Vercel eve: an open-source agent framework built on files

Vercel eve is an open-source TypeScript agent framework that launched at Vercel Ship London on June 17, 2026, and its core idea is disarmingly simple: every AI agent is a directory of files. You scaffold an agent/ folder, eve discovers and validates what is inside, compiles a manifest, and serves the result as a durable runtime on Vercel Functions.

The framework is released under Apache-2.0 and is genuinely open source — but it shipped in beta, and it is Vercel-native by design. Its durable execution, sandboxing, and model routing all lean on Vercel-proprietary primitives, so the headline is not raw novelty. It is distribution: Vercel is trying to do for AI agents what Next.js did for React, by imposing opinionated, file-based conventions that make shipping the default path.

This guide unpacks what actually launched, the agents-as-directories paradigm and why it matters, how eve’s durable runtime and sandbox work, and an honest decision matrix comparing eve against Mastra, LangGraph, CrewAI, and Vercel’s own AI SDK. Everything below is sourced from Vercel’s changelog, eve documentation, and launch press materials; vendor-reported metrics are labelled as such throughout.

eve was announced at Vercel Ship London on June 17, 2026, an event Vercel reports drew more than 2,500 in-person attendees. The framing from the keynote stage was characteristically grand — Vercel founder and CEO Guillermo Rauch positioned the agent era as needing purpose-built infrastructure, and eve as Vercel’s answer to it.

Concretely, eve is an Apache-2.0 licensed TypeScript framework for building, running, and scaling AI agents. The repository lives at github.com/vercel/eve, the project is overwhelmingly TypeScript, and it is built as a pnpm-workspaces monorepo. You get started with a single command — npx eve@latest init my-agent — which scaffolds a project and runs it locally in under a minute, or you add it to an existing app with npm install eve@latest. Deployment is a plain vercel deploy; no separate agent infrastructure to provision.

One caveat matters before you read any further: eve launched in beta and Vercel states it is subject to change before general availability. Treat API shapes, command names, and conventions as current-at-launch, not frozen. The honest read is that this is an opinionated v0 of something Vercel intends to evolve quickly.

The single most important thing to understand about eve is its design philosophy: it is a filesystem-first framework for durable backend AI agents. Rather than describing an agent through a graph object or a wall of configuration, you describe it by the files you place under agent/. eve discovers those files at build time, validates them, compiles a manifest, and serves the runtime as a deployable app.

If that pattern feels familiar, it should. It is the same move Next.js made when it turned routes into folders. Adding a page meant adding a file; adding an API route meant adding a file. eve applies the identical convention-over-configuration discipline to agents — adding a tool means adding a file, adding a skill means adding a file, adding a channel means adding a file. The filename often is the contract: a .ts file in agent/tools/ becomes a callable tool whose runtime name is the filename the model sees.

Why does the paradigm matter beyond aesthetics? Because conventions unlock distribution. When the structure of every agent is predictable, tooling, documentation, observability, and deployment can all assume the same shape. That is precisely the lever Next.js pulled to standardise React app structure, and it is the lever Vercel is pulling again here. The product is a framework; the strategy is to make a particular way of building agents the obvious one.

A minimal eve agent is two files. agent/instructions.md is the always-on system prompt, written in plain Markdown. agent/agent.ts is the runtime config, where defineAgent() sets the model and other options. That is enough to run. From there, every additional capability is another file or folder in a known location, auto-discovered at build time.

