# What is Vercel eve, and should you build agents on it?

> eve is Vercel’s open-source agent framework, launched in June 2026 under Apache-2.0. Every agent is a directory: instructions in markdown, one typed tool per TypeScript file, plus skills, subagents, channels, and schedules. Durable execution, sandboxing, approvals, tracing, and evals ship in the box - and despite the reflexive lock-in take, you can self-host it off Vercel.

*By Muhammad Idrees · Published July 17, 2026*

## Key takeaways

- eve is Vercel’s open-source (Apache-2.0) agent framework, launched at Ship London in June 2026 and still in beta - it turns a directory of files into a durable backend agent.
- Every capability is a file: instructions.md is the system prompt, each TypeScript file in tools/ is one tool, and skills, subagents, channels, connections, and schedules are just more folders.
- The real pitch is the plumbing you do not write - durable execution that survives crashes and deploys, a sandbox, human approvals, tracing, and evals all ship in the box.
- It is not the lock-in the hot takes claim. eve build and eve start produce a plain Nitro Node server, and Vercel Labs publishes a proof of concept running eve with zero Vercel-proprietary infrastructure.
- What you actually trade by leaving Vercel is specific and short: the Agent Runs dashboard, Vercel Cron, sandbox prewarm, latest-deployment routing, and network allowlists.

## By the numbers

