toolagentsframeworkverceltypescriptfilesystem-firstdurable-executionsandboxharnessmcpopen-sourceUpdated 2026-07-06

Vercel Eve

Open-source (Apache-2.0) agent framework from Vercel, launched 2026-06-17 at Vercel Ship: an agent is a directory of files, and production — durable execution, a sandbox, human-in-the-loop approvals, subagents, evals — comes built in. Pitched as "Next.js for agents." Source: Vercel, "Introducing eve", vercel.com/blog/introducing-eve, 2026-06-17

View original tweet
View original tweet

Current Source Snapshot

As of the 2026-07-04 source review, vercel/eve is an Apache-2.0 repo with npm package eve@0.19.0, Git tag eve@0.19.0 at 923170b08215d452004eb579b2b9d56e589c47d3, and default-branch HEAD at e2d7c577ced338d463fc045887464378e5099e91. The latest package requires Node >=24 and peers against ai@^7.0.0, @opentelemetry/api, braintrust, just-bash, and microsandbox. GitHub showed 3,159 stars and 252 forks at this check; the repo was pushed on 2026-07-04. Source: npm registry packument; git ls-remote; GitHub API vercel/eve, 2026-07-04

The core idea: an agent is a directory

eve is a filesystem-first TypeScript framework. You define an agent as files under an agent/ directory; eve discovers them at build time and compiles them into an app that runs on Vercel Functions — no registration, no plumbing. The same way Next.js turns a folder into routes, eve turns a file into an agent capability by owning the agent loop. Source: Vercel blog, 2026-06-17; The New Stack, 2026-06-17

agent/
  agent.ts                 # the model it runs on (AI Gateway fallbacks, compaction)
  instructions.md          # who it is — the system prompt (Markdown)
  tools/run_sql.ts         # what it can do (filename = tool name)
  skills/revenue-defs.md   # what it knows (lazy-loaded markdown + frontmatter)
  subagents/investigator/  # who it delegates to (same shape, clean context)
  channels/slack.ts        # where it lives
  schedules/monday.ts      # when it acts on its own (cron)
  connections/linear.ts    # what it connects to (MCP / OpenAPI via Vercel Connect)

At a glance the tree tells you what the agent is, what it does, where it lives, and when it acts on its own. Kevin bookmarked the launch, then bookmarked Omar Sar's broader restatement of the same pattern: tools, skills, subagents, connections, schedules, and evals should all be visible on disk. Source: X/@vercel, 2026-06-17; Source: X/@omarsar0, 2026-06-27

View original tweet

Chris Tate's framework checklist names the same agent surface area in product-language form: data, evals, tools, skills, schedules, subagents, durable workflows, sandboxed execution, connections, and channels. Use it as a review checklist for "agent framework" claims: if a framework lacks durable execution, sandboxing, evals, or channel/connection boundaries, it is probably an agent demo framework rather than a production agent framework. Source: X/@ctatedev, 2026-06-17

View original tweet

Eve-style agent directory

Structure Evaluation

Kevin's useful takeaway is not "markdown files are magic." The critique bookmark points at a thin instructions.md fixture and correctly stress-tests the launch framing: a file tree is only valuable when the harness gives those files runtime semantics. A real Eve-style agent directory needs executable ownership boundaries:

  • tools are callable code with schemas, approvals, and failure behavior
  • skills are lazy procedural memory, not generic prose
  • subagents isolate context and tool exposure
  • schedules and channels have deployment/runtime meaning
  • evals run in CI and block regressions
  • traces expose model calls, tool calls, and approvals

For Kevin's stack, adopt Eve as a source-owned operating shape only when the tree is paired with evals, versioning, and a runtime that proves the files still work. Otherwise it becomes attractive slop with folders. Source: X/@IceSolst, 2026-06-18; Source: GitHub vercel/eve, 2026-06-30

View original tweet

Registry as agent distribution

shadcn's follow-up thread extends the Eve file graph into a distribution model: if an agent is instructions, tools, skills, subagents, channels, schedules, and config, then a shadcn-style registry can install those source files directly into meaningful locations. This differs from npm's library model: the install target is owned source that a team reviews, edits, composes, and overrides. Source: X/@shadcn, 2026-06-18

View original tweet

This is the bridge between Vercel Eve and agentcn: Eve supplies the file-native agent shape, while the registry pattern supplies install, dependency composition, dry-run, diff, override, and private catalog mechanics. For Kevin's brain, this supports a source-owned skill/tool/capsule corpus instead of a remote-agent storefront.

Authoring model

  • agent.ts — defineAgent({ model: "anthropic/claude-opus-4.8" }); one line sets the model, with provider fallbacks through AI Gateway. Any model works, including GLM-5.2 (model: "zai/glm-5.2"). Source: Vercel blog, 2026-06-17
  • Tools — one defineTool file with a Zod inputSchema + inline execute. Add needsApproval: ({toolInput}) => … to gate destructive/expensive calls. Source: Vercel blog, 2026-06-17
  • Skills — one markdown file with a frontmatter description, loaded only when relevant (the same lazy-skill pattern as Cursor/Claude SKILL.md). Source: Vercel blog, 2026-06-17
  • Subagents — a directory inside subagents/ with its own instructions, tools, and sandbox; the parent calls it like a tool, the child runs in a clean context window and hands the result back. Source: Vercel blog, 2026-06-17
  • The agent can write its own code — every agent gets a real shell in its sandbox, so when no tool fits it writes and runs code (e.g. a one-off Python analysis). Source: Vercel blog, 2026-06-17

Production, built in ("batteries included")

Capability How it works
Durable sessions Every conversation is a durable workflow on the open-source Workflow SDK; each step is checkpointed, so a session can pause, survive a crash or deploy, and resume exactly where it stopped.
Sandbox Agent-generated code runs isolated from the app runtime. Adapter-based: Vercel Sandbox in prod; Docker / microsandbox / just-bash locally; write your own adapter.
HITL approvals Any action can require approval; the agent pauses indefinitely without consuming compute and continues from where it left off once approved.
Connections A file pointing at an MCP server or any OpenAPI-compatible API; Vercel Connect brokers OAuth + token refresh and the model never sees URLs/credentials. Slack, GitHub, Snowflake, Salesforce, Notion, Linear at launch.
Channels Same agent on every surface, one adapter file each. HTTP API on by default; Slack, Discord, Teams, Telegram, Twilio, GitHub, Linear included; defineChannel for custom. Sessions move between channels.
Tracing + evals Every run emits OpenTelemetry spans (ai.eve.turn → model call → tool call with I/O); export to Braintrust/Honeycomb/Datadog/Jaeger, or the Agent Runs tab on Vercel. defineEval gives scored suites, locally or in CI.

Source: Vercel blog, 2026-06-17; vercel.com/docs/eve

Agent Runs Observability

Vercel's 2026-06-26 observability changelog makes Eve's trace layer a first-party product surface. Every Eve project gets an Agent Runs tab in the Vercel dashboard without custom OpenTelemetry setup. The run list surfaces trigger, duration, and token usage; drill-down exposes turns, model calls, tool calls, and runtime errors correlated to the failing step. Source: Vercel changelog, 2026-06-26

The product split is useful for Agent Legibility: developer mode preserves raw tool names, input/output JSON, and per-step token counts, while business mode humanizes tool names, hides JSON, and produces a plain-English run summary. Run data is encrypted by default. Default retention is Hobby 12 hours, Pro 1 day, and Enterprise 3 days; Pro and Enterprise can extend to 30 days with Observability Plus. Teams can still export AI SDK spans from agent/instrumentation.ts to external OpenTelemetry backends such as Braintrust or Datadog. Source: Vercel changelog, 2026-06-26

View original tweet

As of the July Agent Runs CLI/MCP update, those traces are also agent-operable: vc agent-runs and Vercel MCP can expose Eve traces back to coding agents. That closes an important legibility loop: an agent can inspect prior runs before changing an Eve project, rather than relying on a human to paste dashboard screenshots into chat. Source: X/@vercel_dev, 2026-07-04; Source: Vercel changelog, 2026-07-04

View original tweet

Dev → ship loop

npx eve@latest init my-agent     # wizard: pick a model → running dev server in <1 min
eve dev                          # TUI; same structured events served over HTTP for curl/CI
eve eval                         # scored test suites (wire into CI as a deploy gate)
eve channels add slack           # writes channels/slack.ts; approvals render as Slack buttons
vercel deploy                    # ships unchanged; sandbox swaps to Vercel Sandbox, no code change

An eve agent is an ordinary Vercel project: it lives in Git (a prompt/tool/skill change is a commit with a diff + review + history), every commit gets a preview deployment carrying its channels, and you can roll production back instantly. A session mid-task when you deploy finishes on the version it started on. At launch eve deploys only to Vercel, with other platforms "on the way." Apache-2.0; current release eve@0.19.0; dev in the open at github.com/vercel/eve, docs at eve.dev/docs. Source: Vercel changelog, 2026-06-17; npm registry and vercel/eve GitHub, 2026-07-03

Frontend helper surface

Guillermo Rauch's "Next.js for agents" bookmark adds the clearest product framing: Eve asks for agent/instructions.md the way early Next asked for pages/index.js. His follow-up reply turns that into an app boundary: deploying Eve gives a backend API, and the frontend helpers expose useEveAgent() for Next, Vite, and TanStack apps. The docs describe useEveAgent() as opening a durable session, sending turns, streaming the reply, and adapting raw events into a browser chat or agent UI. Source: X/@rauchg, 2026-06-17; Source: Eve frontend overview, checked 2026-07-03

View original tweet

Nuxi Migration Signal

Hugo's Nuxi migration bookmark is adoption evidence: a Nuxt Agent maintainer is testing Eve against a real adjacent framework agent rather than only Vercel-owned demos. The linked Vercel Eve page reiterates the same file-native stack - markdown instructions/skills, TypeScript tools, sandbox customization, channels, connections, subagents, and schedules - so the bookmark does not change the feature model. It does change confidence that Eve's shape is legible to non-Vercel agent authors. Source: X/@hugorcd, 2026-06-25; Source: Vercel Eve page, checked 2026-07-04

