Vercel shipped eve at Ship London yesterday — an open-source framework where an AI agent is a directory of files. Tools go in tools/
. Instructions go in instructions.md
. Skills, channels, schedules, and subagents each get their own folder. The framework discovers everything automatically and includes production infrastructure — durable sessions, sandboxed compute, human-in-the-loop approval gates — without a line of configuration code.
Agents Are Just Directories #
The central idea sounds almost too obvious: the filesystem is the configuration. You want a tool called run_sql
? Create agent/tools/run_sql.ts
. You want a Slack channel? Run eve channels add slack
and a channels/slack.ts
file appears. The directory tree is the agent contract.
Here is the full layout of an eve agent:
agent/
agent.ts ← model selection, runtime config
instructions.md ← system prompt in Markdown
tools/ ← typed actions; filename = tool name
skills/ ← knowledge files loaded contextually
subagents/ ← delegated specialist agents
channels/ ← Slack, Discord, HTTP, cron endpoints
schedules/ ← timer-based autonomous triggers
connections/ ← MCP servers and OpenAPI backends
This mirrors exactly how Next.js won the frontend framework wars: pages/
for routing, app/
for layouts, convention over configuration. Vercel is making the same bet for agents, and the pattern is familiar enough that TypeScript developers will recognize it on day one.
What Ships Bundled (The Part That Actually Matters) #
Most agent frameworks give you an agent loop and leave the rest to you. Eve ships six production capabilities that teams normally spend months building:
Durable execution— Sessions checkpoint each step via Vercel Workflow’s event-log replay. Agents survive crashes, new deployments, and multi-day s without losing state.Sandboxed compute— Agent-generated code runs in ephemeral microVMs, not inside your application process.** Human-in-the-loop**— TheneedsApproval
directive s any tool call until a human confirms. No custom retry logic required.Secure connections— MCP and OpenAPI integrations route through Vercel Connect. Models never see raw API keys.** Multi-channel**— The same agent handles HTTP, Slack, Discord, Teams, Telegram, GitHub, and Linear without separate deployments.** Observability**— Per-turn OpenTelemetry spans for every model call, tool execution, and sandbox command, exportable to Datadog or Braintrust.
Infrastructure is where agent projects go to die. Durability, sandboxing, and approval gates are not glamorous problems, but they are the ones that block production deployments. Eve removes those blockers from the start.
Getting Started in About a Minute #
The minimal working agent requires two files:
// agent/agent.ts
import { defineAgent } from "eve";
export default defineAgent({ model: "anthropic/claude-opus-4.8" });
// agent/instructions.md
You are a concise assistant. Use tools when they are available.
To scaffold and start:
npx eve@latest init my-agent # scaffold, install deps, start dev server
eve dev # interactive terminal UI + HTTP API
eve eval # run test suites locally or in CI
vercel deploy # ship to production unchanged
Here is a tool definition with an approval gate:
// agent/tools/run_sql.ts
import { defineTool } from "eve/tools";
import { z } from "zod";
export default defineTool({
description: "Run a read-only SQL query.",
inputSchema: z.object({ sql: z.string() }),
needsApproval: ({ toolInput }) => estimateScanGb(toolInput.sql) > 50,
async execute({ sql }) {
// query logic here
},
});
The filename becomes the tool name. The needsApproval
function s execution before expensive queries and waits for confirmation in whatever channel the session is running on. The same directory that runs locally deploys to production with vercel deploy
— no infrastructure changes.
Where Eve Fits (And Where It Does Not) #
The TypeScript agent framework landscape now has two serious options: eve and Mastra. The key difference is platform coupling. Mastra is platform-agnostic — built by the Gatsby co-founders alongside a Next.js co-creator, runs on any Node.js host. Eve defaults to Vercel. That is not a limitation if you are already on Vercel, but it is a real constraint if you are not.
Against LangGraph — the most established agent framework — eve wins on TypeScript-first development and serverless compatibility. LangGraph is Python-first and does not support serverless environments natively. If your team writes TypeScript and your infrastructure is Vercel or edge-compatible, eve is the cleaner path.
Against a DIY stack, the comparison is not close. Tool registration, durable state management, sandboxing, and deployment are months of engineering work. Eve replaces all of it with a directory structure.
Vercel Ran This in Production First #
Eve is not a framework built for a launch announcement. Vercel ran the same pattern internally before open-sourcing it. Their Slack analyst handles 30,000 questions per month. Their SDR agent returns roughly 32x ROI. Their support agent resolves 92% of tickets without human intervention. Agent-triggered deployments on the Vercel platform grew from under 3% to over 50% of all deploys in the past six months.
That operational history matters. The six capabilities bundled into eve were extracted from real systems that needed to survive crashes, credential leaks, and runaway compute — not designed on a whiteboard.
Beta Caveats #
Eve is in public beta. The documentation is explicit: “pin your versions and expect some churn if you build on this today.” APIs will change before general availability. This is not a framework to drop into a mission-critical system immediately, but it is a practical choice for new agent projects where the production infrastructure question would otherwise take months to answer.
The framework is available on GitHub under Apache-2.0. The official documentation includes the full API reference. Start with npx eve@latest init
and review the Ship announcement for the full feature set.