GitHub reviewed GHSA-gfv3-m769-5xm3 (CVE-2026-53998) on November 17, 2026: a format string injection in Arize Phoenix’s applyChatTemplate GraphQL query can return server-side environment variables, cryptographic secrets, and module attributes in the API response. On default Phoenix installs where authentication is disabled, the endpoint is reachable with no credentials; when auth is enabled, any account suffices. Upgrade arize-phoenix to 15.7.0, enable authentication, and rotate LLM API keys stored in Phoenix if the service was reachable on your network while running a vulnerable build.
Arize Phoenix is an open-source LLM observability stack teams run beside coding agents to capture traces, eval scores, and prompts. It is not the agent itself—but it often holds the same inference API keys your harness uses, which makes this a credential vault breach, not a tracing cosmetic bug.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | pip show arize-phoenix in 13.0.0 ≤ version < 15.7.0, especially if Phoenix listens on LAN or 0.0.0.0 without auth |
| Is there a fix? | arize-phoenix 15.7.0 (release tag, fix PR context in Arize-ai/phoenix#13197) |
| Severity? | Critical, CVSS 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L) per NVD |
| Unauthenticated exploit? | Yes on default installs per advisory summary |
| What leaks? | os.environ, PHOENIX_SECRET, Fernet-protected LLM keys and OAuth tokens in the DB |
| Does data leave my machine? | Exploitation requires network reachability to Phoenix; local-only + patched version does not phone home |
Mechanism: F_STRING templates and DotDict traversal
The vulnerable path is the applyChatTemplate GraphQL endpoint implemented in src/phoenix/server/api/queries.py (advisory cites line 1638). When templateOptions.format is F_STRING, user-controlled text is rendered through FStringTemplateFormatter._format() in src/phoenix/utilities/template_formatters.py (line 272).
The formatter wraps variables in DotDict, whose __getattr__ (line 90) does not stop attribute walks. A researcher-supplied template can climb Python object graphs—for example referencing u.__class__.__bases__[0].__init__.__globals__[_os].environ—and return the result inside normal GraphQL JSON. That is classic CWE-134 (externally controlled format string) paired with CWE-200 (sensitive information disclosure).
Impact chain from the advisory:
- Reconnaissance — filesystem paths, loaded modules, and constants appear in the response.
- Environment dump — full
os.environ, including hardcoded admin material inphoenix.authon some deployments. - Key compromise —
PHOENIX_SECRETleaks; it signs JWTs and derives Fernet keys for encrypted credentials. - Persistence — forged admin JWTs and decrypted LLM API keys / OAuth tokens stored for tracing workloads.
Arize’s recommended fix combines formatter hardening, IsAuthenticated on the resolver, and restricting F_STRING to trusted templates—all landed in v15.7.0.
Why format strings still show up in 2026 agent stacks
Format-string bugs sound like a C era artifact, but they reappear wherever user text becomes a template language without a hard sandbox. Phoenix’s F_STRING path treats prompt variables like Python f-string fields. The advisory’s DotDict wrapper was meant to expose template keys safely; in practice, chained attribute access reached module globals and os.environ.
That design choice matters for coding-agent teams because agents generate prompt templates constantly. A workflow that auto-fills Phoenix eval templates from repository files—or from chat exports—can feed untrusted strings into the same code path a remote attacker abuses with GraphQL. Patching closes the remote vector; template provenance still belongs in your threat model.
Disclosure timeline
| Date | Milestone |
|---|---|
| 2026-02-13 | First vulnerable release arize-phoenix-v13.0.0 per advisory |
| 2026-04-17 | v14.8.0 last confirmed vulnerable build cited |
| 2026-11-09 | GitHub advisory published to Arize-ai/phoenix (per timeline on GHSA page) |
| 2026-11-16 | NVD publication |
| 2026-11-17 | GitHub Advisory Database marked Reviewed, CVSS vector published |
The gap between first vulnerable release and public review is long—if you pinned Phoenix for a stable local tracing stack in early 2026, assume exposure for the entire window the instance was reachable.
Proof of concept (from the advisory)
Image: GitHub Advisory Database (GHSA-gfv3-m769-5xm3)
The published GraphQL body sets format to F_STRING and nests the format-string payload inside a synthetic chat message. On a vulnerable server, the text field in the response carries environment contents. The advisory credits reporter OmarXtream; NVD published the record on November 16, 2026, and GitHub’s database entry updated November 17, 2026.
NVD scoring and CWE mapping
NVD aligns with GitHub’s CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L, yielding a 10.0 base score. Weakness enumerations include CWE-134 (externally controlled format string) and CWE-200 (exposure of sensitive information). There is no chained RCE prerequisite: confidentiality and integrity impact are already High because the response body carries secrets and forged sessions become plausible once PHOENIX_SECRET is known.
For compliance trackers, record this alongside other LLM platform issues in the November cluster—ScreenConnect MSP access and Puppet Enterprise KEV hit different layers, but Phoenix is the one your eval harness may host on the same VLAN as the engineer’s laptop.
Who is affected
| Deployment pattern | Risk |
|---|---|
Local phoenix serve on a laptop with default auth off and Wi‑Fi/LAN exposure | High if another device—or a malicious page via SSRF elsewhere—can reach the port |
| Shared dev Phoenix on a team VPC | High; one POST exfiltrates keys for every project wired into that instance |
| Docker Compose beside agent eval harnesses | High when compose publishes 8000/tcp without reverse-proxy auth |
| Auth-enabled but unpatched 14.x | Still exploitable per advisory (any account) |
| No Phoenix installed | Not affected |
Phoenix differs from agent monitoring on the workstation: observability platforms ingest prompts and spans centrally and therefore accumulate secrets. That is the same pattern as Railway and Zeabur breaches where environment stores doubled as attack targets—here the store is your tracing server.
Patch, verify, and rotate
1. Upgrade
pip install --upgrade 'arize-phoenix>=15.7.0'
Confirm:
pip show arize-phoenix | grep -E '^Version:'
Container operators should pull an image tag tied to v15.7.0+ and redeploy; see Arize-ai/phoenix releases.
2. Enable authentication
The advisory’s summary calls out authentication disabled by default. After upgrading, follow Arize Phoenix deployment documentation to require login before GraphQL mutation/query endpoints are reachable.
3. Network bind and exposure
Bind Phoenix to localhost during local agent development unless a reverse proxy enforces auth. If Phoenix was reachable on 0.0.0.0 while vulnerable, assume PHOENIX_SECRET and stored provider keys are burned.
4. Rotation checklist
- Regenerate
PHOENIX_SECRETand restart so JWT and Fernet material rotate. - Rotate every LLM provider key Phoenix stored (OpenAI, Anthropic, Azure, etc.).
- Invalidate OAuth refresh tokens connected through Phoenix integrations.
- Review Phoenix audit logs—if none exist, inspect reverse-proxy access logs for
applyChatTemplatePOSTs since v13.0.0 deployment.
What this means if you run AI coding agents
Coding agents rarely embed Phoenix inside the IDE, but engineers wire the same projects agents touch into Phoenix for eval loops:
.envkeys copied into Phoenix UI become decryptable afterPHOENIX_SECRETleaks.- CI jobs that spin Phoenix for regression evals may publish ports agents never see—but attackers scanning the subnet will.
- MCP or script tools that call
http://localhost:6006/graphql(or your chosen port) can accidentally forward attacker-controlled templates if an agent is prompt-injected to do so—secondary to the unauthenticated case, but real in prompt-injection chains.
Concrete habits:
- One Phoenix instance per engineer on loopback, auth on, patched.
- Never paste production inference keys into a dev tracing server agents can read via repo configs.
- Grep repos for
arize-phoenixpins before agents bump dependencies:
grep -R "arize-phoenix" pyproject.toml requirements.txt docker-compose*.yml 2>/dev/null
- After upgrade, run a quick version gate in CI the same way you gate Kubeflow pipeline patches.
Signs you may already have been probed
The advisory does not describe active exploitation in the wild. Defenders can still hunt:
- Reverse-proxy or Phoenix access logs with GraphQL operations named
applyChatTemplatefrom non-admin IPs. - Spikes in 200 responses with unusually large
textfields insidemessages. - New admin sessions immediately after anonymous GraphQL from the same source address (forged JWT after
PHOENIX_SECRETleak).
Absent logs, treat any internet-exposed Phoenix < 15.7.0 as compromised until patched and rotated.
How Phoenix fits next to agent tooling on the same laptop
Developers often run three parallel planes on one machine:
- The coding agent (Claude Code, Codex, Cursor CLI) with repository and shell access.
- An observability plane (Phoenix, Langfuse, or a vendor sink) holding API keys for replay and eval.
- A model gateway (LiteLLM, custom proxy) routing traffic.
CVE-2026-53998 hits plane 2 hardest. It does not grant shell on the laptop by itself, but decrypted LLM keys let an attacker run the same models your agent uses—burning quota, scraping proprietary prompts from provider logs, or pivoting into fine-tuned endpoints you pay for. That is why rotation must include provider-side key revocation, not only restarting Phoenix.
If your agent workspace policy already denies destructive shell patterns, keep it—but do not confuse hook denies with server-side GraphQL auth. They solve different layers.
What Beam can and cannot do here
Beam watches Claude Code and Codex tool calls on your machine—filesystem edits, shell commands, MCP/tool invocations—and can flag risky patterns (credential formats, destructive commands) before persistence when workspace policy is in enforce mode. Beam’s skill and MCP scanners help catch configs that exfiltrate secrets or pull remote install scripts.
Beam does not patch Phoenix, terminate GraphQL requests, or sit in front of your observability server. If an agent runs curl against a local Phoenix GraphQL endpoint with a malicious template, Beam may log the shell event when hooks are wired, but it is not a WAF and fail-open applies when cached policy is missing. Treat Phoenix like any other local secret store: patch, authenticate, bind to localhost.
Related reading
- What agent monitoring software tracks — how observability differs from on-device agent security
- MCP security practical guide — when agents reach local HTTP services
- Kubeflow CVE-2026-77596 — another critical fix for ML sidecars agents trigger
- Railway breach environment variables — parallel lesson on rotating inference keys after platform exposure
- OpenAI Codex Security CLI — securing the repos agents modify, not the trace backend
Severity, affected versions, and CVSS scores are accurate as of November 17, 2026, per GitHub’s advisory database and NVD.
Frequently asked questions
What is CVE-2026-53998?
CVE-2026-53998 is a critical format string injection in Arize Phoenix's applyChatTemplate GraphQL resolver. A crafted F_STRING template can read Python globals and return full server os.environ, including PHOENIX_SECRET, which signs JWTs and derives Fernet keys for stored credentials.
Which Phoenix versions are affected?
GitHub's advisory lists arize-phoenix versions from 13.0.0 through before 15.7.0. The first vulnerable release is v13.0.0 (2026-02-13); 14.8.0 was confirmed vulnerable. Patched release is arize-phoenix-v15.7.0.
Can attackers exploit default Phoenix installs without a login?
Yes. The advisory states that on default installations where authentication is disabled, applyChatTemplate is reachable with no credentials. When auth is enabled, any account regardless of privilege can still exploit the flaw per the same advisory text.
How do I check my Phoenix version?
Run pip show arize-phoenix in the environment that hosts Phoenix, or pip list and grep for arize-phoenix. Docker users should inspect the image tag and release notes at Arize-ai/phoenix releases; upgrade to 15.7.0 or later.
What secrets are at risk if I was running a vulnerable build?
The advisory says successful exploitation can disclose environment variables, including hardcoded admin credentials in phoenix.auth, PHOENIX_SECRET, and Fernet-protected LLM API keys, OAuth tokens, and other credentials stored in Phoenix's database.
Is there a workaround before I upgrade?
GitHub lists three mitigations in combination: restrict attribute traversal in FStringTemplateFormatter, add IsAuthenticated on applyChatTemplate, and limit F_STRING format to trusted system templates. The shipped fix is version 15.7.0; do not rely on YAML tweaks alone.
Does this affect Langfuse or other tracing tools on my laptop?
This CVE is specific to Arize Phoenix's template formatter and GraphQL resolver. Other stacks need their own version checks. If your agent writes traces only to Langfuse or a file, Phoenix is not in scope—but many teams run Phoenix locally beside Claude Code or Codex for evals.
Should I rotate keys after patching Phoenix?
If Phoenix was network-reachable while vulnerable and stored LLM provider keys, rotate those provider keys and OAuth tokens after upgrading. Regenerate PHOENIX_SECRET per Arize deployment docs so old JWTs and Fernet material cannot decrypt prior ciphertext.