Beyond those, the convention extends to agent/connections/* for typed integrations with external services such as MCP or OpenAPI endpoints, agent/subagents/* for hierarchical composition where a subagent receives clean, scoped context without exposing parent state, and agent/schedules/*.ts for cron-driven recurring tasks defined directly in the agent directory. Model selection is model-agnostic through Vercel’s AI Gateway: a string like "openai/gpt-5.4-mini" or "anthropic/claude-opus-4-8" resolves through the gateway, and on Vercel the agent authenticates via OIDC, so no static provider API keys are required.

The feature that separates eve from a streaming UI library is durable execution. eve sessions run on Vercel Workflow, which persists progress as an event log and deterministically replays it to reconstruct state. The practical payoff: a session can survive cold starts, redeploys, and long pauses while it waits for the next user message or tool result, without losing its place. To be precise about naming, this is the Vercel Workflow Development Kit, not a separate “AI Workflow” product — and it is distinct from the streaming-focused Vercel AI SDK, which has no durable workflows or first-class agent orchestration.

Sessions are driven over a small HTTP API. A POST /eve/v1/session starts a durable session and returns an x-eve-session-id header plus a continuationToken; a GET /eve/v1/session/:id/stream streams NDJSON lifecycle events. Because turns are long-running and stream incrementally, eve enables Vercel’s Fluid Compute (active-CPU pricing) by default for new projects.

Each agent also gets an isolated, bash-style compute environment with its own filesystem via Vercel Sandbox. On Vercel that runs as ephemeral Firecracker microVMs for untrusted or model-generated commands; locally it uses Docker or microsandbox. And for the riskier actions an agent might take, third-party technical analysis describes a human-in-the-loop approval mechanism that can pause a tool call — at no compute cost while paused — until an interface such as Slack buttons triggers continuation. The exact flag name for that behaviour has been reported by independent analysts rather than confirmed in Vercel’s own docs at launch, so treat the approvals API as qualitatively real but not yet officially specified.

Every eve project automatically gets an Agent Runs dashboard in the Vercel dashboard under Observability, with no instrumentation file required. It shows runs over time by trigger, token usage broken down into input, output, and cached, and a per-turn drill-down with timings, reasoning, tool calls, and token counts. For teams used to bolting telemetry onto an agent after the fact, getting that view for free is a meaningful ergonomic win.

If you want to export traces to your own backend, you add an agent/instrumentation.ts file and eve auto-discovers it at server startup, exporting via OpenTelemetry to backends such as Braintrust, Honeycomb, Datadog, Jaeger, or anything OTel-compatible. The trace hierarchy runs from ai.eve.turn down through ai.streamText to per-tool ai.toolCall spans, with context such as the session id, environment, turn id, and channel kind injected onto each span.

On the testing side, eve is reported to ship a first-class evaluation workflow — eval frameworks you can run locally or in CI against development or deployed instances, conceptually parallel to how pytest structures test suites. The specific API surface and CLI command for evals come from third-party technical analysis rather than Vercel’s official documentation at launch, so we describe the capability qualitatively here and recommend confirming the exact commands against the eve docs before wiring evals into a pipeline.

eve does not arrive into an empty field. The most useful way to place it is against the frameworks developers are already weighing — and the dimension that actually separates them is not feature count but portability. The matrix below is ours, built from each project’s official docs and GitHub, the Speakeasy framework comparison, and our own fact-pack. We deliberately leave out GitHub-star columns: counts move daily and the most-circulated figures are already stale. For a broader survey, see our open-source agent frameworks comparison and our deeper look at how eve compares to LangChain and CrewAI.

Read the table by the column that matters to you. If portability is the priority, Mastra is the natural pick — it is platform-agnostic, TypeScript-first, and self-hostable, with durable execution provided through Inngest. If you need the deepest graph control and time-travel debugging, LangGraph wins, but it is Python-first and not serverless-compatible, so it will not run on Vercel or Cloudflare Workers; its TypeScript port is not the primary supported version. CrewAI targets role-based multi-agent coordination in Python and has real enterprise adoption, but it is not a TypeScript-or-serverless answer.

eve’s row tells the strategic story plainly: it is the only framework here that is both serverless-native and backed by a managed durable runtime out of the box — and the only one you cannot self-host, because that runtime, the sandbox, and the model gateway are Vercel-proprietary. That is the deliberate trade. If your work already lives on Vercel, eve offers the shortest path from idea to production agent. If you need to run anywhere, the lock-in is the cost of admission, and Mastra or LangGraph will serve you better. For teams currently weighing a move off LangChain, our TypeScript agent migration playbook walks the cost-and-quality maths.

eve’s most persuasive proof point is that Vercel built it from patterns observed across hundreds of agents it runs internally, and it says more than 100 internal agents run on eve today. Vercel published the architectures of six of them to illustrate the framework’s range. They make a genuinely interesting case study — with one essential caveat: every metric below is vendor-stated by Vercel, drawn from its own launch materials, with no independent verification available at launch. Read them as what a platform vendor reports when it dogfoods its own framework, not as audited benchmarks.

The standout claim is the Lead Agent: an autonomous inbound-sales agent that Vercel says costs roughly $5,000 a year to run and delivered a 32x return with a single part-time engineer. Taken at face value, that is the kind of unit economics that reframes what a small team can attempt. Taken honestly, it is a single self-reported figure from the company selling the framework — exactly the sort of number to validate against your own workload before citing it in a business case. The same applies to Vertex’s 92% ticket-resolution rate and d0’s 30,000 monthly questions: useful as directional proof that the framework runs real production load, not as independently established performance.

The decision tree is cleaner than the launch noise suggests. eve is a strong default when you are already on Vercel and want durable, production-grade agents fast; it is the wrong default when portability or platform independence is a hard requirement.

Our reading of the launch is that the framing matters more than the feature list. eve’s technical pieces — durable execution, a sandbox, a model gateway — are individually unremarkable in 2026; several frameworks offer comparable primitives. What is genuinely new is the packaging: a filesystem-first convention that collapses scaffolding time and a distribution channel measured in millions of developers. Vercel reports that agent-triggered deployments climbed from under 3% to over 50% of all deployments on its platform in six months. If even a sliver of that base adopts eve for agentic workloads, the framework wins on reach long before it wins on any single capability — and that, not novelty, is the bet.

Looking forward, the more interesting question is whether agents-as-directories becomes a de-facto convention the way file-based routing did. If Vercel can make eve’s structure the shape that tooling, docs, and tutorials assume, the lock-in stops feeling like a tax and starts feeling like a standard — which is exactly how Next.js compounded. The counter-pressure is portability: teams burned by platform lock-in will keep a watchful distance, and Mastra exists precisely to serve them. Expect the TypeScript agent market to bifurcate along that line over the next year.