# Vercel eve: The Open-Source Agent Framework That Treats Agents as Directories

> Source: <https://byteiota.com/vercel-eve-the-open-source-agent-framework-that-treats-agents-as-directories/>
> Published: 2026-06-22 09:18:13+00:00

Vercel shipped `eve`

on June 17 at its Ship London event, and the pitch is almost annoyingly simple: your agent is a directory of files. Drop an `instructions.md`

in `agent/`

, add typed tools in `agent/tools/`

, and `eve`

compiles the whole thing into a durable service on Vercel Functions — checkpointed execution, sandboxed compute, and human-in-the-loop approvals included. The framework is open source, in public beta, and Vercel is already running over 100 agents in production on it internally. The [official announcement](https://vercel.com/blog/introducing-eve) calls it “Next.js for agents” — the tagline is marketing, but the filesystem-first model is a real idea worth taking seriously.

## The Directory Is the Agent

Most agent frameworks ask you to configure an orchestration graph, wire up memory backends, and glue together a dozen integrations. Eve’s answer is convention over configuration — the same bet Next.js made with file-based routing, applied to agents.

A minimal eve agent lives in four locations:

**agent/instructions.md**— your system prompt, written in plain Markdown** agent/tools/*.ts**— typed tool definitions using Zod schemas** agent/skills/*.md**— reusable playbooks the agent can invoke on demand** agent/channels/*.ts**— channel connectors for Slack, Discord, Teams, and more

Eve discovers these files at build time and wires everything together. The only two languages you touch are TypeScript and Markdown. That’s a deliberately small surface area — and for most agent framework use cases, it’s the right call.

Here’s what a tool definition looks like:

``` js
// agent/tools/check_status.ts
import { defineTool } from 'eve/tools';
import { z } from 'zod';

export default defineTool({
  description: 'Check deployment status',
  inputSchema: z.object({
    deploymentId: z.string(),
  }),
  execute: async ({ deploymentId }) => {
    return { status: 'ready', url: `https://...` };
  },
});
```

That’s the whole API surface for a tool. Zod schema, execute function, description. Eve handles the rest — registration, type inference, error handling.

## Durable Execution Is the Feature That Actually Matters

Pretty directory structure aside, the reason eve is interesting is durable execution. Most agent frameworks treat session state as your problem. If your server crashes mid-conversation, the session is gone. If you push a new deployment while an agent is mid-task, you are rolling the dice.

Eve makes durability the default. Every conversation is a workflow — each step is checkpointed using Vercel’s open-source [Workflow SDK](https://github.com/vercel/workflow-sdk). Push a new deploy while a session is active? The session finishes on the version it started on, then migrates. Server crash? It resumes from the last checkpoint. This is built into the framework, not a feature you configure later.

For anyone who has tried to build a production agent and discovered that “just add a database for state” is significantly harder than it sounds, this is the right default.

## One Agent, Any Channel

Eve ships with multi-channel support out of the box. One agent codebase deploys to web chat, Slack, Discord, Teams, Telegram, Twilio, GitHub, and Linear. You add a file to `agent/channels/`

to connect a new surface — the agent logic doesn’t change, only the connector does.

Sessions persist across channels. A conversation started in a Slack DM can continue on the web. An alert that arrives via GitHub webhook can open an investigation thread in Slack. This is the kind of cross-channel session continuity that usually requires custom infrastructure to build and maintain.

## Why Vercel Is Making This Move

At Ship London, Vercel revealed a stat worth sitting with: six months ago, fewer than 3% of deployments on its platform were triggered by coding agents. Today it’s over 50%, with monthly token volume jumping from 2 trillion to 20 trillion. The platform is already in an agentic transition whether Vercel builds for it or not.

Eve is Vercel’s bet that the deployment layer for agents will be as valuable as the deployment layer for web apps was a decade ago. The other announcements at Ship fill in the picture: Vercel Connect brings short-lived OAuth tokens for integrations, Vercel Passport puts enterprise AI apps behind an identity provider, and [analysts tracking the announcement](https://thenewstack.io/vercel-launches-eve-an-open-source-framework-that-treats-agents-as-directories/) note that Vercel Services (backend state layer) launches July 1. Eve is the developer-facing surface of a larger infrastructure stack.

## Getting Started

The quickstart is one command:

```
npx create-eve-app my-agent
```

It scaffolds the project, installs dependencies, initializes Git, and starts a dev server. You should have an agent running locally in under a minute. The dev server exposes a simple HTTP API: `POST /eve/v1/session`

to create a session, `GET /eve/v1/session/:id/stream`

to attach to it. Full documentation is at [vercel.com/docs/eve](https://vercel.com/docs/eve) and the source is at [github.com/vercel/eve](https://github.com/vercel/eve).

## The Honest Take

Eve is not neutral infrastructure. The durable runtime, sandboxed compute, and AI Gateway routing are Vercel-proprietary. You cannot self-host this. If your organization requires running on AWS, GCP, or bare metal, eve does not work for you — look at [LangGraph](https://langchain-ai.github.io/langgraph/) instead, which is self-hostable and has a more mature Python ecosystem. Eve is also TypeScript-only, which cuts out Python developers entirely. And it is a public beta — the API will change before GA.

That said: if you are already on Vercel, building TypeScript agents, and tired of the complexity overhead that comes with LangChain and CrewAI for straightforward use cases, eve is worth trying today. The filesystem model is genuinely simpler. Durable execution out of the box is a real advantage over most alternatives. And Vercel’s own production use of the framework — including an internal data analyst agent handling 30,000 questions per month — is a meaningful signal that it is not vapourware.

For everyone else: watch the GA release. The pattern is good. The platform constraints may relax over time.
