# Vercel Eve: Open-Source Agent Framework for TypeScript

> Source: <https://byteiota.com/vercel-eve-open-source-agent-framework-for-typescript/>
> Published: 2026-06-18 12:13:02+00:00

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 pauses without losing state.**Sandboxed compute**— Agent-generated code runs in ephemeral microVMs, not inside your application process.** Human-in-the-loop**— The`needsApproval`

directive pauses 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:

``` js
// 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:

``` js
// 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 pauses 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](https://mastra.ai). 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](https://www.langchain.com/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](https://github.com/vercel/eve) under Apache-2.0. The [official documentation](https://vercel.com/docs/eve) includes the full API reference. Start with `npx eve@latest init`

and review the [Ship announcement](https://vercel.com/changelog/introducing-eve-an-open-source-agent-framework) for the full feature set.