Vercel's filesystem-first framework derives every capability from where a file lives — and runs each turn as a durable, resumable workflow. A look at what that buys you, and what it costs while it's still v0.11. Reliable by architecture. Not yet by track record.
agent/tools/get_weather.ts is the tool get_weather. No registry, no name/id fields — rename the file and its identity moves.model takes a Vercel AI Gateway model-id string (documented default anthropic/claude-sonnet-4.6) or a provider object like openai("gpt-5.1-codex") for a direct call.Shipping an agent today usually means assembling a stack by hand. You wire an LLM SDK to a tool router, bolt on a memory or checkpoint store, stand up a queue or worker fleet for anything long-running, add a sandbox for code execution, hand-roll auth on your HTTP route, and re-deploy the whole thing every time you add a tool.
The result is glue-code sprawl: orchestration logic, state management, and capability registration scatter across config objects and bootstrap files. State is fragile — a serverless timeout or a crash mid-run loses the reasoning chain and re-issues side effects: duplicate emails, refunds, payments. And capability is centrally registered, so every new tool, channel, or subagent is another edit to a wiring file.
eve's thesis is two moves at once: make the filesystem the source of truth, and make durability the substrate. Capability is derived from where a file lives — no central registry. Each turn is a durable workflow that survives restarts by default. The framework — not your glue code — owns discovery, the HTTP surface, the reconnectable stream, session state, auth, and the sandbox.
This is the same instinct Next.js had for the web: convention over configuration, the file tree as the API. eve applies it to backend agents. Whether that trade pays off depends on how much you value structure over ecosystem breadth — a question this piece tries to answer honestly.
Identity is registered in code — name/id fields, central arrays. Durability is opt-in: add a checkpointer, queue, or external orchestrator. Surfaces: wire each channel and write your own route auth. Code execution: bring and secure your own sandbox.
Adding capability means editing wiring and redeploying the world. Maturity is the upside: the libraries (LangChain, the AI SDK) are battle-tested across years of production use.
Identity is path-derived: agent/tools/<snake>.ts becomes the tool name. Durability is default: every turn is a durable workflow on the Workflow SDK. Surfaces: one agent over many channels with a fail-closed ordered auth walk. Sandbox: a per-session disposable sandbox for shell/file tools.
Adding capability means adding a file in the right folder. Maturity is the cost: v0.11 preview — opinionated but young.
eve isn't arriving in a vacuum. There are roughly three families of agent toolkits in 2026, each with a different center of gravity. Click each to explore where it shines and where it strains — eve included, with its weaknesses stated plainly.
A composable toolkit of LLM calls, prompts, tools, and chains. The bare Vercel AI SDK lives here too as a primitive: an Agent loop with stopWhen/prepareStep, but no built-in durability, memory, channels, scheduling, or sandbox.
The de-facto building blocks for LLM apps. You wire calls, tools, and chains together yourself, retaining full control over every step of the loop.
Hundreds of integrations, Python and JS/TS, and unmatched prototyping speed. If a connector exists anywhere, it likely exists here first.
You assemble durability, memory, surfaces, and auth yourself. Long-running reliability is your responsibility — the library hands you primitives, not guarantees.
Years of production use, the largest community in the space, and a vast surface area of documented patterns and battle-tested integrations.
LangGraph's typed stateful graphs (nodes/edges + reducers), CrewAI's role-based Crews plus event-driven Flows, and Microsoft's Agent Framework (the merger of AutoGen + Semantic Kernel) for conversational/actor multi-agent.
Explicit models for branching, multi-agent topologies, and the agent loop. You describe the control flow as a graph, crew, or conversation.
LangGraph 1.0 (Oct 2025, no breaks until 2.0); CrewAI ~47–48k stars; Microsoft Agent Framework GA (Apr 2026). Production-proven, Python-first.
Steep learning curve and heavy state abstraction. OSS LangGraph has no automatic failure detection — true distributed durability lives in the paid Platform; CrewAI durability is opt-in.
Microsoft moved AutoGen + Semantic Kernel into maintenance mode; new builds target MAF or the community AG2 fork. The graph world is consolidating.
Capability derived from file paths; each turn a durable workflow; channels, auth, sandbox, connections, and evals bundled. A stable HTTP route, reconnectable NDJSON stream, and durable session state — all from a directory.
The shape of agent/ is the agent. No registry, no wiring file — discovery, surfaces, and state are framework-owned.
Fail-closed auth, durable turns, and near-zero wiring out of the box. Provider-agnostic model field, integrated DX from a single CLI.
v0.11 pre-1.0, beta deps, a small community, TS/JS-only, and a fast-moving API. Several conveniences (Vercel Cron, Vercel Sandbox, Agent Runs dashboard) are Vercel-only.
eve is the least proven family member here. Its bet is that filesystem-derived structure plus durable-by-default is worth trading language reach and ecosystem breadth for.
| Dimension | Library / chains | Graphs & crews | Filesystem-first (eve) |
|---|---|---|---|
| Mental model | Compose calls / chains | Explicit graph / crew / conversation | Path = capability |
| Durability | DIY | Checkpoint (OSS) → distributed (Platform) | Durable workflow by default |
| Wiring cost | High | Medium–High | Low (add a file) |
| Languages | Python + TS | Python (+ .NET for MAF) | TS/JS only |
| Maturity | Very high | High | Low (preview) |
If LangChain's slogan is composition and LangGraph's is control, eve's is convention. The entire framework collapses into a single equation: the filesystem registers your capabilities, and the durable runtime makes them reliable.
The shape of your agent/ directory is the agent. There is no name field, no id, no central registry — move a file, and you move a capability.
This is more than a stylistic choice. Removing the registry removes an entire class of drift bugs — the tool that exists in code but was never wired up, the subagent registered twice, the channel whose handler points at the wrong file. In eve, those states are unrepresentable: if the file is in the folder, the capability exists; if it isn't, it doesn't. The other half of the equation — durable execution — means the reliability story isn't something you bolt on, but a property of the substrate every turn runs on.
The honest framing: eve did not invent durable execution, and it does not author a from-scratch Temporal competitor. It integrates the open-source Workflow SDK (Vercel Workflow) so that durability, fail-closed auth, sandboxing, compaction, and evals are defaults of a filesystem-first DX rather than libraries you assemble. The contribution is ergonomics and integration, not a novel durability engine.
eve is a layered system of conventions, each derived from the filesystem. The explorer below details each pillar — what it requires, what it recommends, and what advanced patterns it unlocks. Required / Recommended / Advanced are marked per bullet.
Capability is path-derived. There are no name or id fields anywhere — the location of a file is its identity, and the framework discovers everything by walking the tree.
agent/agent.ts (defineAgent) plus agent/instructions.md — a Markdown system prompt.agent/tools/<snake>.ts — the snake_case ASCII filename becomes the model-facing tool name.agent/skills/<name>.md — Markdown skills the agent can load on demand.subagents/<id>/agent.ts must export description and inherits nothing from the parent.connections/, schedules/ (root-only), channels/, hooks/, and lib/ (import-only — never reaches the sandbox).eve is provider-agnostic via the Vercel AI SDK. The model field accepts two shapes — a gateway string or a provider object — letting you route through the AI Gateway or call a provider directly.
model as a gateway string — e.g. "anthropic/claude-sonnet-4.6" — routing via AI Gateway (needs AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN).openai("gpt-5.1-codex") from @ai-sdk/openai, called directly with OPENAI_API_KEY. This project's choice.agent.ts to inherit the default model; when the file is present, model is required.Sessions are durable and resumable. Execution survives process restarts and redeploys, resuming from the last completed step — the core reliability argument, built on the open-source Workflow SDK.
.workflow-data).compaction.thresholdPercent (default 0.9) to control when older turns get summarized.One agent surface, exposed over many channels. The built-in HTTP surface is always present; chat surfaces are added as files. The edge is that it's one bundled surface — not that eve uniquely owns multi-channel.
POST /eve/v1/session, GET /eve/v1/session/:id/stream (NDJSON), POST /eve/v1/session/:id; GET /eve/v1/health is always public.channels/<name>.ts for Slack, Discord, GitHub, Linear, Telegram, Teams, Twilio, or custom surfaces.An ordered, fail-closed auth walk. Each entry accepts (returns context), skips (returns null), or rejects (throws). If everything skips, the request gets a 401 — auth fails closed by default.
AuthFn or ordered array. All-skip → 401; an empty array rejects all requests.[localDev(), vercelOidc()]; placeholderAuth() keeps a half-configured app at 401 in production until you choose real auth.localDev / vercelOidc / none / httpBasic / jwtHmac / jwtEcdsa / oidc plus custom. This project uses [localDev(), none()] for anonymous demo access — with an inline warning. Never ship none() over sensitive data.Every agent has exactly one per-session disposable sandbox. Only shell/file tools proxy into it; tool execute() code itself runs in the trusted app runtime. The default network policy is permissive, not locked down.
bash/read_file/write_file/glob/grep proxy in. Tool execute() runs in the trusted app runtime with process.env — secrets never enter the sandbox.skills/ and agent/sandbox/workspace/** mount into /workspace; the network policy is allow-all by default — tighten to deny-all / allow-list for sensitive work.vercel() (microVM) / docker() / microsandbox() / justbash(), plus defaultBackend() (Vercel→Docker→microsandbox→just-bash). just-bash has no real binaries and no network isolation — a dependency-free fallback, not an isolation story.Connections wrap MCP and OpenAPI as model-callable tools with credentials hidden from the model. Evals are a first-class harness: deterministic asserts and LLM judges over the same HTTP surface, with CI-friendly exit codes.
defineMcpClientConnection (URL + description) or defineOpenAPIConnection (one tool per operation). The model calls connection__<conn>__<tool> and never sees URLs or creds.connect() from @vercel/connect/eve (consent / storage / refresh); tokens cached per step, never serialized, never shown to the model. Approval helpers: never()/once()/always().evals/*.eval.ts, defineEval, deterministic asserts (t.completed/t.calledTool/t.toolOrder, t.check) plus LLM-judge (t.judge.autoevals.*); gates vs soft; eve eval exits 0 (pass) / 1 (fail) / 2 (config error); Braintrust + JUnit reporters.Where LangGraph gives control through explicit graph wiring and CrewAI through role config, eve moves the control surface to the filesystem. Flexibility here isn't just a long list of supported providers — it's that the shape of the project, the model, the surfaces, the tools, and the isolation are all swappable by adding or moving files.
Capability changes are file operations. Add a tool, rename to re-identify, drop in a channel — no central registry to edit, no wiring to keep in sync.
agent tool (shares sandbox/tools, fresh state) vs declared subagents (own dir, must export description)Provider neutrality is real — but flexibility has dimensions where established frameworks are still ahead. Honesty matters more than a clean win.
So the accurate claim is narrow but real: eve's flexibility is structural, not merely provider-level. It does not out-orchestrate LangGraph or out-reach LangChain. What it offers is a control model where moving a file is the configuration — and a genuinely strong, AI-SDK-grade provider story underneath.
eve's reliability argument rests on a mature, validated pattern — durable execution — made a default of the DX rather than a library you assemble. That's the genuine contribution. It is not a claim of more battle-testing than the incumbents.
Each safety property is a framework default that you'd otherwise hand-roll across separate libraries.
thresholdPercent 0.9; preserves read-before-write tracking and re-injects the todo listDurable execution is a category, not eve's invention — and the category leaders are formidable.
step.run()), Restate, Cloudflare Workflows (step.do()) all sell the durable layerThe precise claim: this is reliability by construction — fail closed, hide secrets, isolate code, resume from the last step — packaged as defaults. Tellingly, a category leader like Temporal competes on identical model plumbing (the same AI SDK), which validates the pattern and underlines that eve's edge is integration and ergonomics, not a unique durability engine.
Illustrative: each bar is glue-code the DIY/library stack expects you to wire and secure yourself; in eve these arrive as framework defaults (zero authored wiring). It depicts breadth of bundled concerns, not benchmark performance — and says nothing about battle-testing.
A direct comparison across the dimensions that actually decide a framework choice. Cells are written to be honest — eve's maturity row is the one that should give you pause, and it's stated as plainly as its strengths.
| Dimension | eve | LangGraph | CrewAI | OpenAI Agents SDK | Mastra |
|---|---|---|---|---|---|
| State / Durability | Durable workflow by default (Workflow SDK) | Checkpointing (OSS) → distributed in paid Platform | Opt-in @persist/SQLite Flow recovery |
Stateless; history backends; durable exec via Temporal (GA Mar 2026) | Suspend/resume; crash-durability via Inngest/Vercel Workflows |
| Multi-agent | Built-in agent tool + declared subagents |
Explicit graphs, mature | Role-based Crews + Flows | Handoffs within a run | Graph workflows (.then/.branch/.parallel) |
| Channels / surfaces | HTTP + 7 chat surfaces bundled | Bring your own | Bring your own | Node + Cloudflare/Twilio extensions | Deployers; bring your own surfaces |
| Tooling & MCP | defineTool + MCP/OpenAPI connections, creds hidden |
Rich tool/integration ecosystem | Tools + MCP | Tools + guardrails | Tools + MCP authoring |
| Auth | Fail-closed ordered route auth built in | App-level / Platform | App-level | App-level | App-level |
| Evals | First-class (eve eval, judges, reporters) |
LangSmith (deep) | Model-graded / rule / statistical | Tracing-centric | Built-in evals |
| Language | TS/JS only | Python + JS/TS | Python only | Python + JS/TS | TS only |
| Deployment | Vercel or self-host (Nitro/eve start) |
Cloud/Hybrid/Self-host/Developer | Cloud + on-prem (AMP) | Self-managed | Vercel/Cloudflare/Netlify/Node |
| Provider lock-in | Low — gateway string or any AI SDK provider | Low | Low | OpenAI-first (others best-effort beta) | Low (AI SDK router) |
| Maturity | Low — v0.11 preview, beta deps | High (1.0, no breaks until 2.0) | High (~47–48k stars) | High (GA Mar 2025) | Medium-high (v1.45, ~25k stars) |
Read the matrix as a portrait of trade-offs, not a scoreboard. eve leads on bundled surfaces, built-in auth, and durable-by-default execution; it trails decisively on maturity and language reach. Every cell here is consistent with the framework being a credible, well-designed preview — not a drop-in replacement for a production-proven incumbent.
The sequence below is the verified path. Node 24+ is required, and the model ids shown are illustrative. A couple of steps are marked as inference where the eve docs don't spell them out — flagged rather than asserted.
eve link/eve deploy (which wrap vercel deploy --prod); a global vercel install/login is an inference, not spelled out in eve docs.npx eve@latest init my-agent scaffolds, installs deps, inits Git, and opens the dev TUI. For an existing project: eve init . adds eve, ai, and zod.npx eve link links a Vercel project and pulls AI Gateway creds into .env.local. Skip if going direct-provider — set OPENAI_API_KEY instead.npm install @ai-sdk/openai (or another AI SDK provider).npm run dev runs next dev at localhost:3000. (Turbopack is a plausible Next 16 inference — not stated in eve docs; don't assert it.) eve dev never fires schedules; trigger via POST /eve/v1/dev/schedules/:id.eve build emits .eve/; then PORT=3000 eve start --host 0.0.0.0.eve deploy runs vercel deploy --prod (linking first if needed) — or just vercel deploy.Note the two flagged inferences: a global vercel login, and Turbopack under next dev. Both are reasonable, but neither is documented by eve — they're marked so the rest of the flow can be trusted as verified.
The smallest meaningful eve agent is three files: the agent definition, the Markdown instructions, and one tool. The filename of the tool — not any field inside it — becomes the model-facing tool name. Here is the exact layout and the verified, copy-paste code.
This project's direct-provider example. The documented default is the gateway string "anthropic/claude-sonnet-4.6", shown as a comment.
The system prompt is just Markdown — no code, no escaping, no template object.
The filename must be snake_case ASCII; it becomes the tool name the model sees. Note that execute() runs in the trusted app runtime — it has process.env and never touches the sandbox.
Start a session over the built-in HTTP surface and stream the NDJSON events back.
That's the whole agent. No registry call, no router config, no tools: [getWeather] array. The tool exists because the file exists in agent/tools/, and it's named get_weather because that's the filename. To add a second tool, you add a second file — nothing else changes.
A framework review that only lists strengths is marketing. Here are the concrete situations where eve is the wrong call today — each one a real limitation, not a softened caveat.
ai@7.0.0-beta.178, next@16.2.6, @workflow/* 5.0.0-beta). Durability is by construction, not by years of production. Reach for LangGraph, CrewAI, or Temporal-backed stacks.vercel()/docker()/microsandbox() for real isolation.The single most important sentence in this article: do not pick eve because it is more proven — it is not. Pick it for the architecture, with full awareness that you are adopting v0.11 preview software on beta dependencies. Treat every reliability claim here as "reliable by construction," never "battle-tested at scale."
eve is a wager that the best agent framework is one you barely have to configure. Whether that wager pays off depends less on eve's age and more on whether convention-over-orchestration is the future of backend agents.
eve is a wager that the best agent framework is one you barely have to configure — where moving a file moves a capability, and a crash is just a pause. It isn't the most proven framework in the room, and it doesn't pretend to be. But it is the most honest about what reliability should feel like: a property of the system, not a chore for the developer.
— Haroon K M, June 2026