Kevin-Stack Local Contract

The local wiki implementation uses Eve's file-native lesson without requiring a Vercel Eve runtime app. agents/codex-self-improver/ is the reference contract:

agents/codex-self-improver/
  agent/agent.ts
  agent/tools/run-self-eval.ts
  agent/skills/self-improve.md
  agent/subagents/evaluator.md
  agent/connections/local.ts
  schedules/weekly-self-improvement.md
  evals/codex-self-improvement.eval.json
  package.json

That tree makes Kevin's brain visible to agents: tools show what can be done, skills show when to do it, subagents show delegation, connections show local boundaries, schedules show cadence, and evals prove the agent still works. The actual scorer lives in Agent Self-Improvement Eval Library and the repeatable loop route lives in Loopy.

How Vercel uses it (proof)

Vercel runs 100+ agents on eve in one monorepo, same shape and tooling: d0 (data analyst, 30k+ Slack questions/mo, scoped to each asker's permissions), Lead Agent (autonomous SDR, ~$5k/yr → 32× return, one part-time eng), Athena (RevOps sales cockpit built in 6 weeks with no engineers, ~2× pipeline coverage), Vertex (support, solves 92% of tickets), draft0 (content review pipeline), and V (a routing agent that dispatches to the right agent so the fleet behaves like one). Agents triggered <3% of Vercel deployments a year ago; now ~29%, and they expect ~half soon. Source: Vercel blog, 2026-06-17

Linear Proof Surface

Linear's 2026-06-18 changelog names Vercel Eve as the open-source framework for building custom agents that can investigate incidents, monitor SLAs, analyze customer feedback, and operate inside Linear through issue delegation or mentions. That matters because it proves Eve's connections/ and channels/ model is meant to land in real work-management surfaces, not only demo chat apps. Source: Linear changelog, 2026-06-18

For Kevin's stack, the translation is: Eve-style agents should have a visible work-ledger integration boundary. If an agent writes a project update, triages an incident, or changes an issue, the Linear/GitHub/Slack artifact is part of the run proof. Source: Agent Operations Skills; Agent Product Surface

Personal Agent Template Proof

Personal Agent Template is the concrete "V" example for Eve as a user-facing personal agent: web chat, Slack, iMessage, Linear tools, long-term memory, and daily summaries in one repo. It proves Eve's file structure needs adjacent product concerns: account linking, connector scopes, memory approval, scheduled summaries, and a console-like web UI. The connector boundary is Vercel Connect, not raw provider tokens in prompts or app code. Source: GitHub vercel-labs/personal-agent-template, 2026-07-01

Why it matters to Kevin

  • Same thesis as Agent-Docs Mesh. Kevin already runs agents as files — AGENTS.md + per-dir SKILL.md, skills/personal/<slug>/SKILL.md, automations/. eve is that intuition turned into a shipped framework: instructions.md = system prompt, skills/*.md = lazy skills, schedules/ = automations, subagents/ = nested harness. Strong validation + a reference implementation to mine.
  • Direct overlap with Dedalus. Durable sessions, per-agent sandbox, and pause-without-compute HITL are exactly the Dedalus Labs microVM / Durable Agent Execution Architecture value props — eve is both a competitor framing and a benchmark for "agents need computers." HITL approvals also rhyme with Kevin's own Agent-Ping.
  • Plays with the rest of the stack: any model via Vercel AI SDK / AI Gateway (so GLM-5.2 drops in), any MCP server, evals as a CI gate — fits the harness-engineering and eval-loop patterns Kevin writes about.
  • Content angle. A high-signal "Next.js for agents" launch for an agent-infra builder; pairs with the agents-need-computers / harness theses in Content Backlog.

Timeline

Related Pages

Agent-Docs MeshVercel AI SDKGLM-5.2Dedalus LabsLoopAgent-PingDurable Agent Execution ArchitectureCross-Agent Harness PortabilityAgent Self-Improvement Eval LibraryLoopyShadcn Registry Directory (Top Blocks)agentcnAgent Operations SkillsPersonal Agent TemplateVercel ConnectAgent LegibilityAgent Trajectory Evaluation

26 pages link here

Agent Harness, Runtime, Memory, and EvalsConceptsAgent LegibilityConceptsAgent Self-Improvement Eval LibraryConceptsAgent-Docs MeshConceptsAgent-PingProjectsagentcnToolsAgentic InfrastructureConceptsBrain CapsulesMetaCapability Routing MapMetaContent BacklogCareerDedalus LabsProjectsDurable Agent Execution ArchitectureArchitectureGLM-5.2ToolsLinear EcosystemToolsLoopProjectsPersonal Agent TemplateToolsShipper.nowToolsSkill ResolverSkill ResolverVercel ConnectToolsVercel EcosystemToolsVercel EveToolsX Bookmark Ingest 2026-06-26ResearchX Bookmark Ingest 2026-06-28ResearchX Bookmark Ingest 2026-07-06ResearchX Bookmarks: AI Agents & Tools (Jan 2025 – Jun 2026)ToolsX Bookmarks: React & Next.js (Mar–Jun 2026)Tools