Inside Phoenix MCP: remote MCP, SQL, and code mode let agents query traces

You ask a coding agent a simple observability question: how many spans failed yesterday, which tool was called most, where latency spiked. Without the right tool shape, the agent starts paging through spans one by one, reading rows into context, and doing database work inside the model loop.

Phoenix MCP changes that architecture. It gives MCP-compatible clients a remote endpoint into Arize Phoenix, exposes a queryable schema over telemetry data, and lets the agent run bounded, read-only SQL inside code mode so the database does the aggregation before raw rows reach model context.

We'll demo the workflow in Claude Code and Cursor, then walk through the implementation: connecting to Phoenix's built-in /mcp endpoint, discovering the telemetry schema with describeSqlSchema, and querying it with executeSql. You'll see how code mode runs agent-written Python in a sandboxed execution environment, and how Phoenix parses, rewrites, limits, and validates agent-written SQL before execution against SQLite or Postgres.

We'll use the benchmark from our recent post as the motivating example: retrieval-style tools forced an agent to page through trace data span by span, while SQL plus code mode answered the same class of questions with far fewer turns and lower token cost. Across an eight-question benchmark, that worked out to roughly a 17x average cost reduction.

Who this is for
Engineers, agent builders, and platform teams who want to understand how to expose production observability data to coding agents without dumping raw spans into context.

Especially relevant if you are building MCP servers, internal developer tools, agent observability workflows, or query interfaces over large operational datasets.

What you'll leave with

• A clear mental model of what a remote MCP server is: an application-hosted endpoint that lets coding agents connect to real product data and operations.

• An understanding of why trace aggregation is a bad fit for page-by-page retrieval tools.

• A technical picture of Phoenix MCP's architecture: /mcp, client auth/connection, generated tools, code mode, and the SQL layer.

• A breakdown of how describeSqlSchema and executeSql let agents query telemetry without dumping raw spans into context.

• The safety model Phoenix uses for agent-written SQL: parsing, allowlisting, rewriting, backend checks, limits, and read-only execution.

• The benchmark result from the blog and what it says about tool design, cost, and accuracy.

• Design patterns you can borrow when building your own MCP server over production data.

Format
Technical live session with architecture walkthrough, benchmark discussion, demos in Claude Code and Cursor, and Q&A. About 45 minutes: roughly 30 minutes presentation and demo, 15 minutes Q&A.

Level
Intermediate. Assume you know what traces and spans are. No prior MCP experience required, but we will get into server architecture and implementation details.

Speakers

• Nancy Chauhan is a Developer Relations Engineer at Arize AI with experience across AI observability, DevOps, cloud-native, and developer experience. An open-source contributor, speaker, and founder of Women in Cloud Native, she is passionate about making AI systems more accessible for developers. Nancy is also a Linux Foundation TAGGIE Award winner, recognized for her contributions to the CNCF open-source community.