eve: Vercel's Filesystem-First Framework for Building AI Agents

Vercel open-sourced eve, a framework that treats an AI agent as a directory of files instead of a tangle of glue code. The pitch on screen is direct: "Like Next.js for web apps, but for agents." Markdown handles instructions and skills, TypeScript handles tools, and the whole thing is durable by default.

The core idea is that the filesystem is the authoring interface. Core agent capabilities live in conventional locations, so a project is easier to inspect, extend, and operate. You can scaffold one with a single command shown in the video: npx eve@latest init my-agent.

An agent is a directory

eve maps each part of the agent stack to a file or folder. The README shows a typical layout like this:

my-agent/
  agent/
    agent.ts          # Optional: model and runtime config
    instructions.md   # Required: the agent's role and behavior
    tools/            # Optional: typed TypeScript tools
      get_weather.ts
    skills/           # Optional: Markdown procedure playbooks
      plan_a_trip.md
    channels/         # Optional: messaging integrations
      slack.ts
    schedules/        # Optional: recurring jobs
      weekly_recap.ts

The video walks through how each piece works:

1. Start with instructions. An instructions.md file is a complete agent on its own. You describe the agent's role in Markdown, then run it. The on-screen example defines an expert weather assistant.
2. Choose a model. eve uses a default model. Add agent.ts when you want to pick a specific model or configure the runtime. The example imports defineAgent from eve and sets a model through the AI Gateway.
3. Add reusable skills. Skills are Markdown playbooks loaded when they are relevant, so the agent pulls in the right procedure at the right time.
4. Add typed tools. Custom tools are plain TypeScript files in the tools/ folder.
5. Connect channels. A channel file lets the same agent run in Slack, Discord, Teams, or the web. The example imports connectSlackCredentials and wires up a Slack channel.
6. Deploy your stack. You connect data sources and then deploy the files straight to Vercel functions in one shot.
7. Delegate to subagents. A main agent can hand off specialized work to subagents.

Durable and sandboxed by default

Two runtime features stood out in the video. eve gives agents sandboxed compute, and it provides durable sessions that survive crashes and redeploys. The README frames eve as "a filesystem-first framework for durable AI agents." One defineSandbox example on screen sets a nodejs24 runtime backend for isolated execution.

The workflow the author highlights: spin up an agent locally, then push the same files to Vercel functions without a rewrite. The framework compiles the directory, wires up durable workflows, and connects the channels you defined.

What the repo shows

• Repository: github.com/vercel/eve, marked "Made by Vercel"
• License: Apache 2.0
• Homepage: vercel.com/eve, tagline "The Framework for Building Agents"
• At the time of the video: roughly 969 stars, 42 forks, published on NPM around version 0.11.4

Key Takeaways

• eve models an entire agent as a directory of files, with conventional locations for instructions, skills, tools, channels, and schedules.
• Markdown handles instructions and skills. TypeScript handles custom tools. An instructions.md file alone is a runnable agent.
• Sessions are durable and compute is sandboxed, so agents survive crashes and redeploys.
• One channel definition lets the same agent run across Slack, Discord, Teams, or the web.
• You develop locally and deploy the same files straight to Vercel functions. It is open source under Apache 2.0 at github.com/vercel/eve.