diff --git a/benchmarking/benchmark-values.yaml b/benchmarking/benchmark-values.yaml
new file mode 100644
index 000000000..1ef8ae71b
--- /dev/null
+++ b/benchmarking/benchmark-values.yaml
@@ -0,0 +1,63 @@
+job:
+  image:
+    repository: quay.io/inference-perf/inference-perf
+    tag: "latest" # Defaults to .Chart.AppVersion
+  serviceAccountName: ""
+  nodeSelector: {}
+  # Example resources:
+  # resources:
+  #   requests:
+  #     cpu: "1"
+  #     memory: "4Gi"
+  #   limits:
+  #     cpu: "2"
+  #     memory: "8Gi"
+  resources: {}
+
+logLevel: INFO
+
+# A GCS bucket path that points to the dataset file.
+# The file will be copied from this path to the local file system
+# at /dataset/dataset.json for use during the run.
+# NOTE: For this dataset to be used, config.data.path must also be explicitly set to /dataset/dataset.json.
+gcsPath: ""
+
+# hfToken optionally creates a secret with the specified token.
+# Can be set using helm install --set hftoken=<token>
+hfToken: ""
+
+config:
+  load:
+    type: constant
+    interval: 15
+    stages:
+    - rate: 10
+      duration: 20
+    - rate: 20
+      duration: 20
+    - rate: 30
+      duration: 20
+  api:
+    type: completion
+    streaming: true
+  server:
+    type: vllm
+    model_name: meta-llama/Llama-3.1-8B-Instruct
+    base_url: http://0.0.0.0:8000
+    ignore_eos: true
+  tokenizer:
+    pretrained_model_name_or_path: meta-llama/Llama-3.1-8B-Instruct
+  data:
+    type: shareGPT
+  metrics:
+    type: prometheus
+    prometheus:
+      google_managed: true
+  report:
+    request_lifecycle:
+      summary: true
+      per_stage: true
+      per_request: true
+    prometheus:
+      summary: true
+      per_stage: true
diff --git a/benchmarking/benchmark.ipynb b/benchmarking/benchmark.ipynb
new file mode 100644
index 000000000..fe072dd3d
--- /dev/null
+++ b/benchmarking/benchmark.ipynb
@@ -0,0 +1,596 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "executionInfo": {
+          "elapsed": 391,
+          "status": "ok",
+          "timestamp": 1741734317446,
+          "user": {
+            "displayName": "Cong Liu",
+            "userId": "18222691451061354557"
+          },
+          "user_tz": 420
+        },
+        "id": "ziJD5zt0c1Rt"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "<>:8: SyntaxWarning: invalid escape sequence '\\d'\n",
+            "<>:8: SyntaxWarning: invalid escape sequence '\\d'\n",
+            "/tmp/ipykernel_2612482/2189011373.py:8: SyntaxWarning: invalid escape sequence '\\d'\n",
+            "  FILE_MATCHER='.*stage_\\d_lifecycle_metrics*'\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title Configuration. Edit this before running the rest.\n",
+        "\n",
+        "OUTPUT_DIR='output'\n",
+        "RUN_ID='default-run'\n",
+        "# Path to the benchmark dir under `gateway-api-inference-extension/benchmark`\n",
+        "BENCHMARK_DIR =\"./\"\n",
+        "# A regex to match the output file name.\n",
+        "FILE_MATCHER='.*stage_\\d_lifecycle_metrics*'\n",
+        "INTERACTIVE_PLOT='False'"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "executionInfo": {
+          "elapsed": 33,
+          "status": "ok",
+          "timestamp": 1741735749209,
+          "user": {
+            "displayName": "Cong Liu",
+            "userId": "18222691451061354557"
+          },
+          "user_tz": 420
+        },
+        "id": "dB7xALgLawN-"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Plot Helper\n",
+        "import os\n",
+        "import pandas as pd\n",
+        "import re\n",
+        "import json\n",
+        "from collections import OrderedDict\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "import math\n",
+        "from sklearn.metrics import r2_score\n",
+        "import logging\n",
+        "level = logging.INFO\n",
+        "logger = logging.getLogger(__name__)\n",
+        "logger.setLevel(level)\n",
+        "handler = logging.StreamHandler()  # This sends output to the console\n",
+        "handler.setLevel(level) # Set handler level\n",
+        "logger.addHandler(handler)\n",
+        "\n",
+        "title_fontsize = 18\n",
+        "axis_label_fontsize = 18\n",
+        "legend_fontsize = 16\n",
+        "tick_label_fontsize = 14\n",
+        "\n",
+        "# Encapsulates some basic information needed to plot metrics.\n",
+        "class XY:\n",
+        "  def __init__(self, x: str, y: str, x_label=None, y_label=None):\n",
+        "    self.x = x\n",
+        "    self.y = y\n",
+        "    self.x_label = x if x_label is None else x_label\n",
+        "    self.y_label = y if y_label is None else y_label\n",
+        "\n",
+        "NUM_PLOTS_PER_ROW = 4\n",
+        "# The arguments need to match the metric name fields generated by the benchmark tool.\n",
+        "CORE_METRICS = [\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'successes_throughput_output_tokens_per_sec', y_label= 'output_tokens_per_sec'),\n",
+        "    XY(x = \"load_summary_requested_rate\", x_label = 'QPS', y = \"successes_latency_time_per_output_token_p90\", y_label= 'p90_per_output_token_latency'),\n",
+        "    XY(x = \"load_summary_requested_rate\", x_label = 'QPS', y = \"successes_latency_request_latency_p90\", y_label= 'p90_latency'),\n",
+        "    XY(x = \"load_summary_requested_rate\", x_label = 'QPS', y = \"load_summary_count\", y_label= 'num_prompts_attempted'),\n",
+        "    XY(x = \"load_summary_requested_rate\", x_label = 'QPS', y = \"successes_count\", y_label= 'num_prompts_succeeded'),\n",
+        "]\n",
+        "SANITY_CHECK_METRICS = [\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'successes_throughput_requests_per_sec', y_label= 'throughput_rps'),\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'successes_throughput_input_tokens_per_sec', y_label= 'total_input_tokens'),\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'successes_throughput_output_tokens_per_sec', y_label= 'total_output_token'),\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'prompt_len_mean', y_label= 'avg_input_len'),\n",
+        "    XY(x = 'load_summary_requested_rate', x_label = 'QPS', y = 'output_len_mean', y_label= 'avg_output_len'),\n",
+        "]\n",
+        "\n",
+        "class Label:\n",
+        "  def __init__(self, name, alias=None):\n",
+        "    self.name = name\n",
+        "    self.alias = name if alias is None else alias\n",
+        "\n",
+        "ALL_METRICS = CORE_METRICS  + SANITY_CHECK_METRICS\n",
+        "\n",
+        "class Plotter:\n",
+        "  def __init__(self, run_id, labels=None, metrics=CORE_METRICS, num_plots_per_row=5, interactive=False, annotate=False, output_dir=OUTPUT_DIR):\n",
+        "    self.run_id = run_id\n",
+        "    self.labels = labels\n",
+        "    self.metrics = metrics\n",
+        "    self.num_plots_per_row = num_plots_per_row\n",
+        "    self.interactive = interactive\n",
+        "    self.annotate = annotate\n",
+        "    self.output_dir = output_dir\n",
+        "    self.data = load_data(self.labels, self.run_id, self.output_dir)\n",
+        "    self.groups = group_data(self.data, self.metrics)\n",
+        "\n",
+        "  def withRunId(self, run_id):\n",
+        "    return Plotter(run_id, self.labels, self.metrics, self.num_plots_per_row, self.interactive, self.annotate, self.output_dir)\n",
+        "\n",
+        "  def withLabels(self, labels):\n",
+        "    return Plotter(self.run_id, labels, self.metrics, self.num_plots_per_row, self.interactive, self.annotate, self.output_dir)\n",
+        "\n",
+        "  def withMetrics(self, metrics):\n",
+        "    return Plotter(self.run_id, self.labels, metrics, self.num_plots_per_row, self.interactive, self.annotate, self.output_dir)\n",
+        "\n",
+        "  def withOutputDir(self, output_dir):\n",
+        "    return Plotter(self.run_id, self.labels, self.metrics, self.num_plots_per_row, self.interactive, self.annotate, output_dir)\n",
+        "\n",
+        "  def plot_bar(self):\n",
+        "    \n",
+        "    logger.debug(\"Plotting run id...\")\n",
+        "    plot_bar(self.labels, self.groups, self.metrics, self.num_plots_per_row, self.interactive, annotate=self.annotate)\n",
+        "\n",
+        "  def plot_delta(self):\n",
+        "    \"\"\"\n",
+        "    Plot the delta between two labels.\n",
+        "    \"\"\"\n",
+        "    logger.debug(\"Plotting delta for run id...\")\n",
+        "    plot_delta(self.labels, self.groups, self.metrics, self.num_plots_per_row, self.interactive, annotate=self.annotate)\n",
+        "\n",
+        "def filepaths(root_dir):\n",
+        "    \"\"\"\n",
+        "    Recursively reads files within a directory and returns a list of file paths.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    filepaths = []\n",
+        "    for dirpath, dirnames, filenames in os.walk(root_dir):\n",
+        "        for filename in filenames:\n",
+        "            filepath = os.path.join(dirpath, filename)\n",
+        "            filepaths.append(filepath)\n",
+        "    return filepaths\n",
+        "\n",
+        "def flatten_server_metrics(server_metrics):\n",
+        "  \"\"\"\n",
+        "  Flattens the server metrics json to a single level.\n",
+        "  \"\"\"\n",
+        "  flattend = {}\n",
+        "  for k, v in server_metrics.items():\n",
+        "    if isinstance(v, dict):\n",
+        "      for k2, v2 in v.items():\n",
+        "        flattend[k + \".\" + k2] = v2\n",
+        "\n",
+        "  return flattend\n",
+        "\n",
+        "def load_data(labels, run_id, output_dir=OUTPUT_DIR):\n",
+        "  data_path =f\"{BENCHMARK_DIR}/{output_dir}/{run_id}\"\n",
+        "  records = []\n",
+        "  logger.debug(f\"Loading data for {data_path}\")\n",
+        "  for file in filepaths(data_path):\n",
+        "    for label in labels:\n",
+        "      regex = f\".*/{label.name}/results/json/{FILE_MATCHER}.json\"\n",
+        "      logger.debug(f\"matching file {file} for regex {regex} and label {label}\")\n",
+        "      if re.match(regex, file):\n",
+        "        logger.debug(f\"found match file {file} for regex {regex} and label {label}\")\n",
+        "        with open(file, 'r') as f:\n",
+        "          raw_data = json.load(f)\n",
+        "          sample_data = {\n",
+        "              'file_name': f.name,\n",
+        "              'label': label.alias,\n",
+        "          }\n",
+        "          for k, v in raw_data.items():\n",
+        "            if isinstance(v, dict):\n",
+        "              for k2, v2 in v.items():\n",
+        "                if isinstance(v2, dict):\n",
+        "                  for k3, v3 in v2.items():\n",
+        "                    if isinstance(v3, dict):\n",
+        "                      for k4, v4 in v3.items():\n",
+        "                        sample_data[f\"{k}_{k2}_{k3}_{k4}\"] = v4\n",
+        "                    else:\n",
+        "                      sample_data[f\"{k}_{k2}_{k3}\"] = v3\n",
+        "                else:\n",
+        "                    sample_data[f\"{k}_{k2}\"] = v2\n",
+        "            else:\n",
+        "                sample_data[k] = v\n",
+        "          if 'config_load_summary_requested_rate' in sample_data and 'config_num_models' in sample_data:\n",
+        "              sample_data['load_summary_requested_rate'] = sample_data['config_load_summary_requested_rate'] * sample_data['config_num_models']\n",
+        "          records.append(sample_data)\n",
+        "  all_data = pd.DataFrame.from_records(records, index='file_name') if len(records) > 0 else pd.DataFrame()\n",
+        "  return all_data\n",
+        "\n",
+        "def group_data(all_data, metrics=CORE_METRICS):\n",
+        "  try:\n",
+        "    data = all_data.sort_values(by=['load_summary_requested_rate'], ascending=True).copy()\n",
+        "  except Exception as e:\n",
+        "    print(f\"Error sorting data: {e}\")\n",
+        "    return None\n",
+        "\n",
+        "  # Ensure there is exactly one benchmark result per label and x-axis for each\n",
+        "  # metric.\n",
+        "  x_axes = set()\n",
+        "  for m in metrics:\n",
+        "    x_axes.add(m.x)\n",
+        "\n",
+        "  for x in x_axes:\n",
+        "    # Check for missing columns before grouping\n",
+        "    if 'label' not in data.columns or x not in data.columns:\n",
+        "        print(f\"Missing 'label' or '{x}' column in data, skipping grouping.\")\n",
+        "        continue\n",
+        "    sizes = data.groupby(by=['label', x], dropna=True).size()\n",
+        "    for index, v in sizes.items():\n",
+        "      if v > 1:\n",
+        "        label, _ = index\n",
+        "        # print(f\"Multiple benchmark results for the same label ({label}), and x-axis ({x}). {index}: {v}. Please use more selective file filters.\")\n",
+        "        # raise ValueError(f\"Multiple benchmark results for the same label ({label}), and x-axis ({x}). Please use more selective file filters.\")\n",
+        "\n",
+        "  # Group by label.\n",
+        "  if 'label' in data.columns:\n",
+        "    groups = data.groupby(by=['label'],sort=True)\n",
+        "    return groups\n",
+        "  else:\n",
+        "    print(\"Missing 'label' column, cannot group data.\")\n",
+        "    return None\n",
+        "\n",
+        "def compute_r2_for_metrics(groups, metrics, label_before, label_after):\n",
+        "    print(\"\\nCoefficient of Determination (R^2) between before and after runs:\")\n",
+        "    for m in metrics:\n",
+        "        try:\n",
+        "            df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+        "            df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n",
+        "        except KeyError:\n",
+        "            print(f\"  Skipping {m.y}: missing group data for '{label_before}' or '{label_after}'\")\n",
+        "            continue\n",
+        "        common = sorted(set(df_b.index).intersection(df_a.index))\n",
+        "        yb = df_b.loc[common, m.y].values\n",
+        "        ya = df_a.loc[common, m.y].values\n",
+        "        mask = ~np.isnan(yb) & ~np.isnan(ya)\n",
+        "        yb, ya = yb[mask], ya[mask]\n",
+        "        if len(yb) > 1 and np.any(yb != 0):\n",
+        "            r2 = r2_score(yb, ya)\n",
+        "            print(f\"  {m.y:<30} R^2 = {r2:.4f}\")\n",
+        "        else:\n",
+        "            print(f\"  {m.y:<30} insufficient data for R^2 calculation\")\n",
+        "\n",
+        "\n",
+        "def init_plot(metrics, num_plots_per_row=NUM_PLOTS_PER_ROW):\n",
+        "  num_plots_per_row = min(num_plots_per_row, len(metrics))\n",
+        "  row_count = math.ceil(len(metrics) / num_plots_per_row)\n",
+        "  fig, axes = plt.subplots(nrows=row_count, ncols=num_plots_per_row, figsize=(20, 5*row_count), tight_layout=True)\n",
+        "  if row_count == 1 and num_plots_per_row == 1:\n",
+        "    axes = [axes]\n",
+        "  return fig, axes\n",
+        "\n",
+        "def plot_metrics(metrics, plot_func, num_plots_per_row=NUM_PLOTS_PER_ROW, fig=None, axes=None):\n",
+        "  \"\"\"\n",
+        "  plot_func: a function in the form of def plot_func(ax:~matplotlib.axes.Axes , m: XY):\n",
+        "  \"\"\"\n",
+        "  logger.debug(f'Plotting metrics: {metrics}')\n",
+        "  num_plots_per_row = min(num_plots_per_row, len(metrics))\n",
+        "  if fig is None or axes is None:\n",
+        "    logger.debug(f'Creating new figure and axes')\n",
+        "    fig, axes = init_plot(metrics, num_plots_per_row)\n",
+        "  row_count = math.ceil(len(metrics) / num_plots_per_row)\n",
+        "  for i, m in enumerate(metrics):\n",
+        "    row = math.floor(i/num_plots_per_row)\n",
+        "    col = i%num_plots_per_row\n",
+        "    if row_count == 1:\n",
+        "      curAx = axes[col]\n",
+        "    else:\n",
+        "      curAx = axes[row, col]\n",
+        "    plot_func(curAx, m)\n",
+        "  return fig, axes\n",
+        "\n",
+        "def plot_bar(labels, groups, metrics=CORE_METRICS, num_plots_per_row=NUM_PLOTS_PER_ROW, interactive=INTERACTIVE_PLOT, annotate=False):\n",
+        "    labels = [label.alias for label in labels]\n",
+        "    logger.debug(f'Prnting bar chart for {labels}')\n",
+        "    logger.debug(f'groups: {groups}')\n",
+        "    dataframes = []\n",
+        "    for label in labels:\n",
+        "      try:\n",
+        "        dataframes.append(groups.get_group((label,)))\n",
+        "      except:\n",
+        "        logger.debug(f\"No data found for label {label}\")\n",
+        "        continue\n",
+        "    y_columns = [m.y for m in metrics]\n",
+        "    logger.debug(f'y_columns: {y_columns}')\n",
+        "    logger.debug(f'dataframes: {dataframes}')\n",
+        "\n",
+        "    # 1. Combine all request rates\n",
+        "    all_load_summary_requested_rates = set()\n",
+        "    for df in dataframes:\n",
+        "        all_load_summary_requested_rates.update(df['load_summary_requested_rate'].astype(int))\n",
+        "    all_load_summary_requested_rates = sorted(list(all_load_summary_requested_rates))\n",
+        "\n",
+        "    # 2. Prepare data for plotting:  Create a nested dictionary\n",
+        "    plot_data = {y_col: {label: {} for label in labels} for y_col in y_columns}\n",
+        "\n",
+        "    for i, df in enumerate(dataframes):\n",
+        "        label = labels[i]\n",
+        "        df_dict = df.set_index('load_summary_requested_rate').to_dict()\n",
+        "        for y_col in y_columns:\n",
+        "            for load_summary_requested_rate in all_load_summary_requested_rates:\n",
+        "                plot_data[y_col][label][load_summary_requested_rate] = df_dict.get(y_col, {}).get(load_summary_requested_rate, np.nan)\n",
+        "\n",
+        "    logger.debug(f'Plot_data: {plot_data}')\n",
+        "\n",
+        "    # 3. Plotting\n",
+        "    def plot_func(curAx, m):\n",
+        "      num_load_summary_requested_rates = len(all_load_summary_requested_rates)\n",
+        "      num_labels = len(labels)\n",
+        "      x = np.arange(num_load_summary_requested_rates)  # the label locations (x-axis positions)\n",
+        "      width = 0.4 / num_labels   # width of the bars\n",
+        "\n",
+        "      for i, label in enumerate(labels):\n",
+        "          bar_x = x - (width*num_labels)/2 + i*width + width/2\n",
+        "          #Extract y-values to plot\n",
+        "          y_values = [plot_data[m.y][label][rr] for rr in all_load_summary_requested_rates]\n",
+        "\n",
+        "          rects = curAx.bar(bar_x, y_values, width, label=label)\n",
+        "          if annotate:\n",
+        "            for rect, val in zip(rects, y_values):\n",
+        "                if not np.isnan(val):\n",
+        "                    height = rect.get_height()\n",
+        "                    curAx.annotate(f'{val:.2f}',\n",
+        "                            xy=(rect.get_x() + rect.get_width() / 2, height),\n",
+        "                            xytext=(0, 3),  # 3 points vertical offset\n",
+        "                            textcoords=\"offset points\",\n",
+        "                            ha='center', va='bottom')\n",
+        "      # Add labels, title, and legend\n",
+        "      curAx.set_xlabel(m.x_label, fontsize=axis_label_fontsize)\n",
+        "      curAx.set_ylabel(m.y_label, fontsize=axis_label_fontsize)\n",
+        "      curAx.set_xticks(x)\n",
+        "      curAx.set_xticklabels(all_load_summary_requested_rates)\n",
+        "      curAx.tick_params(axis='both', labelsize=tick_label_fontsize)\n",
+        "      curAx.legend(fontsize=legend_fontsize, loc='upper left', frameon=True, framealpha=0.8, edgecolor='black')\n",
+        "    fig, axes = plot_metrics(metrics, plot_func, num_plots_per_row)\n",
+        "    fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
+        "    plt.show()\n",
+        "\n",
+        "def plot_delta(labels, groups, metrics=CORE_METRICS, num_plots_per_row=NUM_PLOTS_PER_ROW, interactive=True, annotate=False):\n",
+        "    \"\"\"\n",
+        "    Plot the delta between base_label and compare_label for each metric.\n",
+        "    A positive delta means compare_label has a higher value than base_label.\n",
+        "    \"\"\"\n",
+        "    base_label = labels[0].name\n",
+        "    compare_label = labels[1].name\n",
+        "    logger.debug(f'Printing delta chart for {base_label} vs {compare_label}')\n",
+        "\n",
+        "    try:\n",
+        "        base_df = groups.get_group((base_label,))\n",
+        "        compare_df = groups.get_group((compare_label,))\n",
+        "    except Exception as e:\n",
+        "        logger.error(f\"Error getting data for labels {base_label} and {compare_label}: {e}\")\n",
+        "        return\n",
+        "\n",
+        "    y_columns = [m.y for m in metrics]\n",
+        "\n",
+        "    # 1. Find common request rates\n",
+        "    base_rates = set(base_df['load_summary_requested_rate'].astype(int))\n",
+        "    compare_rates = set(compare_df['load_summary_requested_rate'].astype(int))\n",
+        "    common_rates = sorted(list(base_rates.intersection(compare_rates)))[:6]\n",
+        "\n",
+        "    if not common_rates:\n",
+        "        logger.error(f\"No common request rates found between {base_label} and {compare_label}\")\n",
+        "        return\n",
+        "\n",
+        "    # 2. Prepare data for delta calculation\n",
+        "    base_data = base_df.set_index('load_summary_requested_rate').to_dict()\n",
+        "    compare_data = compare_df.set_index('load_summary_requested_rate').to_dict()\n",
+        "\n",
+        "    # Calculate deltas (compare_label - base_label)\n",
+        "    delta_data = {y_col: {} for y_col in y_columns}\n",
+        "    for y_col in y_columns:\n",
+        "        for rate in common_rates:\n",
+        "            base_val = base_data.get(y_col, {}).get(rate, np.nan)\n",
+        "            compare_val = compare_data.get(y_col, {}).get(rate, np.nan)\n",
+        "\n",
+        "            if not np.isnan(base_val) and not np.isnan(compare_val):\n",
+        "                delta_data[y_col][rate] = (compare_val - base_val)/base_val*100\n",
+        "            else:\n",
+        "                delta_data[y_col][rate] = np.nan\n",
+        "\n",
+        "    # 3. Plotting\n",
+        "    def plot_func(curAx, m):\n",
+        "        x = np.arange(len(common_rates))\n",
+        "        y_values = [delta_data[m.y].get(rr, np.nan) for rr in common_rates]\n",
+        "\n",
+        "        # Determine colors based on positive/negative values\n",
+        "        colors = ['green' if val > 0 else 'blue' for val in y_values]\n",
+        "\n",
+        "        rects = curAx.bar(x, y_values, 0.6, color=colors)\n",
+        "\n",
+        "        # Add a horizontal line at y=0\n",
+        "        curAx.axhline(y=0, color='black', linestyle='-', linewidth=1)\n",
+        "\n",
+        "        if annotate:\n",
+        "            for rect, val in zip(rects, y_values):\n",
+        "                if not np.isnan(val):\n",
+        "                    height = rect.get_height()\n",
+        "                    # For negative bars, put text above the bar\n",
+        "                    vert_align = 'bottom' if val >= 0 else 'top'\n",
+        "                    y_offset = 3 if val >= 0 else -3\n",
+        "\n",
+        "                    curAx.annotate(f'{val:.2f}',\n",
+        "                            xy=(rect.get_x() + rect.get_width() / 2, val),\n",
+        "                            xytext=(0, y_offset),  # vertical offset\n",
+        "                            textcoords=\"offset points\",\n",
+        "                            ha='center', va=vert_align)\n",
+        "\n",
+        "        # Create a title that shows what this delta represents\n",
+        "        title = f\"Delta: {compare_label} - {base_label} ({m.y})\"\n",
+        "        curAx.set_title(title, fontsize=12)\n",
+        "\n",
+        "        # Add labels\n",
+        "        curAx.set_xlabel(m.x_label, fontsize=axis_label_fontsize)\n",
+        "        #curAx.set_ylabel(f\"% Delta in {m.y_label}\", fontsize=axis_label_fontsize)\n",
+        "        curAx.set_xticks(x)\n",
+        "        curAx.set_xticklabels(common_rates)\n",
+        "        curAx.tick_params(axis='both', labelsize=tick_label_fontsize)\n",
+        "\n",
+        "        # Create a dummy handle for the legend\n",
+        "        legend_handle = [plt.Rectangle((0,0),1,1,color='green'),\n",
+        "                        plt.Rectangle((0,0),1,1,color='blue')]\n",
+        "        legend_label = [f'{compare_label} > {base_label}',\n",
+        "                       f'{compare_label} < {base_label}']\n",
+        "\n",
+        "        return legend_handle, legend_label\n",
+        "\n",
+        "    # Create plot with metrics\n",
+        "    fig, axes = plot_metrics(metrics, plot_func, num_plots_per_row)\n",
+        "\n",
+        "    # Add an overall title for the figure\n",
+        "    fig.suptitle(f\"% Delta Metrics: {compare_label} - {base_label}\",\n",
+        "                fontsize=title_fontsize, y=0.98)\n",
+        "\n",
+        "    plt.subplots_adjust(bottom=0.15, top=0.9)  # Make room for legends\n",
+        "    fig.tight_layout(rect=[0, 0.1, 1, 0.95])  # Adjust the rectangle in which the subplots fit\n",
+        "    plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "height": 1000
+        },
+        "executionInfo": {
+          "elapsed": 2232,
+          "status": "ok",
+          "timestamp": 1741735855456,
+          "user": {
+            "displayName": "Cong Liu",
+            "userId": "18222691451061354557"
+          },
+          "user_tz": 420
+        },
+        "id": "HbGEAOucb_Jn",
+        "outputId": "faf0304b-92f4-4fa7-ae71-83b8bd987e70"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 2000x500 with 5 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 2000x500 with 5 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Coefficient of Determination (R^2) between before and after runs:\n",
+            "  successes_throughput_output_tokens_per_sec R^2 = 1.0000\n",
+            "  successes_latency_time_per_output_token_p90 R^2 = 1.0000\n",
+            "  successes_latency_request_latency_p90 R^2 = 1.0000\n",
+            "  load_summary_count             R^2 = 1.0000\n",
+            "  successes_count                R^2 = 1.0000\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_2612482/1457368969.py:189: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:190: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:189: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:190: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:189: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:190: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:189: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:190: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:189: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_b = groups.get_group(label_before).set_index('load_summary_requested_rate')\n",
+            "/tmp/ipykernel_2612482/1457368969.py:190: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
+            "  df_a = groups.get_group(label_after).set_index('load_summary_requested_rate')\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title Plot Result\n",
+        "# initialize the plotter with the run id and labels. \n",
+        "# Example labels are 'inference-extension' and 'k8s-svc' if comparing Inference Extension and K8s Service \n",
+        "# 'regression-before' and 'regression-after' if comparing two different runs of inference extension to see the regression\n",
+        "\n",
+        "benchmark_id1 =  'inference-extension' # eg 'regression-before' or 'inference-extension'\n",
+        "benchmark_id2 = 'inference-extension' # eg 'regression-after' or 'k8s-svc'\n",
+        "labels = [Label(benchmark_id1), Label(benchmark_id2,)]\n",
+        "\n",
+        "# Plot bar chart of metrics\n",
+        "pl = Plotter(run_id=RUN_ID, labels=labels, output_dir=OUTPUT_DIR)\n",
+        "pl.plot_bar()\n",
+        "pl.plot_delta()\n",
+        "\n",
+        "# Load & group data to compute R^2\n",
+        "all_data = load_data(labels, RUN_ID, OUTPUT_DIR)\n",
+        "groups = group_data(all_data)\n",
+        "compute_r2_for_metrics(groups, CORE_METRICS,\n",
+        "                           label_before=benchmark_id1,\n",
+        "                           label_after=benchmark_id2)\n",
+        "\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "last_runtime": {
+        "build_target": "",
+        "kind": "local"
+      },
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Inference Perf (.venv)",
+      "language": "python",
+      "name": "inference-perf"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.13.7"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/benchmarking/download-gcs-results.bash b/benchmarking/download-gcs-results.bash
new file mode 100755
index 000000000..edefb49d9
--- /dev/null
+++ b/benchmarking/download-gcs-results.bash
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Downloads a file from a GCS bucket.
+
+# Check if GCS_BUCKET is provided as an argument
+if [ -z "$1" ]; then
+  echo "Usage: $0 <GCS_BUCKET> [GCS_FOLDER_PATH:DEFAULT=benchmark_results]"
+  exit 1
+fi
+
+GCS_BUCKET="$1"
+GCS_FOLDER_PATH="${2:-benchmark_results/}" # Default to benchmark_results/ if not provided
+
+# Env vars to be passed when calling this script.
+# The id of the benchmark. This is needed to identify what the benchmark is for.
+# It decides the filepath to save the results, which later is used by the jupyter notebook to assign
+# the benchmark_id as data labels for plotting.
+benchmark_id=${benchmark_id:-"inference-extension"}
+# run_id can be used to group different runs of the same benchmarks for comparison.
+run_id=${run_id:-"default-run"}
+output_dir=${output_dir:-'output'}
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+benchmark_output_dir=${SCRIPT_DIR}/${output_dir}/${run_id}/${benchmark_id}
+
+echo "Creating output directory: ${benchmark_output_dir}/results/json/"
+mkdir -p "${benchmark_output_dir}/results/json/"
+
+echo "Downloading gs://${GCS_BUCKET}/${GCS_FOLDER_PATH} to ${benchmark_output_dir}/results/json/"
+gsutil cp -r "gs://${GCS_BUCKET}/${GCS_FOLDER_PATH}" "${benchmark_output_dir}/results/json/"
+
+echo "Download complete."
diff --git a/benchmarking/inference-perf/.helmignore b/benchmarking/inference-perf/.helmignore
new file mode 100644
index 000000000..0e8a0eb36
--- /dev/null
+++ b/benchmarking/inference-perf/.helmignore
@@ -0,0 +1,23 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*.orig
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj
+.vscode/
diff --git a/benchmarking/inference-perf/Chart.yaml b/benchmarking/inference-perf/Chart.yaml
new file mode 100644
index 000000000..0295e06ef
--- /dev/null
+++ b/benchmarking/inference-perf/Chart.yaml
@@ -0,0 +1,6 @@
+apiVersion: v2
+name: inference-perf
+description: A Helm chart for running inference-perf benchmarking tool
+type: application
+version: 0.2.0
+appVersion: "0.2.0"
diff --git a/benchmarking/inference-perf/README.md b/benchmarking/inference-perf/README.md
new file mode 100644
index 000000000..54fdd3edd
--- /dev/null
+++ b/benchmarking/inference-perf/README.md
@@ -0,0 +1,85 @@
+## 🚀 Deploying `inference-perf` via Helm Chart
+
+This guide explains how to deploy `inference-perf` to a Kubernetes cluster with Helm.
+
+Note: This is a temporary chart added until remote chart is available.
+
+---
+
+### 1. Prerequisites
+
+Make sure you have the following tools installed and configured:
+
+* **Kubernetes Cluster:** Access to a functional cluster (e.g., GKE).
+* **Helm:** The Helm CLI installed locally.
+
+---
+
+### 2. Configuration (`values.yaml`)
+
+Before deployment, navigate to the **`deploy/inference-perf`** directory and edit the **`values.yaml`** file to customize your deployment and the benchmark parameters.
+
+#### Optional Parameters
+
+| Key | Description | Default |
+| :--- | :--- | :--- |
+| `hfToken` | Hugging Face API token. If provided, a Kubernetes `Secret` named `hf-token-secret` will be created for authentication. | `""` |
+| `serviceAccountName` | Standard Kubernetes `serviceAccountName`. If not provided, default service account is used. | `""` |
+| `nodeSelector` |  Standard Kubernetes `nodeSelector` map to constrain pod placement to nodes with matching labels. | `{}` |
+| `resources` | Standard Kubernetes resource requests and limits for the main `inference-perf` container. | `{}` |
+---
+
+> **Example Resource Block:**
+> ```yaml
+> # resources:
+> #   requests:
+> #     cpu: "1"
+> #     memory: "4Gi"
+> #   limits:
+> #     cpu: "2"
+> #     memory: "8Gi"
+> ```
+
+#### GKE Specific Parameters
+
+This section details the necessary configuration and permissions for using a Google Cloud Storage (GCS) path to manage your dataset, typical for deployments on GKE.
+
+##### Required IAM Permissions
+
+The identity executing the workload (e.g., the associated Kubernetes Service Account, often configured via **Workload Identity**) must possess the following IAM roles on the target GCS bucket for data transfer:
+
+* **`roles/storage.objectViewer`** (Required to read/download the input dataset from GCS).
+* **`roles/storage.objectCreator`** (Required to write/push benchmark results back to GCS).
+
+
+| Key | Description | Default |
+| :--- | :--- | :--- |
+| `gcsPath` | A GCS URI pointing to the dataset file (e.g., `gs://my-bucket/dataset.json`). The file will be automatically copied to the running pod during initialization. | `""` |
+
+---
+
+### 3. Run Deployment
+
+Use the **`helm install`** command from the **`deploy/inference-perf`** directory to deploy the chart.
+
+* **Standard Install:** Deploy using the default `values.yaml`.
+    ```bash
+    helm install test .
+    ```
+
+* **Set `hfToken` Override:** Pass the Hugging Face token directly.
+    ```bash
+    helm install test . --set hfToken="<TOKEN>"
+    ```
+
+* **Custom Config Override:** Make changes to the values file for custom settings.
+    ```bash
+    helm install test . -f values.yaml
+    ```
+
+### 4. Cleanup
+
+To remove the benchmark deployment.
+    ```bash
+    helm uninstall test
+    ```
\ No newline at end of file
diff --git a/benchmarking/inference-perf/templates/_helpers.tpl b/benchmarking/inference-perf/templates/_helpers.tpl
new file mode 100644
index 000000000..e3f6f5715
--- /dev/null
+++ b/benchmarking/inference-perf/templates/_helpers.tpl
@@ -0,0 +1,72 @@
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "inference-perf.name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+If release name contains chart name it will be used as a full name.
+*/}}
+{{- define "inference-perf.fullname" -}}
+{{- if .Values.fullnameOverride }}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- $name := default .Chart.Name .Values.nameOverride }}
+{{- if contains $name .Release.Name }}
+{{- .Release.Name | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "inference-perf.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Common labels
+*/}}
+{{- define "inference-perf.labels" -}}
+helm.sh/chart: {{ include "inference-perf.chart" . }}
+{{ include "inference-perf.selectorLabels" . }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end }}
+
+{{/*
+Selector labels
+*/}}
+{{- define "inference-perf.selectorLabels" -}}
+app.kubernetes.io/name: {{ include "inference-perf.name" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- end }}
+
+{{/*
+Common Secret Name for HuggingFace credentials
+*/}}
+{{- define "inference-perf.hfSecret" -}}
+{{ include "inference-perf.fullname" . }}-hf-secret
+{{- end -}}
+
+{{/*
+Common Secret Key for HuggingFace credentials
+*/}}
+{{- define "inference-perf.hfKey" -}}
+{{ include "inference-perf.fullname" . }}-hf-key
+{{- end -}}
+
+{{/*
+Mount path for config map
+*/}}
+{{- define "inference-perf.configMount" -}}
+/cfg
+{{- end -}}
\ No newline at end of file
diff --git a/benchmarking/inference-perf/templates/configmap.yaml b/benchmarking/inference-perf/templates/configmap.yaml
new file mode 100644
index 000000000..aec22aa8c
--- /dev/null
+++ b/benchmarking/inference-perf/templates/configmap.yaml
@@ -0,0 +1,10 @@
+# inference-perf/templates/configmap.yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "inference-perf.fullname" . }}-config
+  labels:
+    {{- include "inference-perf.labels" . | nindent 4 }}
+data:
+  config.yml: |
+    {{- toYaml .Values.config | nindent 4 }}
\ No newline at end of file
diff --git a/benchmarking/inference-perf/templates/job.yaml b/benchmarking/inference-perf/templates/job.yaml
new file mode 100644
index 000000000..83a61f862
--- /dev/null
+++ b/benchmarking/inference-perf/templates/job.yaml
@@ -0,0 +1,57 @@
+# inference-perf/templates/job.yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: {{ include "inference-perf.fullname" . }}-job
+  labels:
+    {{- include "inference-perf.labels" . | nindent 4 }}
+    app: inference-perf
+spec:
+  template:
+    metadata:
+      labels:
+        {{- include "inference-perf.selectorLabels" . | nindent 8 }}
+        app: inference-perf
+    spec:
+      restartPolicy: Never
+      serviceAccountName: {{ .Values.job.serviceAccountName }}
+      {{- with .Values.job.nodeSelector }}
+      nodeSelector:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+{{- if .Values.gcsPath}}
+      initContainers:
+        - name: fetch-dataset
+          image: google/cloud-sdk:latest
+          command: ["sh", "-c", "gsutil cp {{ .Values.gcsPath }} /dataset/dataset.json"]
+          volumeMounts:
+            - name: dataset-volume
+              mountPath: /dataset
+{{- end }}
+      containers:
+        - name: inference-perf-container
+          image: "{{ .Values.job.image.repository }}:{{ .Values.job.image.tag | default .Chart.AppVersion }}"
+          command: ["inference-perf"]
+          args:
+            - "--config_file"
+            - "{{ include "inference-perf.configMount" . }}/config.yml"
+            - "--log-level"
+            - {{ .Values.logLevel }}
+          env:
+            {{- if .Values.hfToken }}
+            - name: HF_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  name: {{ include "inference-perf.hfSecret" . }}
+                  key: {{ include "inference-perf.hfKey" . }}
+            {{- end }}
+          volumeMounts:
+            - name: config-volume
+              mountPath: {{ include "inference-perf.configMount" . }}
+              readOnly: true
+          resources:
+            {{- toYaml .Values.job.resources | nindent 12 }}
+      volumes:
+        - name: config-volume
+          configMap:
+            name: {{ include "inference-perf.fullname" . }}-config
diff --git a/benchmarking/inference-perf/templates/secret.yaml b/benchmarking/inference-perf/templates/secret.yaml
new file mode 100644
index 000000000..66c9cff84
--- /dev/null
+++ b/benchmarking/inference-perf/templates/secret.yaml
@@ -0,0 +1,12 @@
+# inference-perf/templates/secret.yaml
+{{- if .Values.hfToken }}
+apiVersion: v1
+kind: Secret
+metadata:
+  name: {{ include "inference-perf.hfSecret" . }}
+  labels:
+    {{- include "inference-perf.labels" . | nindent 4 }}
+type: Opaque
+stringData:
+  {{ include "inference-perf.hfKey" . }}: {{ .Values.hfToken | quote }}
+{{- end }}
diff --git a/site-src/performance/benchmark/index.md b/site-src/performance/benchmark/index.md
index 42d5e727b..6aaed4baa 100644
--- a/site-src/performance/benchmark/index.md
+++ b/site-src/performance/benchmark/index.md
@@ -32,15 +32,75 @@ kubectl expose deployment vllm-llama3-8b-instruct --port=80 --target-port=8000 -
 
 ## Run benchmark
 