- **Apache-2.0, June 2026** - eve launched at Vercel Ship London as an open-source framework, and is still in beta ahead of general availability. ([source](https://vercel.com/blog/introducing-eve))
- **2 files** - The minimum viable eve agent: an instructions.md system prompt and an agent.ts that names a model. ([source](https://vercel.com/docs/eve))
- **100+ agents** - Vercel says it runs more than a hundred eve agents internally, including a data analyst fielding over 30,000 questions a month. Vendor-reported. ([source](https://vercel.com/blog/introducing-eve))
- **3% to 29%** - Vercel’s claimed share of its own deployments triggered by agents rather than humans, before and after its agent fleet. Vendor-reported and unverified. ([source](https://vercel.com/blog/introducing-eve))

Every few months a new agent framework arrives promising to be the one. Most hand you a graph API, an orchestration DSL, and a decorator or two, and you still spend the first sprint building the same boring infrastructure - retries, state that survives a deploy, somewhere safe to run untrusted code, a way to ask a human before the agent does something expensive. Vercel’s eve makes a different bet. It does not give you an API to learn. It gives you a folder.

## What is Vercel eve?

eve is an open-source framework for building durable backend AI agents, released by Vercel under the Apache-2.0 license at Ship London on 17 June 2026. It is filesystem-first: you author an agent as a set of conventionally named files under an agent/ directory, and eve discovers them, validates them, compiles a manifest, and serves the result as a deployable app. Vercel calls it “Next.js for agents,” which is marketing but also a fair description of the trade - convention over configuration, with the production concerns handled for you.

It sits above the AI SDK rather than replacing it, and it takes its durability from Vercel’s open-source Workflow SDK. The framework is still in beta: the docs say the APIs and behavior may change before general availability, and the release cadence backs that up, with the package moving through the 0.24.x line within a month of launch. Treat it as production-capable but not yet API-stable.

## Why is every agent a directory?

This is the whole idea, so it is worth being concrete. An eve agent is not a class you instantiate or a graph you wire up. It is a folder whose layout is the API:

```text
agent/
  instructions.md      the always-on system prompt
  agent.ts             model and runtime config
  tools/               one typed tool per .ts file
  skills/              procedures loaded only when relevant
  subagents/           child agents with their own context
  channels/            entry points: HTTP, Slack, Discord, GitHub
  connections/         typed integrations with external services
  schedules/           cron jobs
  sandbox/             the agent’s isolated compute environment
  instrumentation.ts   optional OpenTelemetry setup
```

Directories are auto-discovered by name, so adding a capability is usually just adding a file. The filename in tools/ becomes the tool name the model sees, which means renaming a file renames the tool. If that pattern feels familiar, it should: it is the same bet Anthropic made with Claude Code skills - capability as plain text on disk, loaded on demand rather than crammed into one enormous prompt. Two companies arriving independently at the same shape is a signal worth noticing.

## What does an eve agent look like in code?

A minimal agent is two files. The instructions are literally just markdown - “You are a concise assistant. Use tools when they are available.” - and agent.ts names a model:

```typescript
import { defineAgent } from 'eve';

export default defineAgent({
  model: 'openai/gpt-5.4-mini',
});
```

Model strings resolve through Vercel’s AI Gateway, so a deployed agent authenticates with OIDC instead of you managing provider keys. Adding a capability means adding a file. Here is agent/tools/get_weather.ts, where the filename becomes the tool name the model sees:

```typescript
import { defineTool } from 'eve/tools';
import { z } from 'zod';

export default defineTool({
  description: 'Get the current weather for a city.',
  inputSchema: z.object({ city: z.string() }),
  async execute(input) {
    return { city: input.city, condition: 'Sunny', temperatureF: 72 };
  },
});
```

Then you POST to /eve/v1/session and attach to the stream to watch it work. That is the entire mental model: files in, a durable streaming session out.

## What do you get that you would otherwise build yourself?

Vercel’s framing is that every team was rebuilding the same plumbing before their agent could do anything. That is the honest pitch, and it is the strongest argument for eve. None of the items below are things you would choose to skip - they are what separates a demo from a system, and each is a project on its own:

| Capability | What ships in the box | What it saves you |
| --- | --- | --- |
| Durable execution | Sessions run on Workflows - progress is an event log, deterministically replayed | Your own checkpointing, retries, and resume-after-deploy logic |
| Sandboxing | One isolated bash-style environment per agent, with bash, read_file, and write_file | A container runtime for model-generated code |
| Approvals | needsApproval on any tool; the run pauses without consuming compute | A pause/resume queue and a human-in-the-loop state machine |
| Channels | Slack, Discord, Teams, Telegram, GitHub, Linear, and HTTP by default | A webhook adapter and message formatter per platform |
| Subagents | Child agents with their own tools and a fresh context window | Your own delegation and context isolation |
| Observability | Agent Runs in the dashboard with no setup, plus OpenTelemetry export | Span plumbing into Datadog, Honeycomb, Braintrust, or Jaeger |
| Evals | defineEval suites you run locally or in CI against a deployed agent | A bespoke regression harness for non-deterministic output |

The durable execution deserves a note, because it is the part most teams underestimate. A session is a workflow whose progress is persisted as an event log and deterministically replayed, so it survives cold starts, redeploys, and long pauses. An agent waiting three days for someone to approve a refund costs nothing while it waits. That is genuinely hard to build, and it is the difference between an agent that demos and an agent that runs a business process.

## Is eve just Vercel lock-in?

This is the reflexive objection, and it deserves a real answer rather than a vibe. The short version is no, and the long version is checkable.

Self-hosting is fully supported. The eve build and eve start commands produce a standard Nitro Node server under .output/ that runs in a container, on a VM, behind your own proxy - the same build command that writes a Vercel Build Output bundle when you deploy to Vercel instead. What changes off-platform is four explicit swaps:

| Concern | On Vercel | Self-hosted |
| --- | --- | --- |
| Durability | Vercel Workflows | The Workflow SDK’s local disk world, or a Postgres world |
| Model routing | AI Gateway model strings with OIDC | AI_GATEWAY_API_KEY, or a direct provider SDK and its key |
| Sandbox | Vercel Sandbox microVMs | defaultBackend - Docker, microsandbox, or just-bash |
| Route auth | vercelOidc | httpBasic, jwtHmac, jwtEcdsa, oidc, or your own verifier |

Vercel Labs even ships the proof: steve, a public proof of concept that runs eve end to end with zero Vercel-proprietary infrastructure - durability from a self-hosted Postgres workflow world, isolation from a Docker sandbox, model calls straight to OpenAI or Anthropic, and an Ansible pipeline that stands the whole thing up on a DigitalOcean droplet behind Caddy. When the vendor publishes the escape hatch, the lock-in argument gets weaker.

There is one gotcha worth writing on the wall, because it fails silently. If you put a reverse proxy in front of eve, it must forward both /eve/ and /.well-known/workflow/. Proxy only /eve/ and your sessions will start normally and then stall forever, because the workflow callbacks never arrive.

What you actually give up by leaving Vercel is specific and short: the Agent Runs dashboard, Vercel Cron for schedules, sandbox prewarm, latest-deployment routing, and network allowlists. That is the honest shape of it. This is the Next.js bargain applied to agents - portable by license and by design, but the paved road runs through Vercel, and you pay for the detour in operational work rather than in license terms.

## What does eve cost?

The framework is free and Apache-2.0. What you pay for is the infrastructure underneath it, and eve is unusually candid about this: usage is billed through Vercel Functions for serving agent routes, Vercel Workflows for persisting sessions, Vercel Sandbox for isolated execution, and AI Gateway plus your model provider for tokens.

The cost driver people miss is durability itself. Every stream write is persisted by Workflows and counts toward data written and retained, so a chatty agent streaming long answers pays for storage as well as tokens. The mitigations are the obvious ones done deliberately: cheaper models for low-risk turns, tool results and history kept short, repeatable instructions moved into skills so they load only when relevant, and long jobs broken into smaller sessions or subagents before they approach Workflow replay limits. Turn on spend management before you turn on the agent.

## How does eve compare to other agent frameworks?

The useful comparison is not a feature checklist. It is where the thing wants to live.

| Dimension | eve | Mastra | LangGraph |
| --- | --- | --- | --- |
| Language | TypeScript and markdown | TypeScript | Python-first |
| Unit of composition | A file in a directory | Code-defined workflows | A graph of nodes |
| Durable execution | Built in, via Workflows | Via Inngest | Via its own checkpointers |
| Sandbox and approvals | In the box | Assemble yourself | Assemble yourself |
| Self-host | Supported, with four swaps | Native - platform agnostic | Native, but not serverless-friendly |
| Best home | You are already on Vercel | You must run anywhere | Python shops and research |

If your work already lives on Vercel and your team writes TypeScript, eve is the shortest path from idea to a production agent that anyone has shipped. If running anywhere is a hard requirement, Mastra is the more natural pick - platform-agnostic, with durability through Inngest. If your stack is Python, LangGraph is still where the ecosystem is, though it will not run serverless. And if you would rather the model vendor operate the whole thing, Claude Managed Agents attack the same problem from the opposite end - there is a companion post on those.

## Does it actually work in production?

Vercel’s answer is that it runs more than a hundred eve agents internally, and it names them: d0, a data analyst fielding over 30,000 questions a month; Vertex, a support agent it credits with 92% self-resolution; a lead agent it says returns 32x; Athena for sales. It also reports that the share of its deployments triggered by agents rather than humans went from 3% to roughly 29%, and expects that to reach half.

Here is where the senior-engineer hat goes on. Every one of those numbers is Vercel reporting on Vercel’s agents running on Vercel’s platform, with no independent verification and no definition of terms - 92% self-resolution of what, measured how, against which baseline? Treat the magnitude as unproven. What survives the skepticism is the structural fact underneath: eve is dogfooded at real scale by the company that ships it, which is more than most agent frameworks can honestly claim, and it means the sharp edges got found by someone other than you. That is worth something even if the percentages are not.

## Should you build on eve?

Reach for it if you write TypeScript, you are already deployed on Vercel, and you want durability, approvals, sandboxing, and evals without assembling four libraries to get them - especially if your agent needs to live in Slack or GitHub where your team already works. Be more careful if you are a Python shop, if you need API stability guarantees today rather than after general availability, or if you must run on your own infrastructure and have no appetite for the four swaps and the proxy gotcha above.

The more durable observation is not about Vercel at all. Between eve’s directory of files and Claude Code’s skills, the industry is converging on the same answer: agent capability is becoming plain text in a repository - reviewable, diffable, ownable - rather than configuration trapped in someone’s dashboard. Frameworks will keep churning; that shift will not. Choosing the right substrate for an agent, and knowing which parts of the pitch to believe, is the work we do at Sentient Arc - and it usually starts by reading the deployment docs rather than the launch post.

## Frequently asked questions

### What is Vercel eve?

eve is Vercel’s open-source agent framework, released under Apache-2.0 in June 2026. It is filesystem-first: you define an agent as files under an agent/ directory - instructions in markdown, one typed tool per TypeScript file, plus skills, subagents, channels, and schedules - and eve compiles that into a durable, deployable backend agent.

### Is Vercel eve free and open source?

The framework is free and Apache-2.0 licensed. The infrastructure is not. On Vercel you pay for Functions, Workflows, Sandbox, and AI Gateway, plus model tokens. Self-hosted, you pay for whatever you choose to run it on instead.

### Can you self-host eve, or does it require Vercel?

You can self-host it. The eve build and eve start commands produce a standard Nitro Node server you can run anywhere. You swap the workflow world to local disk or Postgres, the sandbox to Docker or microsandbox, the model to a direct provider key, and the route auth off vercelOidc. Vercel Labs publishes steve, a proof of concept doing exactly that with no Vercel infrastructure at all.

### What do you lose if you self-host eve?

The Agent Runs dashboard, Vercel Cron for schedules, sandbox prewarm, latest-deployment routing, and network allowlists. Note one trap: a reverse proxy in front of eve must forward both /eve/ and /.well-known/workflow/, or sessions will start and then stall forever because the workflow callbacks never arrive.

### What is the difference between a tool and a skill in eve?

A tool is one TypeScript file in agent/tools/ that the model can call - typed, with the filename becoming the tool name. A skill is a procedure or reference material in agent/skills/ that the model loads only when it is relevant, keeping it out of the always-on prompt. Tools are actions; skills are knowledge.

### How is eve different from LangGraph or Mastra?

eve composes agents from files rather than graphs, and ships durable execution, sandboxing, approvals, and evals in the box - but its paved road runs through Vercel. Mastra is platform-agnostic TypeScript and self-hostable, with durability via Inngest. LangGraph is Python-first and not serverless-friendly. If you are already on Vercel, eve is the shortest path; if you must run anywhere, Mastra is the safer default.

### Is eve production-ready?

It is in beta, and Vercel says the APIs and behavior may change before general availability, so treat it as production-capable but not API-stable. Vercel does run more than a hundred eve agents internally, so it is dogfooded at real scale - though the performance figures it publishes are vendor-reported and not independently verified.

## Sources

- [Vercel - Introducing eve](https://vercel.com/blog/introducing-eve)
- [Vercel - eve documentation](https://vercel.com/docs/eve)
- [Vercel - eve concepts](https://vercel.com/docs/eve/concepts)
- [eve - Deployment guide](https://eve.dev/docs/guides/deployment)
- [Vercel - eve pricing and limits](https://vercel.com/docs/eve/pricing)
- [GitHub - vercel/eve](https://github.com/vercel/eve)
- [GitHub - vercel-labs/steve, a self-hosted eve proof of concept](https://github.com/vercel-labs/steve)

## Related posts

- [What are Claude Managed Agents, and when should you use them?](https://adrees.dev/blog/claude-managed-agents)
- [What does a production AI agent actually need?](https://adrees.dev/blog/what-a-production-ai-agent-needs)
- [What is OpenClaw, and should you actually run it?](https://adrees.dev/blog/openclaw-ai-agent)

---

More writing: https://adrees.dev/blog · Start a project: https://adrees.dev/#contact · Email: adreesdev@gmail.com