OpenAI Agents API on Vercel Ship Long-Running AI Agents Without an Always-On Worker

Why This Matters

Running a long-lived, tool-using AI agent has always had the same ugly trade-off: either you keep a worker process alive (and pay for idle time), or you rebuild session state from scratch on every request. The new OpenAI Agents API on Vercel integration removes that trade-off.

OpenAI now owns the agent loop and session state. Vercel owns the application layer and, crucially, the execution environment — every session gets its own Vercel Sandbox for code execution and file access. No always-on worker. No manual session juggling.

If you have been following how autonomous agents are reshaping engineering workflows (see our breakdown of Meta's REA autonomous ML agent), this is the deployment story that was missing.

For the official reference, see the Vercel changelog entry.

What You Actually Get

Here is the capability list, translated into what it means for your architecture:

• OpenAI-managed agent loop and session state — you don't write the retry/step loop. OpenAI does.
• Reliable Sandbox creation and reconnection — handled via signed OpenAI webhooks + Vercel Queues. This is the part most people get wrong when rolling their own.
• Isolated execution environment per session — one bad rm -rf won't nuke your other tenants.
• Persistent workspace across follow-ups — files written in step 1 are still there in step 7.
• Scale-to-zero — no idle cost when nobody is talking to your agent.

Minimal Deployment Shape

A typical serverless handler that receives the webhook and forwards the agent task looks like this:

// api/agent-webhook.ts
import type { VercelRequest, VercelResponse } from '@vercel/node';
import { verifyOpenAISignature } from './_lib/openai-signature';

export default async function handler(req: VercelRequest, res: VercelResponse) {
  // 1. Verify the OpenAI webhook signature — never trust raw payloads.
  if (!verifyOpenAISignature(req)) {
    return res.status(401).json({ error: 'invalid signature' });
  }

  const { sessionId, task } = req.body;

  // 2. Hand off to Vercel Sandbox for isolated code execution.
  const sandbox = await createSandbox({ sessionId });
  await sandbox.exec(task);

  // 3. Persist workspace state — survives follow-up instructions.
  await sandbox.persistWorkspace();

  return res.status(200).json({ ok: true, sessionId });
}

The key insight: your handler is stateless. All the loop logic and state lives with OpenAI; all the compute lives in the Sandbox. You just wire the two together.

Honest Comparison: Roll-Your-Own vs. This Stack

Caveats You Should Not Ignore

• Vendor concentration. You are now betting on two platforms simultaneously. If either changes pricing or deprecates the webhook format, you migrate.
• Sandbox cold starts. Scale-to-zero is great for cost, less great for latency. For interactive agents, budget for a first-token delay.
• File persistence scope. "Persistent workspace" is per-session. Cross-session memory is still your problem.
• Webhook security is on you. Signature verification is not optional — an unsigned webhook is an open RCE endpoint if you pipe it into a Sandbox.

Where to Go Next

1. Start with the sample app to understand the webhook contract before writing production code.
2. Add structured logging around every Sandbox create/reconnect — this is where 90% of bugs hide.
3. If you care about human-centered agent UX, the design lessons in Designing AI with a Human Touch are worth reading before you ship.

The Bottom Line

The interesting thing here is not "OpenAI on Vercel." That is marketing. The interesting thing is that the agent loop and the execution environment have been cleanly separated. That separation is what makes scale-to-zero possible, and it is the same architectural shape every serious agent platform is converging on.

If you are building tool-using agents that need to run for minutes or hours, this stack removes a category of infrastructure work you should not be doing by hand. Just go in with your eyes open about the lock-in.

Next step: clone the sample app, deploy it, and watch the webhook + Sandbox dance in your own logs. That twenty minutes will teach you more than any architecture diagram.

Related Reading

• Meta's REA: An Autonomous ML Agent 5x More Productive
• Designing AI with a Human Touch