-The LPG benchmark tool works by sending traffic to the specified target IP and port, and collecting the results.
-Follow the steps below to run a single benchmark. Multiple LPG instances can be deployed to run benchmarks in
+The inference perf tool works by sending traffic to the specified target IP and port, and collecting the results.
+Follow the steps below to run a single benchmark. Multiple benchmarking instances can be deployed to run benchmarks in
 parallel against different targets.
 
+#### Parameters to customize:
+
+For more parameter customizations, refer to inference-perf [guides](https://github.com/kubernetes-sigs/inference-perf/blob/main/docs/config.md)
+
+*   `benchmark`: A unique name for this deployment.
+*   `hfToken`: Your hugging face token.
+*   `config.server.base_url`: The base URL (IP and port) of your inference server.
+
+### Storage Parameters
+
+    Note: Currently inference-perf outputs benchmark results to standard output only, and results will be deleted once pod is finished running the job.
+
+
+#### 1. Local Storage (Default)
+
+By default, reports are saved locally but **lost when the Pod terminates**.
+```yaml
+storage:
+  local_storage:
+    path: "reports-{timestamp}"       # Local directory path
+    report_file_prefix: null          # Optional filename prefix
+```
+
+#### 2. Google Cloud Storage (GCS)
+
+Use the `google_cloud_storage` block to save reports to a GCS bucket.
+
+```yaml
+storage:
+  google_cloud_storage:               # Optional GCS configuration
+    bucket_name: "your-bucket-name"   # Required GCS bucket
+    path: "reports-{timestamp}"       # Optional path prefix
+    report_file_prefix: null          # Optional filename prefix
+```
+
+###### 🚨 GCS Permissions Checklist (Required for Write Access)
+
+1. **IAM Role (Service Account):** Bound to the target bucket.
+
+   * **Minimum:** **Storage Object Creator** (`roles/storage.objectCreator`)
+
+   * **Full:** **Storage Object Admin** (`roles/storage.objectAdmin`)
+
+2. **Node Access Scope (GKE Node Pool):** Set during node pool creation.
+
+   * **Required Scope:** **`devstorage.read_write`** or **`cloud-platform`**
+
+#### 3. Simple Storage Service (S3)
+
+Use the `simple_storage_service` block for S3-compatible storage. Requires appropriate AWS credentials configured in the runtime environment.
+
+```yaml
+storage:
+  simple_storage_service:
+    bucket_name: "your-bucket-name"   # Required S3 bucket
+    path: "reports-{timestamp}"       # Optional path prefix
+    report_file_prefix: null          # Optional filename prefix
+```
+### Steps to Deploy
+
 1. Check out the repo.
 
     ```bash
     git clone https://github.com/kubernetes-sigs/gateway-api-inference-extension
-    cd gateway-api-inference-extension
+    cd gateway-api-inference-extension/benchmarking
     ```
 
 1. Get the target IP. The examples below shows how to get the IP of a gateway or a k8s service.
@@ -49,32 +109,51 @@ parallel against different targets.
     # Get gateway IP
     GW_IP=$(kubectl get gateway/inference-gateway -o jsonpath='{.status.addresses[0].value}')
     # Get LoadBalancer k8s service IP
-    SVC_IP=$(kubectl get service/vllm-llama2-7b -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
+    SVC_IP=$(kubectl get service/vllm-llama3-8b-instruct -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
 
     echo $GW_IP
     echo $SVC_IP
     ```
 
-1. Then update the `<target-ip>` in `./config/manifests/benchmark/benchmark.yaml` to the value of `$SVC_IP` or `$GW_IP`.
-   Feel free to adjust other parameters such as `request_rates` as well. For a complete list of LPG configurations, refer to the
-   [LPG user guide](https://github.com/AI-Hypercomputer/inference-benchmark?tab=readme-ov-file#configuring-the-benchmark).
+1. Deploy Benchmark Tool. 
 
-1. Start the benchmark tool.
+    ```bash
+    export PORT='<YOUR_PORT>'
+    export HF_TOKEN='<YOUR_HUGGINGFACE_TOKEN>'
+    helm install igw-benchmark inference-perf/ -f benchmark-values.yaml \
+    --set hfToken=${HF_TOKEN} \
+    --set "config.server.base_url=http://${GW_IP}:${PORT}"
+
+    export PORT='<YOUR_PORT>'
+    export HF_TOKEN='<YOUR_HUGGINGFACE_TOKEN>'
+    helm install k8s-benchmark inference-perf/ -f benchmark-values.yaml \
+    --set hfToken=${HF_TOKEN} \
+    --set "config.server.base_url=http://${SVC_IP}:${PORT}"
+    ```
+
+1. Wait for benchmark to finish and download the results. Follow inference-perf [guides](https://github.com/kubernetes-sigs/inference-perf on how to access logs. At this moment logs are deleted from the pod if using local storage.
+
+    #### GCS Benchmarking Script
+
+     If storing results in GCS, you can use the `download-gcs-results.bash` script.
+
+    Use the `benchmark_id` environment variable to specify what this
+   benchmark is for. For instance, `inference-extension` or `k8s-svc`.
 
     ```bash
-    kubectl apply -f ./config/manifests/benchmark/benchmark.yaml
+    benchmark_id='k8s-svc' ./download-gcs-results.bash <GCS_BUCKET> <GCS_FOLDER>
+
+    benchmark_id='inference-extension' ./download-gcs-results.bash <GCS_BUCKET> <GCS_FOLDER>
     ```
 
-1. Wait for benchmark to finish and download the results. Use the `benchmark_id` environment variable to specify what this
-   benchmark is for. For instance, `inference-extension` or `k8s-svc`. When the LPG tool finishes benchmarking, it will print
-   a log line `LPG_FINISHED`. The script below will watch for that log line and then start downloading results.
+    After the script finishes, you should see benchmark results under `./benchmarking/output/default-run/k8s-svc/results/json/<GCS_FOLDER>`.
+
+1. Uninstall the chart to tear down resources
 
     ```bash
-    benchmark_id='k8s-svc' ./tools/benchmark/download-benchmark-results.bash
+    helm uninstall igw-benchmark k8s-benchmark
     ```
 
-    After the script finishes, you should see benchmark results under `./tools/benchmark/output/default-run/k8s-svc/results/json` folder.
-    Here is a [sample json file](./sample.json). Replace `k8s-svc` with `inference-extension` when running an inference extension benchmark.
 
 ### Tips
 
@@ -82,11 +161,11 @@ parallel against different targets.
   updated accordingly to analyze the results.
 * You can specify `run_id="runX"` environment variable when running the `./download-benchmark-results.bash` script.
 This is useful when you run benchmarks multiple times to get a more statistically meaningful results and group the results accordingly.
-* Update the `request_rates` that best suit your benchmark environment.
+* Update the `stages` to request rates that best suit your benchmark environment.
 
 ### Advanced Benchmark Configurations
 
-Refer to the [LPG user guide](https://github.com/AI-Hypercomputer/inference-benchmark?tab=readme-ov-file#configuring-the-benchmark) for a
+Refer to the inference-perf [guides](https://github.com/kubernetes-sigs/inference-perf/blob/main/docs/config.md) for a
 detailed list of configuration knobs.
 
 ## Analyze the results
@@ -106,7 +185,7 @@ This guide shows how to run the jupyter notebook using vscode after completing k
     pip install -r ./tools/benchmark/requirements.txt
     ```
 
-1. Open the notebook `./tools/benchmark/benchmark.ipynb`, and run each cell. In the last cell update the benchmark ids with`inference-extension` and `k8s-svc`. At the end you should
+1. Open the notebook `./benchmarking/benchmark.ipynb`, and run each cell. In the last cell update the benchmark ids with`inference-extension` and `k8s-svc`. At the end you should
     see a bar chart like below where **"ie"** represents inference extension. This chart is generated using this benchmarking tool with 6 vLLM (v1) model servers (H100 80 GB), [llama2-7b](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf/tree/main) and the [ShareGPT dataset](https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/ShareGPT_V3_unfiltered_cleaned_split.json).
     
     ![alt text](example-bar-chart.png)
\ No newline at end of file