Vercel Open Agents: Build Your Own Cloud Coding Agent — A Deep Dive
Vercel just open-sourced Open Agents, a reference platform for building and running autonomous coding agents that operate entirely in the cloud. Think of it as a self-hostable alternative to Devin — you describe what you want in natural language, and a background agent writes, tests, and ships code on your behalf, without keeping your laptop open.
In this article, we'll break down the architecture, the key technologies behind it, and why this matters for the future of software development.
What Is Open Agents?
Open Agents is an MIT-licensed monorepo that gives you everything needed to build a cloud-based coding agent:
- Web UI — a chat interface for interacting with the agent
- Agent Runtime — durable workflow execution that survives crashes and redeploys
- Sandbox — isolated VM environments with filesystem, shell, git, dev servers, and preview ports
- GitHub Integration — auto-commit, push, and PR creation from agent work
It's designed to be forked and customized, not used as a black box. Vercel explicitly encourages understanding the architecture so you can adapt it to your needs.
The Three-Layer Architecture
Open Agents is built on a clean three-layer separation:
┌─────────────────────────────────────┐
│ Web Layer │
│ Next.js · Auth · Chat UI · Stream │
├─────────────────────────────────────┤
│ Agent Layer │
│ Durable Workflows · Tool Calls │
│ Model-agnostic · Multi-step │
├─────────────────────────────────────┤
│ Sandbox Layer │
│ Isolated VM · FS · Shell · Git │
│ Dev Servers · Preview Ports │
└─────────────────────────────────────┘
The Critical Design Decision: Agent Runs Outside the Sandbox
This is the most important architectural choice. Unlike many coding agent implementations where the agent logic lives inside the execution environment, Open Agents runs the agent outside the sandbox. The agent communicates with the sandbox only through tool invocations — file reads, edits, shell commands, search queries.
Why does this matter?
- Execution outlives HTTP requests — the agent runs as a durable workflow, not within a single request lifecycle
- Sandbox can hibernate and resume — the VM sleeps when idle and wakes on demand, independent of agent state
- Model flexibility — swap LLM providers without touching the sandbox
- Clean separation of concerns — the sandbox is a pure execution environment, not a control plane
The Vercel Workflow SDK: Making Agents Durable
At the heart of Open Agents is the Vercel Workflow SDK, an open-source TypeScript framework that turns ordinary async functions into durable, resumable workflows.
How It Works
The SDK introduces two core directives:
"use workflow"— marks a function as a durable workflow"use step"— marks a function as an atomic, retriable unit of work
Under the hood, every step's input and output is recorded in an event log. If a crash or redeployment happens, the workflow replays deterministically from the last completed step — completed steps return cached results without re-executing.
Why This Matters for Agents
Traditional serverless functions have hard timeout limits. A coding agent that needs to:
- Clone a repo
- Analyze the codebase
- Plan changes across 15 files
- Write and test code
- Create a PR
...can't fit in a single Lambda invocation. The Workflow SDK solves this by:
- Persisting state across arbitrary numbers of steps
- Sleeping without consuming resources — a workflow can pause for hours
- Resuming from interruption — reconnect to an active workflow's stream
- Built-in retries — failed steps automatically retry with backoff
This is what enables the "fire and forget" pattern: submit a prompt, close your laptop, and the agent keeps working.
The Sandbox: Isolated Execution
Each agent session gets an isolated sandbox — essentially a lightweight VM with:
- Full filesystem access
- Shell execution
- Git integration (clone, branch, commit, push)
- Dev server support on ports 3000, 5173, 4321, 8000
- Snapshot-based resume — sandboxes hibernate after inactivity and restore from snapshots
The sandbox is where code actually runs, but it has no opinions about what to do. It's the agent layer that decides; the sandbox just executes.
Tool System
The agent interacts with the sandbox through a structured tool system:
| Tool | Purpose |
|---|---|
| File | Read, write, and manipulate files with line-level precision |
| Search | Full-text search across the codebase |
| Shell | Execute arbitrary commands with output capture |
| Task | Coordinate multi-step workflows |
| Skill | Invoke reusable agent capabilities |
| Web | HTTP requests and preview port interaction |
This tool-based approach means the agent is model-agnostic. Any LLM that supports function calling can drive the agent — you're not locked into a specific provider.
Tech Stack
| Component | Technology |
|---|---|
| Web framework | Next.js |
| Styling | Tailwind CSS |
| Package manager | Bun |
| Database | PostgreSQL |
| Cache | Redis / Upstash KV (optional) |
| Workflow engine | Vercel Workflow SDK |
| Sandbox | Vercel Sandboxes |
| Auth | Vercel OAuth + GitHub App |
| Voice input | ElevenLabs (optional) |
The monorepo structure:
apps/web/ → Next.js app, workflows, auth, chat
packages/agent/ → Agent logic, tools, subagents, skills
packages/sandbox/ → Sandbox abstraction, Vercel integration
packages/shared/ → Shared utilities
How It Compares
Open Agents occupies a unique position in the 2026 coding agent landscape:
| Open Agents | Devin | Claude Code | Cursor | |
|---|---|---|---|---|
| Runs in | Cloud (Vercel) | Cloud | Local terminal | Local IDE |
| Open source | Yes (MIT) | No | No | No |
| Self-hostable | Yes | No | N/A | No |
| Background execution | Yes | Yes | No | No |
| Customizable | Fully forkable | No | Hooks/skills | Extensions |
| GitHub integration | Built-in | Built-in | Via CLI | Via extension |
The key differentiator: Open Agents is the only open-source option that gives you a full cloud-based coding agent with durable execution, sandboxed environments, and GitHub integration — all deployable on your own infrastructure.
The Bigger Picture: Vercel's Agentic Strategy
Open Agents is part of Vercel's broader bet on agentic infrastructure. According to their data:
- Coding agents now initiate over 30% of Vercel deployments (up 1000% in six months)
- Claude Code accounts for 75% of agent-driven deployments
- Agent-deployed projects are 20x more likely to call AI inference providers
Vercel is positioning itself as the full-stack platform for the agent era: deployment infrastructure, agent orchestration (Workflow SDK), execution isolation (Sandbox), observability, and model routing (AI Gateway). Open Agents is the reference implementation that ties it all together.
Getting Started
- Fork the repo
- Set up PostgreSQL and generate encryption secrets
- Configure Vercel OAuth and GitHub App credentials
- Deploy to Vercel (or run locally with
bun run web)
The minimum required environment variables are just POSTGRES_URL and JWE_SECRET to boot. Add GitHub App credentials for the full experience.
Final Thoughts
Open Agents represents a significant shift: coding agents are moving from local tools to cloud-native infrastructure. The separation of agent logic from execution environment, combined with durable workflows, means we're approaching a world where you can describe a feature in plain English, walk away, and come back to a pull request.
The fact that it's open source and designed for forking makes it a compelling foundation for teams that want the Devin experience without the vendor lock-in. Whether you're building an internal development tool, a coding education platform, or just want to experiment with autonomous agents — Open Agents gives you a production-grade starting point.
Links:
