Vercel Launches eve: An Open-Source Agent Framework Where Agents Are Directories

Six months ago, fewer than 3% of Vercel deployments were triggered by AI agents. Today that number is over 50%. Vercel didn’t just watch that happen—they built the framework to handle it, ran it internally on 100+ production agents, and today at Ship London they open-sourced it. It’s called eve.

The pitch is blunt: an agent is a directory. Tools are TypeScript files. Skills are Markdown documents. If you know where to put a file, you know how to build with eve.

The Filesystem Is the Interface

Most agent frameworks ask you to learn a DSL, assemble components, or define a graph. Eve takes a different approach. Drop a file in the right directory and the framework wires it up automatically.

A minimal agent is two files:

agent/
├── agent.ts          # model config
└── instructions.md   # system prompt

From there, adding capability is just adding files:

• agent/tools/run_sql.ts — one TypeScript file, one tool the model can call
• agent/skills/revenue-definitions.md — a knowledge doc loaded only when relevant
• agent/channels/slack.ts — wire the agent to Slack without a separate bot setup
• agent/subagents/researcher/ — a full child agent the parent can delegate to
• agent/schedules/daily-report.ts — a cron job that runs the agent on a schedule

Scaffold a new project with one command:

npx eve@latest init my-agent

No boilerplate, no wiring code. The directory structure is the configuration.

Production Infrastructure Without the Assembly

The harder problem isn’t making an agent work in a notebook. It’s making it reliable at 3 AM when a tool call hangs, a deploy happens mid-session, or someone feeds it a prompt designed to exfiltrate your database credentials.

Eve bakes in the answers:

• Durable sessions: Sessions survive crashes, cold starts, and deployments. Built on Vercel Workflows—no checkpoint logic to write.
• Sandboxed compute: Agent-generated code runs in isolated Linux VMs, not inside your application process. Prompt injection attacks don’t reach core systems.
• Human-in-the-loop approvals: Any tool can require human approval with a single declarative field in the tool definition.
• Credential isolation: Tools connect via Vercel Connect, which issues scoped short-lived tokens. The model never sees an API key.
• Zero-config observability: Every model call, tool invocation, and sandbox command is traced via OpenTelemetry and visible in the Vercel dashboard.

This is infrastructure that LangChain users spend weeks building after their prototype works and they discover they can’t actually run it in production. Eve ships it by default.

What Vercel Actually Runs on It

Eve isn’t new code—it’s the framework Vercel has been running internally for over a year. The internal track record makes the promises concrete:

• d0, a data analyst agent, answers more than 30,000 Slack questions per month against Vercel’s data warehouse. One person built it at 20% of their time over a few weeks.
• Lead Agent, an autonomous SDR, works every new lead the moment it arrives. It costs roughly $5,000 per year to run and returns 32x that. One SDR doing the work of ten.
• Vertex, the support agent, resolves 92% of tickets autonomously across the help center, docs, and Slack—around the clock.

These aren’t proof-of-concepts. They’re the actual tools Vercel’s team uses every day, on infrastructure that handles 20 trillion AI Gateway tokens per month.

Who This Is For (and Who It Isn’t)

Eve is a good fit if you’re already building on Vercel or Next.js and want to add agents without standing up separate infrastructure. The TypeScript-first design keeps tooling, types, and deployment consistent with your existing stack.

It’s not the right fit if:

• You’re a Python shop. Eve is TypeScript-only.
• You need multi-cloud or self-hosted deployment. Eve is built for Vercel. Running elsewhere requires significant adaptation.
• You need API stability now. Eve is in beta—the API surface will change before GA.

If those constraints don’t apply, the trade-off is clear: give up deployment flexibility, get production-grade agent infrastructure on day one.

The Broader Signal

Agents went from 3% to over half of Vercel’s deployment traffic in six months. That’s not a trend—that’s a transition. The teams cobbling together LangChain, a custom Postgres store, and a Slack bot integration today are doing what developers did before Next.js abstracted the same problems for the web.

Eve is Vercel’s bet that the agent infrastructure patterns are repeatable and can be standardized. Given that their internal agents handle 30,000+ queries per month and close sales leads autonomously at 32x ROI, the bet has evidence behind it.

Eve is available now in public preview. Get started at vercel.com/docs/eve or browse the source on GitHub. The Vercel AI SDK 6, which provides the underlying streaming and tool-call primitives, is covered in a prior ByteIota post if you want the lower-level picture.