eve by Vercel: A Filesystem-First Framework for Durable AI Agents

The Problem eve Solves: Predictable Agent Structure

Building AI agents tends to produce code where the system prompt, tool definitions, channel handlers, and scheduling logic are scattered across files with no enforced layout. eve addresses this by making the filesystem the authoring interface. Every core capability of an agent lives in a conventional location: the always-on system prompt goes in agent/instructions.md, typed tool functions go in agent/tools/, procedures loaded on demand go in agent/skills/, message channels such as HTTP, Slack, or Discord handlers go in agent/channels/, and recurring cron jobs go in agent/schedules/. One optional file, agent/agent.ts, configures the model and runtime options.

This convention means that anyone who knows the eve project layout can open an agent directory and immediately find the system prompt, the tools, and the schedule without reading a configuration DSL or a framework-specific class hierarchy. The README describes this as making projects easier to inspect, extend, and operate.

eve is built by Vercel and released under the Apache-2.0 license. It is currently in public beta.

Quick Start: Scaffolding Your First eve Agent

The fastest way to create a new eve agent is with the init command:

npx eve@latest init my-agent

This creates a new my-agent directory, installs dependencies, initializes Git, and starts the interactive terminal UI. To start with a specific AI Gateway model, pass the model ID at init time:

npx eve@latest init my-agent --model openai/gpt-5.6-terra

To add eve to an existing project instead of creating a new directory:

npx eve@latest init .

Once initialized, the project contains an agent/ directory. Replacing agent/instructions.md with your system prompt and adding a tool file under agent/tools/ is enough for a working agent. After editing those files, start the agent with:

npm run dev

The README notes that the eve package includes its full documentation, so coding agents can read it locally from node_modules/eve/docs.

Building a Minimal Agent: Instructions, Tools, and Model Config

The README walks through a minimal weather demo. First, replace agent/instructions.md with a plain text system prompt. For example:

You are a concise weather demo assistant. Tell users that the weather data is mocked.

Next, add a tool at agent/tools/get_weather.ts. The tool uses eve's defineTool function and a Zod schema for input validation:

import { defineTool } from "eve/tools";
import { z } from "zod";

export default defineTool({
  description: "Return mock weather data for a city.",
  inputSchema: z.object({ city: z.string().min(1) }),
  async execute({ city }) {
    return { city, condition: "Sunny", temperatureF: 72 };
  },
});

To set the model, create agent/agent.ts:

import { defineAgent } from "eve";

export default defineAgent({
  model: "spacexai/grok-4.7",
});

Those three files produce a working agent. The README notes that human-in-the-loop prompts, subagents, and schedule definitions can be added incrementally.

Skills, Channels, and Schedules: Extending the Agent Layout

Beyond the required instructions.md, eve supports three optional extension points that each map to a directory.

Skills are procedures loaded on demand rather than on every request. They live in agent/skills/ as Markdown files. The README gives plan_a_trip.md as an example filename, suggesting these are task-scoped procedures the agent can invoke contextually rather than maintaining them in the permanent system prompt.

Channels define how the agent receives and sends messages. The agent/channels/ directory holds handlers for different input surfaces: the README gives slack.ts as an example. Channel handlers let the same agent logic surface over HTTP, Slack, Discord, or other transports without duplicating the core logic.

Schedules allow the agent to run recurring tasks. Files in agent/schedules/ contain cron job definitions; the README gives weekly_recap.ts as an example. This brings scheduled execution into the same file layout as everything else rather than requiring a separate cron service.

The monorepo also contains a skills/ directory at the repository root (separate from per-agent agent/skills/), a research/ directory, and an apps/ directory, indicating that the repository hosts both the framework packages and internal development tooling.

Beta Status and Known Constraints

eve is under the Vercel public beta terms. The README is explicit: the framework, APIs, documentation, and behavior may change before general availability. This is a real constraint for any team considering eve for production agent infrastructure.

The latest release at the time of the last push was [email protected], released on September 27, 2026. The rapid release cadence (0.67.0, 0.67.1, and 0.67.2 published within two days) is consistent with active development but also with ongoing API changes.

The README does not document a migration guide between versions, so teams upgrading between minor versions should test their agent definitions against the new release before deploying. Security vulnerabilities should not be reported through public GitHub issues; the README directs reports to [email protected] and the SECURITY.md file.

Community support is through GitHub Discussions. There is no documented paid support tier or SLA in the public repository.

eve vs. LangChain: Different Models for Agent Construction

LangChain is a widely used framework for building LLM-powered applications in Python and JavaScript. Its model is component-based: chains, agents, tools, and memory are objects constructed and composed in code. LangChain gives a developer maximum flexibility in how those components connect but does not enforce any particular file layout.

eve takes the opposite position. It enforces a filesystem layout and makes that layout the interface. The agent's system prompt is not a string in code; it is a Markdown file. Tools are not arbitrary functions; they live in a specific directory and are loaded by convention. This makes an eve agent easier to inspect without reading code, but it also means that agent behaviors must fit the framework's file-based model.

Teams already using LangChain who are satisfied with its component model have no reason to migrate. Teams building new agents from scratch who want a predictable, inspectable layout and plan to deploy on Vercel's infrastructure may find eve's conventions a better starting point.

Editorial conclusion

eve suits teams that want a structured, file-based approach to authoring AI agents and are comfortable with a beta-stage framework where APIs and behavior may change before general availability. The framework is not appropriate for production systems that require API stability guarantees, since the README explicitly states that the framework, APIs, documentation, and behavior may change. Check the latest release at [email protected] or later, and verify that your target AI model is available via the AI Gateway before starting.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes