eve is a filesystem-first framework for durable backend AI agents, open-sourced by Vercel in June 2026. Capability is derived from where a file lives; every turn runs as a durable, resumable workflow. It is genuinely novel in architecture — and genuinely young as software.
- The directory is the contract.
agent/tools/get_weather.tsis the toolget_weather. No registry, noname/idfields — rename the file and its identity moves. - Durability is a default, not a decorator. Every turn runs as a durable workflow on the open-source Workflow SDK; sessions survive restarts and resume from the last completed step. eve integrates this engine rather than inventing it.
- Provider-agnostic by design.
modeltakes a Vercel AI Gateway model-id string (documented defaultanthropic/claude-sonnet-4.6) or a provider object likeopenai("gpt-5.1-codex")for a direct call. - Batteries the standalone durable engines leave out. One agent over many channels, fail-closed route auth, a per-session sandbox, brokered MCP/OpenAPI connections, and a first-class eval harness — all path-derived.
- It is young. Pre-1.0, beta-pinned dependencies, a fast-changing API, TypeScript/JS-only, and a smaller community than LangChain/LangGraph. Pick eve for the architecture — not because it is more proven. It isn't.
Building a production agent is mostly glue code
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.
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.
Three approaches to building agents
eve isn't arriving in a vacuum. There are roughly three families of agent toolkits in 2026, each with a different center of gravity. Each one below states where it shines and where it strains — eve included, with its weaknesses stated plainly.
Library / chains
Composable building blocks — you own orchestration. 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.
- What it is — flexibility by composition. 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.
- Where it shines — ecosystem & reach. Hundreds of integrations, Python and JS/TS, and unmatched prototyping speed. If a connector exists anywhere, it likely exists here first.
- Where it strains — reliability is on you. You assemble durability, memory, surfaces, and auth yourself. Long-running reliability is your responsibility — the library hands you primitives, not guarantees.
- Maturity — very high. Years of production use, the largest community in the space, and a vast surface area of documented patterns and battle-tested integrations.
Graphs & crews
Explicit orchestration models. 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.
- What it is — fine-grained control. Explicit models for branching, multi-agent topologies, and the agent loop. You describe the control flow as a graph, crew, or conversation.
- Where it shines — maturity & track record. LangGraph 1.0 (Oct 2025, no breaks until 2.0); CrewAI ~47–48k stars; Microsoft Agent Framework GA (Apr 2026). Production-proven, Python-first.
- Where it strains — checkpoints ≠ durable execution. 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.
- Caveat — shifting ground. Microsoft moved AutoGen + Semantic Kernel into maintenance mode; new builds target MAF or the community AG2 fork. The graph world is consolidating.
Filesystem-first (eve)
Path = capability. 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.
- What it is — structure as the API. The shape of
agent/is the agent. No registry, no wiring file — discovery, surfaces, and state are framework-owned. - Where it shines — durability & safety by default. Fail-closed auth, durable turns, and near-zero wiring out of the box. Provider-agnostic model field, integrated DX from a single CLI.
- Where it strains — maturity. 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.
- Honest read — a wager on convention. 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) |
Convention over orchestration
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.
agent/ directory is the agent. There is no name field, no id, no central registry — move a file, and you move a capability.— The filesystem-first principle, eve documentation
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.
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.
Inside eve: the seven pillars
eve is a layered system of conventions, each derived from the filesystem. Each pillar below details 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.
0 name/id fields · 11 authored slots · 1 rule: path = identity
- Required.
agent/agent.ts(defineAgent) plusagent/instructions.md— a Markdown system prompt. - Recommended.
agent/tools/<snake>.ts— the snake_case ASCII filename becomes the model-facing tool name. - Recommended.
agent/skills/<name>.md— Markdown skills the agent can load on demand. - Advanced.
subagents/<id>/agent.tsmust exportdescriptionand inherits nothing from the parent. - Advanced.
connections/,schedules/(root-only),channels/,hooks/, andlib/(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.
2 model shapes · 1 AI SDK · sonnet-4.6 documented default
- Required. Set
modelas a gateway string — e.g."anthropic/claude-sonnet-4.6"— routing via AI Gateway (needsAI_GATEWAY_API_KEY/VERCEL_OIDC_TOKEN). - Recommended. Or a provider object —
openai("gpt-5.1-codex")from@ai-sdk/openai, called directly withOPENAI_API_KEY. This project’s choice. - Advanced. Omit root
agent.tsto inherit the default model; when the file is present,modelis required. - Advanced. Model ids shown here are an illustrative near-future catalog — treat them as point-in-time.
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.
restarts + redeploys survived · last step resume point · 0.9 compaction threshold
- Required. Nothing — durability is on by default (Vercel Workflow on Vercel, else a local on-disk world under
.workflow-data). - Recommended. Make step side effects idempotent: a step interrupted mid-execution re-runs, while completed steps replay recorded results.
- Advanced. Durable parking for approvals, OAuth, or long subagents — holds no compute until input arrives.
- Advanced. Tune
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.
8+ surfaces · 1 agent · health always public
- Required. Built-in HTTP:
POST /eve/v1/session,GET /eve/v1/session/:id/stream(NDJSON),POST /eve/v1/session/:id;GET /eve/v1/healthis always public. - Recommended. Add
channels/<name>.tsfor Slack, Discord, GitHub, Linear, Telegram, Teams, Twilio, or custom surfaces. - Advanced. Channels must verify signatures in constant time and never trust body-supplied identity.
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.
fail-closed default posture · ordered auth walk · 401 on all-skip
- Required. An
AuthFnor ordered array. All-skip → 401; an empty array rejects all requests. - Recommended. Framework default (no channel file) is
[localDev(), vercelOidc()];placeholderAuth()keeps a half-configured app at 401 in production until you choose real auth. - Advanced. Helpers:
localDev / vercelOidc / none / httpBasic / jwtHmac / jwtEcdsa / oidcplus custom. This project uses[localDev(), none()]for anonymous demo access — with an inline warning. Never shipnone()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.
per-session lifecycle · 4 backends · allow-all default network
- Required. One per-session disposable sandbox; only
bash/read_file/write_file/glob/grepproxy in. Toolexecute()runs in the trusted app runtime withprocess.env— secrets never enter the sandbox. - Recommended. Only
skills/andagent/sandbox/workspace/**mount into/workspace; the network policy is allow-all by default — tighten to deny-all / allow-list for sensitive work. - Advanced. Backends:
vercel()(microVM) /docker()/microsandbox()/justbash(), plusdefaultBackend()(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.
MCP + API connection types · hidden creds · 0/1/2 eve eval exit codes
- Required.
defineMcpClientConnection(URL + description) ordefineOpenAPIConnection(one tool per operation). The model callsconnection__<conn>__<tool>and never sees URLs or creds. - Recommended. OAuth brokered via
connect()from@vercel/connect/eve(consent / storage / refresh); tokens cached per step, never serialized, never shown to the model. Approval helpers:never()/once()/always(). - Advanced. Evals:
evals/*.eval.ts,defineEval, deterministic asserts (t.completed/t.calledTool/t.toolOrder,t.check) plus LLM-judge (t.judge.autoevals.*); gates vs soft;eve evalexits 0 (pass) / 1 (fail) / 2 (config error); Braintrust + JUnit reporters.
Why eve's flexibility is structural
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.
Structural levers
The filesystem is the control surface. 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.
- Path-derived identity — add a file to add capability; rename to re-identify.
- Two model shapes, one SDK — gateway string or provider object.
- One surface, many channels — HTTP + Slack/Discord/GitHub/Linear/Telegram/Teams/Twilio/custom.
- Connections as drop-in tools — MCP + OpenAPI wrapped, creds hidden.
- Swappable sandbox backends — docker / vercel / microsandbox / just-bash, or auto-select.
- Subagents two ways — built-in
agenttool (shares sandbox/tools, fresh state) vs declared subagents (own dir, must exportdescription).
The fair comparison
Provider neutrality is real — but flexibility has dimensions where established frameworks are still ahead. Honesty matters more than a clean win.
| Verdict | Where rivals lead, and where they do not |
|---|---|
| eve ahead | eve cleanly beats the OpenAI Agents SDK on model neutrality (OpenAI-first; others "best-effort, beta"). |
| eve ahead | eve edges Google ADK (Gemini-first via LiteLLM); matches Mastra and the AI SDK it’s built on. |
| Rival ahead | LangGraph ships richer built-in orchestration — typed stateful graphs. |
| Rival ahead | Google ADK ships Sequential/Parallel/Loop agents and bidi audio/video. |
| Hard limit | Every major rival except eve’s TS siblings supports Python. |
| Hard limit | eve trades language reach and ecosystem breadth for filesystem-derived structure. |
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.
Reliability as a property of the substrate
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.
Reliability levers
Built in, not bolted on. Each safety property is a framework default that you'd otherwise hand-roll across separate libraries.
- Durable execution by default — turns survive restarts/redeploys, resume from the last completed step.
- Fail-closed route auth — ordered walk, 401 unless an entry explicitly accepts.
- Per-session sandbox — disposable isolation for shell/file tools; secrets stay in the app runtime.
- Built-in compaction — summarizes older turns at
thresholdPercent0.9; preserves read-before-write tracking and re-injects the todo list. - First-class evals — deterministic + LLM-judge assertions on the same HTTP surface, CI-friendly exit codes.
The honest ceiling
Reliability by construction is not the same as proven at scale. Durable execution is a category, not eve's invention — and the category leaders are formidable.
- Temporal (multi-language, years in banking/payments), Inngest (
step.run()), Restate, Cloudflare Workflows (step.do()) all sell the durable layer. - Temporal shipped an official integration with the very same Vercel AI SDK eve is built on (Jan 2026).
- eve runs on beta deps and is unproven at scale — do not assume more battle-testing than Temporal/LangGraph/CrewAI.
- eve disclaims a durable FIFO message queue and warns against concurrent sends to one session.
- The durability win is scoped to a single self-hosted deployment — not distributed coordination.
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.
What you assemble by hand: DIY stack vs eve defaults
| Concern | DIY / library stack | Authored wiring in eve |
|---|---|---|
| Durable execution layer | You wire and secure it yourself | 0 |
| Route auth (fail-closed) | You wire and secure it yourself | 0 |
| Per-session sandbox | You wire and secure it yourself | 0 |
| Context compaction | You wire and secure it yourself | 0 |
| Eval harness + reporters | You wire and secure it yourself | 0 |
Illustrative: each row 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.
eve against the field
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.
Setup and deploy: the verified flow
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.
- Prereqs — start here. Node 24+, npm. The Vercel CLI is used by
eve link/eve deploy(which wrapvercel deploy --prod); a globalvercelinstall/login is an inference, not spelled out in eve docs. - Scaffold — CLI.
npx eve@latest init my-agentscaffolds, installs deps, inits Git, and opens the dev TUI. For an existing project:eve init .addseve,ai, andzod. - Link credentials — optional.
npx eve linklinks a Vercel project and pulls AI Gateway creds into.env.local. Skip if going direct-provider — setOPENAI_API_KEYinstead. - Install a provider. If using a provider object,
npm install @ai-sdk/openai(or another AI SDK provider). - Run — the dev loop.
npm run devrunsnext devatlocalhost:3000. (Turbopack is a plausible Next 16 inference — not stated in eve docs; don't assert it.)eve devnever fires schedules; trigger viaPOST /eve/v1/dev/schedules/:id. - Build / self-host.
eve buildemits.eve/; thenPORT=3000 eve start --host 0.0.0.0. - Deploy — ship.
eve deployrunsvercel deploy --prod(linking first if needed) — or justvercel deploy.
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.
Build a weather agent in three files
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.
agent/
agent.ts # defineAgent — model
instructions.md # Markdown system prompt
tools/
get_weather.ts # filename → tool name "get_weather"agent/agent.ts
This project's direct-provider example. The documented default is the gateway string "anthropic/claude-sonnet-4.6", shown as a comment.
import { openai } from "@ai-sdk/openai";
import { defineAgent } from "eve";
export default defineAgent({
model: openai("gpt-5.1-codex"),
// or, gateway-routed (documented default):
// model: "anthropic/claude-sonnet-4.6"
});agent/instructions.md
The system prompt is just Markdown — no code, no escaping, no template object.
You are a concise, friendly weather assistant. When the user names a city, call the get_weather tool and report the temperature and conditions in one short sentence.
agent/tools/get_weather.ts
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.
import { defineTool } from "eve/tools";
import { z } from "zod";
export default defineTool({
description: "Get the current weather for a city.",
inputSchema: z.object({ city: z.string().min(1) }),
async execute({ city }, ctx) {
// execute() runs in the trusted app runtime (has process.env), not the sandbox
return { city, condition: "Sunny", temperatureF: 72 };
},
});Run it
Start a session over the built-in HTTP surface and stream the NDJSON events back.
npm install @ai-sdk/openai
npm run dev # localhost:3000
# start a session:
curl -X POST http://localhost:3000/eve/v1/session \
-H "content-type: application/json" \
-d '{"message":"What is the weather in Lisbon?"}'
# returns a continuationToken (body) + x-eve-session-id (header)
# stream: GET /eve/v1/session/:id/stream (NDJSON events:
# session.started, actions.requested, action.result,
# message.completed, session.completed)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.
When not to pick eve
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.
Wrong call today
- You need proven, at-scale reliability today. eve is v0.11.6, public preview, pre-1.0 on beta-pinned deps (
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. - Your team is Python. eve is TypeScript/JS only. LangGraph, CrewAI, OpenAI Agents SDK, and Google ADK all support Python.
- You need distributed durability or a real message queue. eve disclaims a durable FIFO queue and warns against concurrent sends to one session; its durability is scoped to a single deployment.
Right call today
- You value architecture and DX, and can tolerate preview risk. If filesystem-derived structure and durable-by-default execution are worth a young API to you — and you're already in the TS/Vercel world — eve is a compelling bet.
- You're prototyping or learning the pattern. Even if you don't ship on it, eve is an unusually clean demonstration of convention-over-orchestration worth studying.
You want platform neutrality. eve runs anywhere and is self-hostable, but the smoothest reliability/observability path — Vercel Cron, Vercel Sandbox prewarm, Agent Runs dashboard, Deployment Protection bypass — is Vercel-only.
You need a large ecosystem or a stable API. Community and integrations are far smaller than LangChain's, and the API is changing rapidly before GA.
You're counting on just-bash for isolation. The just-bash backend has no real binaries and no network isolation — use vercel()/docker()/microsandbox() for real isolation.
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."
Bet on the architecture, with eyes open
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.
v0.11.6
preview · pre-1.0 · Apache-2.0path = identity
zero name/id fields0.9
default compaction threshold · durable by default- Convention over orchestration. The directory is the contract. Move a file and you move a capability — no registry to keep in sync.
- Durability is a default. Not a decorator. Turns resume from the last completed step, surviving restarts and redeploys.
- Fail closed, hide secrets. Isolate code. Safety is built in, not bolted on — auth fails closed, creds never reach the model.
— Haroon K M, June 2026
- Read the eve docs → github.com/vercel/eve
- Try the quickstart →
npx eve@latest init
Sources
Every claim above traces back to one of these. Vendor and adversarial sources are flagged as such.
- eve — GitHub repository & README ↗
Vercel · github.com/vercel/eve · 2026 - eve — npm package (v0.11.6, Apache-2.0, bin eve) ↗
Vercel · npmjs.com/package/eve · 2026 - Introducing eve, an open-source agent framework ↗
Vercel · vercel.com · Jun 17, 2026 - eve documentation ↗
Vercel · vercel.com/docs/eve · Jun 2026 - Vercel Releases Eve ↗
Asif Razzaq · marktechpost.com · Jun 17, 2026 - Vercel eve: Next.js for Agents ↗
Yash Thakker · explainx.ai · Jun 17, 2026 · third-party framing - Vercel Open Sources eve Amid Agentic AI Boom ↗
Open Source For You · opensourceforu.com · Jun 2026 · secondary - AI SDK 5 ↗
Vercel · vercel.com · Jul 31, 2025 - Building Agents — AI SDK docs ↗
Vercel · ai-sdk.dev · 2026 - A new programming model for durable execution (Workflow SDK / DurableAgent) ↗
Vercel · vercel.com · 2025 - Workflow SDK ↗
Vercel · workflow-sdk.dev · 2026 - LangChain & LangGraph reach v1.0 ↗
LangChain · blog.langchain.com · Oct 22, 2025 - LangGraph Platform is now Generally Available ↗
LangChain · blog.langchain.com · May 14, 2025 - Durable Execution / Persistence — Docs by LangChain ↗
LangChain · docs.langchain.com · 2025 - Agent Middleware ↗
LangChain · blog.langchain.com · Oct 2025 - Checkpoints Are Not Durable Execution ↗
Diagrid · diagrid.io · 2025 · vendor/adversarial - LangSmith: Observability ↗
LangChain · langchain.com · 2025 - CrewAI — GitHub repository ↗
CrewAI Inc. · github.com/crewaiinc · 2026 - Flows — CrewAI Documentation ↗
CrewAI · docs.crewai.com · 2026 - AutoGen v0.4: Reimagining the foundation of agentic AI ↗
Microsoft Research · microsoft.com · Jan 2025 - Introducing Microsoft Agent Framework ↗
Microsoft Azure · azure.microsoft.com · Oct 2025 - Semantic Kernel + AutoGen = Microsoft Agent Framework ↗
Visual Studio Magazine · visualstudiomagazine.com · Oct 1, 2025 - AG2 (formerly AutoGen) — GitHub ↗
AG2AI · github.com/ag2ai/ag2 · 2026 - Models — OpenAI Agents SDK ↗
OpenAI · openai.github.io · 2026 - Sessions — OpenAI Agents SDK ↗
OpenAI · openai.github.io · 2026 - OpenAI Agents SDK for TypeScript ↗
OpenAI · openai.github.io · 2026 - Building durable agents with Temporal and AI SDK by Vercel ↗
Temporal · temporal.io · Jan 20, 2026 · vendor - Temporal + OpenAI Agents SDK durability (Public Preview → GA Mar 2026) ↗
Temporal · temporal.io · 2025 · GA Mar 2026 - Agent Development Kit (ADK) ↗
Google Developers Blog · developers.googleblog.com · 2025 - google/adk-python (v2.3.0) ↗
Google · github.com/google/adk-python · Jun 18, 2026 - mastra-ai/mastra (v1.45.0) ↗
Mastra · github.com/mastra-ai/mastra · Jun 19, 2026 - Mastra ↗
Mastra · mastra.ai · 2026 · vendor - Choosing an agent framework ↗
Nolan Sullivan · speakeasy.com · 2026 - Durable Execution: The Key to Harnessing AI Agents in Production ↗
Inngest · inngest.com · Feb 19, 2026 · vendor - What is Durable Execution? ↗
Restate · restate.dev · 2025 · vendor - Cloudflare Workflows is now GA ↗
Cloudflare · blog.cloudflare.com · Apr 7, 2025 - The Rise of the Agent Runtime ↗
Golem · golem.cloud · 2025 · single-analyst framing