@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import json
+import re
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -64,23 +65,57 @@ def _mpl():
     plt = _plt
     return plt
 
-# display order + labels. A gateway appears in a chart only if it has a result file this run.
-GATEWAYS = {
-    # Alphabetical by key — deliberately NOT busbar-first. Order here is only the input/load order;
-    # every chart and the report tables sort by the MEASURED value, so placement never favors anyone.
-    "apisix": "APISIX",
-    "arch": "Arch",
-    "bifrost": "Bifrost",
-    "busbar": "Busbar",
-    "gomodel": "GoModel",
-    "helicone": "Helicone",
-    "kong": "Kong",
-    "litellm-python": "LiteLLM · Python",
-    "litellm-rust": "LiteLLM · Rust",
-    "one-api": "One-API",
-    "portkey": "Portkey",
-    "tensorzero": "TensorZero",
+# ── the field is discovered from the manifests, nothing is hard-coded here ─────────────────────────
+# Each gateway is fully defined by its own dir: gateways/<key>/gateway.sh declares GW_DISPLAY (label),
+# GW_LANG (color bucket), and GW_REPO (linked from the name in the report table). Add a dir → it shows
+# up in the charts/tables/run-lists; delete it → it's gone everywhere. A gateway only appears in a
+# chart once it also has a result file this run. Alphabetical by key — deliberately NOT busbar-first;
+# order here is only load order, every chart + table sorts by the MEASURED value.
+def _manifest_meta():
+    out = {}
+    for man in sorted((ROOT / "gateways").glob("*/gateway.sh")):
+        key = man.parent.name
+        txt = man.read_text()
+
+        def grab(var, default=""):
+            m = re.search(rf'^{var}=(.*)$', txt, re.M)
+            if not m:
+                return default
+            v = m.group(1).split("#", 1)[0].strip()          # drop trailing comment
+            return v.strip('"').strip("'").strip()
+
+        out[key] = {
+            "display": grab("GW_DISPLAY", key),
+            "lang": grab("GW_LANG", "Other"),
+            "repo": grab("GW_REPO"),
+        }
+    return out
+
+_META = _manifest_meta()
+GATEWAYS = {k: v["display"] for k, v in _META.items()}   # key → display label
+LANGS = {k: v["lang"] for k, v in _META.items()}         # key → language bucket
+REPOS = {k: v["repo"] for k, v in _META.items()}         # key → GitHub URL (may be "")
+
+
+def _linked(key: str) -> str:
+    """Gateway display name for the report table, linked to its GitHub repo when the manifest gives one."""
+    name = GATEWAYS.get(key, key)
+    repo = REPOS.get(key)
+    return f"[{name}]({repo})" if repo else name
+
+# Bars are colored by the gateway's IMPLEMENTATION LANGUAGE — informative (you can see the Rust/Go/
+# Python clustering) and neutral (no "winner" highlight for the sponsor; the best is already the top
+# bar since rows are sorted). A gateway that didn't serve is drawn grey regardless.
+# Five buckets: Rust / Go / Python / Node / Other (Lua/OpenResty, Envoy/C++, … fold into Other).
+LANG_ORDER = ["Rust", "Go", "Python", "Node", "Other"]
+LANG_COLORS = {
+    "Rust": "#c4602d",     # orange
+    "Go": "#00a0c6",       # cyan
+    "Python": "#3b6ea5",   # blue
+    "Node": "#c59b2d",     # amber
+    "Other": "#6b7280",    # grey
 }
+LANG_DEFAULT = "#6b7280"
 
 
 @dataclass(frozen=True)
@@ -260,10 +295,10 @@ def _numlab(v: float) -> str:
         vals = [float(r.get(s.field, 0) or 0) for r in rows]
         rank = s.kind == "rank"
         if rank:
-            # green = served winner; slate = served; muted = did-not-serve (bar is context only).
-            colors = [BRAND if (best is not None and _served(r) and v == best)
-                      else (SLATE if _served(r) else MUTE)
-                      for r, v in zip(rows, vals)]
+            # colored by implementation language (served); did-not-serve is drawn grey. No winner
+            # highlight — the best is already the top bar (rows are sorted).
+            colors = [LANG_COLORS.get(LANGS.get(r["_key"], ""), LANG_DEFAULT) if _served(r) else MUTE
+                      for r in rows]
         else:
             colors = [s.kind] * n
         # On a log axis a bar can't start at 0, and a negative/zero value can't be drawn at all.
@@ -323,17 +358,27 @@ def _numlab(v: float) -> str:
     ax.set_title(chart.title, fontsize=15, fontweight="bold", color=INK, loc="left", pad=38)
     ax.text(0, 1.035, chart.subtitle, transform=ax.transAxes, fontsize=10.5, color=GRAY, va="bottom")
 
-    # legend (only multi-series charts need it)
-    if ns > 1:
-        ax.legend(loc="lower right", fontsize=9, frameon=False, ncols=ns)
+    # Language legend (swatch per language present) + a note for the secondary series (e.g. idle RAM).
+    from matplotlib.patches import Patch
+    present = [l for l in LANG_ORDER if any(_served(r) and LANGS.get(r["_key"]) == l for r in rows)]
+    handles = [Patch(facecolor=LANG_COLORS[l], label=l) for l in present]
+    if any(not _served(r) for r in rows):
+        handles.append(Patch(facecolor=MUTE, label="did not serve"))
+    if ns > 1:  # a muted secondary series (idle RAM) — label it too
+        handles.append(Patch(facecolor=MUTE, label=chart.series[1].legend))
+    if handles:
+        # "best" so the swatch box lands in whitespace (top bars are short on the log charts, longest
+        # bars crowd the bottom) instead of sitting over a bar.
+        ax.legend(handles=handles, loc="best", fontsize=8.5, frameon=False,
+                  ncols=min(len(handles), 6), title="colored by language")
 
     meta = rows[0]
     bits = []
     if "hardware" in meta:
         bits.append(str(meta["hardware"]))
     if "concurrency" in meta and "payload_bytes" in meta:
         bits.append(f"{meta['concurrency']}× {int(meta['payload_bytes'])//1000}KB sustained")
-    bits.append("highlighted = measured best")
+    bits.append("bars colored by implementation language")
     fig.text(0.008, 0.012, "  ·  ".join(bits) + f"     github.com/GetBusbar/benchmarking — regenerated {RENDER_TS} from raw results",
              fontsize=7.3, color=GRAY)
 
@@ -364,8 +409,9 @@ def _report_md(rows: list, title: str, charts: list, pending: tuple = (), chart_
     lines.append(f"**Ran on:** {hw}  ·  {when}")
     lines.append("")
     lines.append("Every number below is regenerated from the raw `results/*.json` — re-run "
-                 "`run-all.sh` and this page updates. The highlighted bar in each chart = measured best. "
-                 "**Rows are sorted by added latency (p99), lowest first.**")
+                 "`run-all.sh` and this page updates. Chart bars are **colored by implementation "
+                 "language** (Rust / Go / Python / Node / Other). **Rows are sorted by added latency "
+                 "(p99), lowest first.**")
     lines.append("")
     lines.append("| Gateway | Added latency (p99) | Sustained RPS @20ms | Max proxy RPS | Idle RAM | Peak RAM | Built |")
     lines.append("|---|--:|--:|--:|--:|--:|---|")
@@ -407,7 +453,7 @@ def rps_cell(val, bound, served):
         if served is False and r.get("serve_error"):
             fail_notes.append((GATEWAYS[key], str(r.get("serve_error"))))
         lines.append(
-            f"| {GATEWAYS[key]} "
+            f"| {_linked(key)} "
             f"| {lat_cell} "
             f"| {llm} "
             f"| {proxy} "
@@ -418,7 +464,7 @@ def rps_cell(val, bound, served):
     # Gateways we intend to measure but haven't yet — shown so the field is transparent, never hidden.
     for key in pending:
         lines.append(
-            f"| {GATEWAYS[key]} | ⏳ *pending* | — | — | — | — | *pending measurement* |"
+            f"| {_linked(key)} | ⏳ *pending* | — | — | — | — | *pending measurement* |"
         )
     lines.append("")
     if pending:
 
@@ -6,10 +6,21 @@ directory.** The runners (`memory/run.sh`, and friends) are gateway-agnostic: th
 
 ## The contract
 
-`gateways/<name>/gateway.sh` sets four variables and defines four functions:
+A gateway is defined **entirely by its own directory** — nothing about it is hard-coded in the
+runners, the charts, or the run lists. `run-all.sh`, `run-on-ec2.sh`, and `charts.py` all discover the
+field by scanning `gateways/*/gateway.sh`, so **adding a dir adds the gateway everywhere and deleting a
+dir removes it everywhere.** No list to keep in sync.
+
+`gateways/<name>/gateway.sh` sets these variables and defines four functions:
 
 ```sh
 GW_KIND=native|docker      # informational
+
+# Self-describing metadata — charts.py + the report tables read these straight from the manifest.
+GW_DISPLAY="Busbar"        # label shown in charts and the report table
+GW_LANG=Rust               # implementation language → bar color bucket (Rust|Go|Python|Node|Other)
+GW_REPO=https://github.com/GetBusbar/busbar   # the gateway name in the table links here
+
 GW_PORT=8080               # port the gateway listens on
 GW_PATH=/v1/chat/completions   # request path used to probe + load it
 GW_MODEL=gpt-4o-mini       # model string put in the request body
@@ -21,6 +32,11 @@ gw_rss()    { :; }         # echo current resident memory in MiB
 gw_stop()   { :; }         # stop + clean up
 ```
 
+`GW_LANG` colors the bars by language (Rust / Go / Python / Node / Other — anything else, e.g.
+OpenResty/Lua or an Envoy/C++ data plane, folds into Other). There is **no winner highlight**: charts
+sort by the measured value, so the best is already the top bar. A gateway that didn't serve is drawn
+grey regardless of language.
+
 The runner exports for you: `$MOCK_PORT` (deterministic mock upstream), `$CORES` (cpu pin),
 `$GW_DIR` (this gateway's directory, for config files).
 
@@ -30,12 +46,12 @@ and it just works. The mock answers both shapes (OpenAI by default, Anthropic fo
 
 ## Shipped gateways
 
-**In the default run** (serve the mock as a single-box drop-in):
-
-Listed alphabetically — no gateway is seated first.
+**In the default run** (serve the mock as a single-box drop-in). This table is illustrative — the
+actual field is whatever dirs exist here; alphabetical, no gateway seated first.
 
 | dir | what | notes |
 |---|---|---|
+| `agentgateway/` | agentgateway (Rust data plane, docker) | `ai` backend `hostOverride`/`pathOverride` → mock; no backendAuth/backendTLS; observability off |
 | `apisix/` | Apache APISIX + `ai-proxy` (docker, DB-less standalone) | `override.endpoint` → mock; no etcd; access log off, workers = pinned cores |
 | `arch/` | Arch (Katanemo, `archgw` CLI) | Envoy + Arch services in one arm64 container; egress-only config → mock; containers pinned to the gateway cores |
 | `bifrost/` | maximhq/bifrost (docker) | openai provider base_url → mock; runs its stock config |
 
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# Gateway manifest: agentgateway (agentgateway/agentgateway, Rust data plane, docker).
+#
+# OpenAI-compatible bare proxy: the `ai` backend's openAI provider takes hostOverride + pathOverride
+# to point the upstream at the mock. No backendAuth (no key added) and no backendTLS (plain HTTP to the
+# mock). Tracing is off unless an OTLP endpoint is set; metrics are pull-only; admin/stats pinned to
+# loopback and RUST_LOG=error → clean overhead. AGENTGATEWAY_IMAGE is pinned in gateways/versions.env.
+GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="agentgateway"                      # label in charts + report tables
+GW_LANG=Rust                            # implementation language → bar color bucket
+GW_REPO=https://github.com/agentgateway/agentgateway   # linked from the gateway name in the report table
+GW_PORT=8080
+GW_PATH=/v1/chat/completions
+GW_MODEL=gpt-4o-mini
+GW_AUTH=dummy
+AGENTGATEWAY_IMAGE="${AGENTGATEWAY_IMAGE:-ghcr.io/agentgateway/agentgateway:v1.3.1}"
+
+gw_version() {
+  local dg; dg=$(sudo docker inspect --format '{{index .RepoDigests 0}}' "$AGENTGATEWAY_IMAGE" 2>/dev/null)
+  echo "${AGENTGATEWAY_IMAGE}${dg:+ (@${dg##*@})}"
+}
+
+gw_build() {
+  cat > "$GW_DIR/config.gen.yaml" <<YAML
+binds:
+- port: $GW_PORT
+  listeners:
+  - name: llm
+    protocol: HTTP
+    routes:
+    - backends:
+      - ai:
+          name: openai
+          hostOverride: "127.0.0.1:$MOCK_PORT"
+          pathOverride: $GW_PATH
+          provider:
+            openAI:
+              model: $GW_MODEL
+YAML
+  sudo docker pull "$AGENTGATEWAY_IMAGE" >/dev/null 2>&1 || true
+}
+
+gw_launch() {
+  sudo docker rm -f agentgateway-bench >/dev/null 2>&1; sleep 1
+  sudo docker run -d --name agentgateway-bench --network host --cpuset-cpus="$CORES" \
+    -e ADMIN_ADDR=127.0.0.1:15000 -e STATS_ADDR=127.0.0.1:15020 -e RUST_LOG=error \
+    -v "$GW_DIR/config.gen.yaml:/config.yaml:ro" \
+    "$AGENTGATEWAY_IMAGE" -f /config.yaml >"$GW_DIR/launch.log" 2>&1 || true
+}
+
+gw_rss() { container_rss_mib agentgateway-bench; }  # summed process-tree VmRSS (same method as native)
+
+gw_diag() {
+  echo "container: $(sudo docker ps -a --filter name=agentgateway-bench --format '{{.Status}}' 2>/dev/null)"
+  echo "run.log: $(cat "$GW_DIR/launch.log" 2>/dev/null | tr '\n' ' ' | head -c 300)"
+  echo "logs:"; sudo docker logs --tail 25 agentgateway-bench 2>&1
+}
+
+gw_stop() { sudo docker rm -f agentgateway-bench >/dev/null 2>&1; }
@@ -7,6 +7,11 @@
 # logging off, worker_processes = pinned core count, no observability plugins → pure proxy overhead.
 # APISIX_IMAGE is pinned in gateways/versions.env.
 GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="APISIX"                      # label in charts + report tables
+GW_LANG=Other                            # implementation language → bar color bucket
+GW_REPO=https://github.com/apache/apisix   # linked from the gateway name in the report table
 GW_PORT=9080
 GW_PATH=/v1/chat/completions
 GW_MODEL=gpt-4o-mini
 
@@ -7,6 +7,11 @@
 # prompt_targets / routing / guards, so the guard/router models never run (pure proxy overhead). The
 # CLI runs the container(s), which we then pin to $CORES. ARCH_VERSION is in gateways/versions.env.
 GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="Arch"                      # label in charts + report tables
+GW_LANG=Other                            # implementation language → bar color bucket
+GW_REPO=https://github.com/katanemo/archgw   # linked from the gateway name in the report table
 GW_PORT=12000
 GW_PATH=/v1/chat/completions
 GW_MODEL=openai/gpt-4o-mini
 
@@ -2,6 +2,11 @@
 # SPDX-License-Identifier: Apache-2.0
 # Gateway manifest: Bifrost (maximhq/bifrost, docker), its documented pool config.
 GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="Bifrost"                      # label in charts + report tables
+GW_LANG=Go                            # implementation language → bar color bucket
+GW_REPO=https://github.com/maximhq/bifrost   # linked from the gateway name in the report table
 GW_PORT=8080
 GW_PATH=/v1/chat/completions
 GW_MODEL=gpt-4o-mini
 
@@ -7,6 +7,11 @@
 # process so we measure the real process RSS/latency. Override with BUSBAR_BIN to point at a local
 # working-tree build instead. Config: token auth, one model to the mock — no special setup.
 GW_KIND=native
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="Busbar"                      # label in charts + report tables
+GW_LANG=Rust                            # implementation language → bar color bucket
+GW_REPO=https://github.com/GetBusbar/busbar   # linked from the gateway name in the report table
 GW_PORT=8080
 GW_PATH=/v1/chat/completions
 GW_MODEL=gpt-4o-mini
 
@@ -7,6 +7,11 @@
 # unset) for a pure proxy-overhead measurement — the default posture. Image pinned in
 # gateways/versions.env; the resolved tag is recorded in the result.
 GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="GoModel"                      # label in charts + report tables
+GW_LANG=Go                            # implementation language → bar color bucket
+GW_REPO=https://github.com/ENTERPILOT/GOModel   # linked from the gateway name in the report table
 GW_PORT=8080
 GW_PATH=/v1/chat/completions
 GW_MODEL=gpt-4o-mini
 
@@ -8,6 +8,11 @@
 # gateways/versions.env. Pure-proxy mode: helicone.features=none → no control plane, no auth, no key
 # required; the built-in `openai` provider's base-url is overridden to the mock.
 GW_KIND=native
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="Helicone"                      # label in charts + report tables
+GW_LANG=Rust                            # implementation language → bar color bucket
+GW_REPO=https://github.com/Helicone/ai-gateway   # linked from the gateway name in the report table
 GW_PORT=8787
 GW_PATH=/router/default/chat/completions
 # Helicone's router requires the unified "{provider}/{model}" form (it errors on a bare model name);
 
@@ -7,6 +7,11 @@
 # DB-less declarative config, generated in gw_launch against the runner's mock port. KONG_IMAGE is
 # pinned in gateways/versions.env.
 GW_KIND=docker
+# Self-describing manifest metadata — charts.py + the run lists read these, so a gateway
+# is fully defined by its own dir (add/remove a dir → it appears/disappears everywhere).
+GW_DISPLAY="Kong"                      # label in charts + report tables
+GW_LANG=Other                            # implementation language → bar color bucket
+GW_REPO=https://github.com/Kong/kong   # linked from the gateway name in the report table
 GW_PORT=8080
 GW_PATH=/v1/chat/completions
 GW_MODEL=gpt-4o-mini