Vercel Adds Agent Runs to Its MCP and CLI

Vercel has shipped a new way to inspect what your AI agents are actually doing once they're deployed. According to the announcement, Agent Runs are now available directly through the Vercel MCP and the Vercel CLI, for eve — an open-source agent framework.

What's actually new

When an eve-based agent is deployed to Vercel, its traces are automatically ingested and stored as Agent Runs. Previously that data lived wherever it lived. Now it's queryable through two new interfaces: MCP tools for agents and assistants that support the protocol, and CLI commands for everyone else, including agents that don't have MCP access.

Both surfaces expose the same underlying data: which projects have agent activity, a list of recent runs, and the full trace for any individual run — reasoning steps, tool calls, tool input/output, and token usage.

The MCP tools

Four new tools ship with the Vercel MCP:

• list_agent_run_projects — finds which projects in a team have Agent Runs activity
• list_agent_runs — lists recent runs for a given project
• get_agent_run — inspects metadata, lifecycle events, usage, and subagent data for a run
• get_agent_run_trace — retrieves the full trace, including turns, messages, reasoning, tool calls, and token usage

This means an assistant with MCP access can be asked something like "show me the latest production Agent Runs for my project" or "update skills based on recent runs," and pull the actual data to answer.

The CLI commands

For agents or workflows without MCP access, the same functionality is available through the CLI:

• vercel agent-runs projects
• vercel agent-runs list
• vercel agent-runs inspect <runId>
• vercel agent-runs trace <runId>

Every subcommand supports a --json flag for machine-readable output, and traces render as markdown when piped elsewhere. That detail matters more than it looks: it means a coding agent can call the CLI directly, parse or read its own run history, and debug itself without a human in the loop or an MCP connection.

Getting started

Vercel's instructions are two commands. To install the MCP server:

npx add-mcp https://mcp.vercel.com

Or to get the latest CLI with the new subcommands:

npm i -g vercel@latest

Why this exists

The underlying problem this addresses is observability for agentic systems. Once an agent is deployed and running against real traffic, understanding what it actually decided to do — which tools it called, what reasoning led to a given output, how many tokens it burned — has mostly required custom logging or a separate observability stack. By ingesting eve traces automatically on deploy and exposing them through interfaces agents themselves can query, Vercel is treating agent debugging as a first-class deployment concern rather than something bolted on afterward.

The fact that both a human-facing MCP path and a scriptable CLI path exist is a deliberate choice. It covers two different consumers: a developer or assistant chatting through an MCP client, and a coding agent that needs to inspect its own past runs programmatically as part of a feedback loop — the "update skills based on recent runs" example is explicit about this use case.

It's worth noting the scope here: this integration currently applies to eve, the open-source agent framework, not to arbitrary agent stacks. The announcement doesn't say whether support for other frameworks is planned.

What this means if you're shipping agent-based products

If you're building on eve and deploying to Vercel, this closes a real gap: you no longer need a separate pipeline to capture and inspect what your agents did in production. The trace data — reasoning, tool calls, token usage — is available the moment you deploy, queryable from a terminal or from an MCP-aware assistant.

More broadly, this is a signal about where deployment platforms are heading: treating agent execution traces the way they've long treated request logs — as something that should be ingested automatically and queryable without extra infrastructure. If your team is running agents in production on any platform, it's worth asking whether you have equivalent visibility into reasoning and tool calls today, or whether you're still stitching that together yourself.