Building and Operating Production AI Agents at Scale with Vercel's Agent Orchestration Platform

vercel · Tech · 2026 · source Agentic: yes · promotional bias: high · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Production agent orchestration platform

Vercel argues that building agents is now easy, but reliably operating them at scale still requires security, observability, reliability, cost control, durable orchestration, and model routing.

Constraints:

AI-generated internal tools can create shadow IT and expensive DevOps setups.
Agents need isolated execution for untrusted code and prompt-injection risk.
Critical business workflows need retries and state recovery.
The source is promotional and positions Vercel's platform as the solution.

Architecture

Vercel's internal d0 analytics agent and broader agent platform use Sandboxes for isolated execution, Fluid Compute for scaling, AI Gateway for model routing and budget control, Workflows for durable orchestration, and Observability for prompt/response/decision tracing. The same primitives support internal agents and customer-facing products such as v0 and Vercel Agent.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  slack-user[Slack User] --> d0-agent[d0 Agent]
  d0-agent --> workflows[Workflows]
  workflows --> sandboxes[Sandboxes]
  d0-agent --> ai-gateway[AI Gateway]
  ai-gateway --> model-providers[Model Providers]
  d0-agent --> data-warehouse[Data Warehouse]
  d0-agent --> observability[Observability]
  ai-gateway --> observability[Observability]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Slack User`	Asks natural-language data questions to d0.	`d0 Agent`
`d0 Agent`	Internal text-to-SQL analytics agent.	`Workflows`, `AI Gateway`, `Data Warehouse`
`Workflows`	Durable orchestration with retries and state recovery.	`d0 Agent`, `Sandboxes`
`AI Gateway`	Routes requests across models with budget, usage, and failover controls.	`d0 Agent`, `Model Providers`
`Sandboxes`	Isolated Linux VMs for sensitive autonomous actions and code execution.	`Workflows`
`Observability`	Traces prompts, responses, decisions, token usage, and performance.	`d0 Agent`, `AI Gateway`
`Data Warehouse`	Enterprise data source queried by d0.	`d0 Agent`
`Model Providers`	Fast and capable model options routed through AI Gateway.	`AI Gateway`

Data flow

A Slack user asks d0 a data question, the agent checks permissions, starts a workflow, routes model calls through AI Gateway, retries failed Snowflake/model steps through Workflows, executes sensitive actions in sandboxed environments when needed, and exposes traces through observability.

“A user asks a question in Slack: "What was our Enterprise ARR last quarter?" d0 receives the message, determines the right level of data access”article, stated

“If a step fails (Snowflake timeout, model hiccup), Vercel Workflows handles retries and state recovery automatically.”article, stated

Why this architecture

Vercel's thesis is that agent generation is commoditized, so the differentiator is the production platform underneath: isolated execution, durable workflows, routing/failover, and observability. d0 is used as proof that one engineer could build a useful internal agent quickly because the platform handled operations.

“--- # Anyone can build agents, but it takes a platform to run them Prototyping is democratized, but production deployment isn't.”article, stated

“Like OpenAI, we built our own internal data agent named d0 (OSS template here). At its core, d0 is a text-to-SQL engine, which is not a new concept. What made it a successful product was the platform underneath.”article, stated

Models used: Claude Opus · AI Gateway models · v0 · Vercel Agent

Scale

One engineer built d0 in a few weeks using 20% of their time.
“Using Vercel’s built-in primitives and deployment infrastructure, one person built d0 in a few weeks using 20% of their time.”article, stated
Vercel says d0 answers hundreds of data questions daily in the summary.
“deployment at scale remains difficult. The company built d0, an internal analytics agent that answers hundreds of data questions daily, using their own agent orchestration platform. By leveraging Vercel's infrastructure primitives—Sandboxes for isolated execution, Fluid Compute for dynamic”summary, stated
The customer support agent handles 87% of initial questions.
“* A customer support agent (handles 87% percent of initial questions) * An abuse detection agent that flags risky content * A content agent that turns Slack threads into draft blog posts.”article, stated
Vercel contrasts an overbuilt $5,000/month DevOps setup with a $500/month efficient system.
“Claude can scaffold a fully functional agent before your morning coffee gets cold. But that same AI will happily architect a $5,000/month DevOps setup when the system could run efficiently at $500/month.”article, stated

Alternatives considered (roads not taken)

Treat agent building as the hard part.

Rejected because: Vercel argues prototyping is democratized and operation is the real bottleneck.

“AI models have commoditized code and agent generation, making it possible for anyone to build sophisticated software in minutes.”article, stated

Run agents without sandboxes.

Rejected because: Generated code and prompt injection can damage core systems without isolation.

“When agents generate and run untested code or face prompt injection attacks, sandboxes contain the damage within isolated Linux VMs.”article, stated

Use one model provider path.

Rejected because: AI Gateway provides model routing, budget controls, monitoring, load balancing, and failover.

“AI Gateway can route simple requests to fast, inexpensive models while sending complex analysis to more capable ones.”article, stated

Patterns

`durable-execution` (workflow runtime)

Vercel Workflows provide retries and state recovery for multi-step agent operations.

“Durable orchestration provides retry logic and error handling at every step”article, stated

`model-routing` (model operations)

AI Gateway routes simple queries to cheap models and complex analysis to Claude Opus.

“AI Gateway routes simple requests to fast models and complex analysis to Claude Opus”article, stated

`safety-policy-enforcement` (sandboxing)

Sandboxes isolate code execution and prompt-injection damage in Linux VMs.

“Sandboxes give agents a secure, isolated environment for executing sensitive autonomous actions.”article, stated

`observability-tracing` (agent operations)

Observability exposes prompts, model responses, decisions, tokens, and performance.

“observability shows you the exact prompts, model responses, and decision paths”article, stated

`cost-aware-routing` (platform cost)

The platform uses budget control, model routing, and cost optimization to avoid overbuilt DevOps.

“built-in budget control, usage monitoring, and load balancing across providers.”article, stated

Tradeoffs

Build-vs-run focus

Chose Platformize operations over Optimizing only for agent scaffolding.

Rationale: Production reliability, security, and cost are the limiting factors after prototypes become easy.

“Competitive advantage no longer comes from whether you can build. It comes from rapid iteration on AI that solves real problems”article, stated

Model choice

Chose Gateway routing across cheap and capable models over One model for all requests.

Rationale: Different query complexity needs different cost/quality choices and failover.

“route simple requests to fast, inexpensive models while sending complex analysis to more capable ones.”article, stated

Execution safety

Chose Isolated sandboxes over Direct access to core systems.

Rationale: Generated code and prompt injections should be contained.

“sandboxes contain the damage within isolated Linux VMs.”article, stated

Gotchas (what bit them)

Fast agent generation can create shadow IT.

Root cause: Anyone can build agents quickly, but operations expertise remains rare.

Resolution: Provide platform primitives for security, reliability, observability, and cost.

“Vibe coding has created one of the largest shadow IT problems in history”article, stated

Agent-generated DevOps can be wildly overbuilt.

Root cause: The model may propose expensive infrastructure without cost optimization.

Resolution: Use platform primitives and built-in budget control.

“Claude can scaffold a fully functional agent before your morning coffee gets cold. But that same AI will happily architect a $5,000/month DevOps setup”article, stated

Agent failures in critical workflows can be costly.

Root cause: Snowflake timeouts, model hiccups, and interrupted multi-step operations require state recovery.

Resolution: Use Workflows for retries and durable state.

“When agents are used for critical business processes, failures are costly.”article, stated

Evaluation

The article evaluates the platform through internal agent examples, d0 development effort, support automation percentage, routing/observability capabilities, and examples of agent categories deployed on Vercel.

Metrics: Development time · Engineer time percentage · Initial support-question handling rate · Model budget and usage · Agent traceability

“one person built d0 in a few weeks using 20% of their time.”article, stated

“A customer support agent (handles 87% percent of initial questions)”article, stated

Outcomes

Vercel built d0 as an internal text-to-SQL analytics agent.
The platform supports internal agents for lead qualification, support, abuse detection, and content generation.
The same primitives support customer-facing v0 and Vercel Agent products.

Reported scale includes d0 built in weeks with 20% of one engineer's time, a support agent handling 87% of initial questions, and hundreds of future specialized tools projected.