ShipSF Workshops - eve: Build Agents That You Own

Highlights

• EVE accumulated over 200 releases, 2,000 commits, and millions of monthly turns on Vercel within four months of its initial announcement.

• Switching from a raw model loop to deterministic sub-agents and decision models cuts token consumption down to roughly one-third while increasing execution speed.

• EVE eliminates traditional 15-minute serverless execution caps by releasing compute while waiting on sub-agents or human approvals, enabling workflows to span days.

• Running the command `eve init` provisions an editable single-file agent runtime with default sandbox environments and web search tools in five seconds.

• EVE agents self-evolve at runtime by distinguishing between standard conversational tasks and requests that require modifying their own instructions or tool files.

• Early internal agents at Vercel consisted of 80% glue code for retries and infrastructure primitives, which motivated the creation of EVE as a dedicated harness framework.

Timeline

1. 00:00 - 03:44

   The Production Gap Beyond AI SDK

   While AI SDK made model interactions straightforward, production deployments require complex plumbing for triggers, streaming, and durable execution. EVE establishes directory conventions that both human developers and autonomous coding agents navigate easily. Vercel built the framework as an open-source, self-hostable runtime powered by the exact same low-level primitives exposed to external developers.

   • Raw model API calls lack the necessary infrastructure glue for reliable enterprise operations.
   • EVE uses a file-based directory structure analogous to Next.js so coding agents can modify agent code cleanly.
   • The project reached millions of production turns and over 200 releases leading up to a stable 1.0 API milestone.
2. 03:44 - 07:23

   Core Architecture and Distributed Capabilities

   Enterprise agents interact with multiple team members simultaneously, demanding fine-grained access control based on active caller credentials. EVE packages background execution, concurrency control, and cross-agent communication into a durable cloud harness. A modernized observability stack and eval framework track reasoning steps, enabling agents to modify their own files safely over time.

   • Multiplayer primitives enforce per-user authorization boundaries within shared agent sessions.
   • Durable execution allows clients to disconnect and resume long-running cloud tasks without dropping session state.
   • Built-in extensions, self-evolution mechanisms, distributed steering harnesses, and native evaluations enable iterative agent development.
3. 07:24 - 14:22

   Optimizing Workflows with Deterministic Sub-Agents and Decision Models

   Standard coding agents can figure out workflows autonomously, but open-ended loops introduce latency and variable execution paths. Introducing deterministic workflow tools lets systems spin up concurrent sub-agents for known processing sequences. Layering lightweight classification models handles obvious items instantaneously, reserving heavy sub-agent reasoning only for low-confidence edge cases.

   • A baseline out-of-the-box coding agent triaged 24 GitHub issues sequentially in roughly 40 seconds.
   • Adding deterministic workflow tools to launch parallel sub-agents increases categorization speed and execution consistency.
   • Routing tasks through fast decision models with fallback confidence intervals cuts token usage to approximately one-third.
4. 14:23 - 19:31

   Durable Cloud Harness Internals and Execution Primitives

   Distributed agent runs decouple computation from specific browser connections and server instances. When a task stalls for user input or requires multi-hour background steps, EVE frees the compute runner until the blocking condition clears. First-party features like steerable sub-agents and approval gates operate directly on this execution harness layer.

   • Browser reloads maintain complete event stream states due to centralized cloud durability.
   • Parent agents release compute resources while waiting on human reviews, bypassing 15-minute serverless execution timeouts.
   • The framework exposes primitive APIs such as `ctx.ask` to stop execution and request human approval for restricted actions.
5. 19:32 - 24:23

   Agent Bootstrapping and Self-Evolution Workflow

   Scaffolding a project instantly yields a single-file agent runtime with preconfigured tools. When commanded to adapt, the agent invokes its internal coding harness to rewrite its own prompt instructions and implement new TypeScript API query tools. Subsequent queries immediately run the freshly generated tools within the updated sandbox.

   • The `eve init` CLI command provisions a functional agent project within five seconds.
   • Out-of-the-box templates provide sandboxed execution environments, web search, and web fetch capabilities.
   • Agents identify when user instructions ask for self-modification and write new tools directly into their project directories.
6. 24:24 - 34:26

   Production Deployment, Tooling, and Architecture Q&A

   While frontier models generate source code, the surrounding harness controls how agents compile, test, and save changes. Local developer tools operate only on personal machines, whereas EVE addresses enterprise scaling, shared state, and long-running retries. Production implementations at Vercel enforce dynamic security credentials so agents automatically scope database visibility to each specific user.

   • Harnesses turn raw LLM code generation into working code by providing sandboxes, test execution, and file management.
   • EVE scales local agent behavior to organization-wide distributed cloud deployments.
   • Internal Vercel deployments include SRE triage bots in incident channels and credential-isolated business intelligence agents.