Back to Devoured - November 18, 2026
DEVOURED
Vercel's eve 1.0

Vercel's eve 1.0

AI Vercel
Vercel has released eve 1.0, an open-source framework designed to bring production-grade reliability, monitoring, and crash recovery to AI agents.
What: Eve 1.0 provides a structured harness for managing agent loops, tools, and memory. It supports multi-user sessions, integration with major messaging platforms, and detailed observability via OpenTelemetry.
Why it matters: As agent development moves from hobbyist experiments to enterprise workflows, frameworks that handle state durability, security, and human-in-the-loop approvals are becoming a critical industry layer.
Takeaway: Install eve locally using 'npx eve@latest init my-agent' to start building with the new 1.0 framework.
Deep dive
  • Latency for agent turns has been reduced from ~3s to 414ms in stress tests.
  • New support for multi-tenant deployments allows for user-specific memory and credentials.
  • Built-in integrations include Slack, Teams, GitHub, and Discord.
  • Tracing capabilities are rebuilt using OpenTelemetry, enabling visibility into agent approvals and tool calls.
  • The framework supports 'self-modification', allowing agents to edit their own source code for updates.
Decoder
  • Durable execution: A programming paradigm where long-running processes (like AI agents) can save state and recover from crashes exactly where they left off.
  • MCP (Model Context Protocol): An open standard that allows AI assistants to securely connect to different data sources and tools without custom integrations for every service.
Original article

Today we're announcing eve 1.0, the open-source framework for building production-ready agents.

Since the public preview in June, we've worked with early adopters to prepare eve for 1.0, shipping 230+ releases and merging thousands of pull requests. With this release, eve is now generally available.

We've made eve faster, expanded integrations, and improved observability. Security controls let you decide which actions need approval and what data gets collected. We've also made it easier for coding agents to build with, measuring that experience with a rigorous evaluation suite.

With eve handling your harness and infrastructure, you and your agent can focus on building instead.

Build production agents on a harness you own

The harness in eve is the loop that calls models, runs tools, and delegates work to subagents. You choose the model, add or replace tools, edit instructions, and decide which actions need approval. The open-source Workflow SDK saves progress as the agent runs, so it can pick up from its last completed step after a crash. Multiplayer sessions and agent-to-agent calls are built in.

For managed hosting, deploy your eve agent to Vercel. Vercel Workflows handles durable execution, and Vercel Sandbox runs agent-generated code in isolation.

Build software factories that turn requests into tested pull requests, company brains that answer questions from your business data, or customer-facing agents in your product.

Thousands of businesses already run eve in production for internal and customer-facing agents. Rillet built a software factory on eve that takes in customer requests, converts them into specs, tests the changes, and opens PRs for human review. Rillet tripled its shipping rate in three months. Clay built monty, a data agent that answers employees’ questions in Slack. Just over two months in, 30–40% of the company used it every week.

Lindy's agent framework roundup names eve “Best for durable backend agents”.

“Custom agents built with eve plus Vercel workflows. I’m biased but I didn’t mandate this, we felt it was the best solution for us.” Mitchell Hashimoto

Collaborate in multiplayer agent sessions

Multiplayer lets several people work with an agent in one shared session. eve keeps track of who said what and directs approvals and sign-ins to the right person. You can set up memory for each user or the whole team.

In the native Slack channel, each thread is one shared session. Approvals appear as buttons that only the right person can answer, and a live task card shows progress and timing. You can follow up in the thread without mentioning the agent again, cancel the current turn, or reset the session from Slack.

Ambient mode lets an agent listen in channels you choose, even without being mentioned. Guided by goals you set per channel, it decides when to speak up, help, or take on a task, and when to stay quiet. To limit model costs, a small decision model screens every message first, and only the ones that might be for the agent start a turn.

Slack is one of several native channels, alongside Microsoft Teams, Discord, Telegram, GitHub, Linear, Twilio, Web Chat, and iMessage. The Chat SDK channel adds support for any Chat SDK platform adapter, including WhatsApp, Messenger, Google Chat, and email. Each channel is one file, and the same agent can work across all of them. See the integrations directory for the full list.

Build agent UIs with Next.js and other frameworks

eve 1.0 expands our native integrations for Next.js, Nuxt, SvelteKit, TanStack Start, and Vite. The framework integrations build your agent alongside your app and set up its routes. On Vercel, you can deploy the agent and your site as one project, or host them separately.

The client libraries let you work with tool calls, approval requests, and questions in a consistent way across frameworks. Use that session data to build custom UIs: stream replies into agent chats, embed an agent in a page, or show the agent's tool calls in your own components.

Use eve add channel/web to scaffold a chat app with AI Elements components, or add eve's React, Vue, or Svelte bindings to an existing UI.

Build multi-tenant agents

One support-agent deployment can connect to each customer's ticketing system with their own credentials and apply that customer's approval rules.

Your application authenticates the user and identifies which tenant they belong to. You can then set memory, connection credentials, and approval policy for that tenant and user.

Before each model call in the main agent loop, dynamic definitions load the agent's capabilities from the session and external data. In 1.0, they cover models, connections, and subagents as well as tools, skills, and instructions.

Give agents memory across sessions

We added native memory so agents can carry context from one session to the next. You choose the memory's scope and can use the built-in file memory, a memory provider, or one you build yourself.

Built-in fileMemory keeps data in memory in eve dev and in a private Vercel Blob store you configure on Vercel.

Other providers include claude-mem, Hindsight, Kybernesis Arcana, Memanto, memco, Supermemory, and Upstash AgentKit.

Trace agents with OpenTelemetry

We rebuilt eve’s tracing around OpenTelemetry, so you can follow an agent’s work in the tracing tools you already use. eve dev records traces locally by default. If you host eve yourself, you can export them to an OpenTelemetry backend, including one you run yourself.

Tracing integrations include Raindrop, with more options in the integrations directory. Add one with eve add instrumentation/<name>, or use the instrumentation APIs to build your own integration.

Traces now show when an agent is waiting for a person, including tool approvals, questions, budget prompts, and sign-ins. They record model selections and approval decisions alongside model usage and cost, and follow calls into MCP servers and remote agents.

You choose what eve collects for tracing. Content you exclude from collection stays out of every destination. You can filter out spans or redact inputs and outputs per destination. Private conversations in production send only metadata by default, without prompts or tool results. The OpenTelemetry guide explains these controls.

On Vercel, Agent Runs uses the same traces to show sessions, model calls, tool execution, subagent activity, and approval decisions in the dashboard. When eve deploy creates a new Vercel project, it sets up trace sampling automatically. See the Agent Runs guide for setup and configuration.

Lower agent turn latency

At the start of September, our hosted stress test on Vercel Workflows took a median of 3.036s per turn. In 1.0, the same 100-turn workload took 414ms. The test sends messages one at a time, with one immediate mock-model response and no tool calls per turn. We measure from sending a message until the turn finishes, capturing eve and Workflow overhead without the time a model takes to generate a response.

Hosted stress run Median turn latency p95
September 1, beta baseline 3.036s 3.692s
November 15, 1.0.0 414ms 633ms

We worked with the Workflow team on spec 9, which gives each run a single orchestrator so background steps no longer replay the workflow. The team also moved event and stream writes to WebSockets and cut redundant history reads. eve agents get these improvements through Workflow SDK.

eve also caches the information it needs to route messages to each session and can move idle sessions to a newer deployment between turns. Web UIs can prewarm a session before the first message arrives, so the first reply starts sooner.

Lower workflow costs for long agent sessions

For a 50-turn Evo Docs session, the estimated Vercel Workflows cost drops from 5.4¢ to 1.3¢, about 76% lower. That assumes roughly two model steps per turn and 30-day retention. eve now uses Workflow SDK 5.5 and saves only the conversation data that changed between turns. We've also cut repeated work in workflow steps, checkpoints, and sandbox setup:

  • Workflow steps save changes and refer back to data already stored, instead of repeatedly copying a growing conversation into each step. Steps that don't need history no longer receive it.
  • Checkpoints store references to image files returned by tools, so they don't have to copy the image bytes each time.
  • Sandboxes from prepared snapshots skip repeated setup. Stop a sandbox and keep its files for reuse. Cleanup starts when the session ends.

The storage changes are part of the open-source Workflow SDK, so agents you host yourself on other Workflow backends also store less duplicate session data. The cost estimate above uses Vercel Workflows pricing.

On Vercel, workflow steps run on Fluid compute. They need extra storage writes for inputs above the payload size limit, so sending less session data helps keep turn times consistent as sessions grow. Images and files can still require those writes.

For model calls, tool and skill listings can stay out of the initial prompt until they're needed. Connection tools run through eve__search and eve__tool, so each search no longer has to expand the model's tool list. We also changed how eve marks parts of a prompt for provider caching, so more content can be reused between calls.

During an earlier migration to eve, an engineer at Evisions reported:

“Transitioning to Eve delivered immediate, high impact results. To name a few, we were able to cut out 25k lines of code, cut our AI costs in half, and improved runtime by 66%.” Chris Fleissner

Share agent capabilities with extensions

Since the preview, we've added extensions so teams can share tools, skills, instructions, connections, channels, schedules, hooks, and subagents without copying files between agents. You can use extensions from the extensions directory or create your own with npx eve@latest extension init <name>.

For example, agent-browser adds browser automation, Mux Video adds tools for video assets and clips, and Link adds wallet and purchase tools.

eve builds workspace extensions from source and reloads changes during development. You can update shared capabilities in one package and try the changes in your agents as you work.

Build coding agents with eve’s shared tools

The 1.0 code extension builds on eve’s default file tools, adding coding instructions and skills that follow your repository’s AGENTS.md. It's included in the eve package, so there's nothing extra to install. Give it a repository in its sandbox and your agent can investigate code, edit files, and run the project's checks. It uses the same harness and extension system as your other agents, so you can replace or disable tools, override skills, and add your own instructions.

See the benchmark results for comparisons with other coding harnesses using the same tasks and model.

eve add extension/code

The companion eve/extensions/git adds GitHub and pull request workflows, using credentials and authorization you configure. On Vercel, the optional remote self-modification extension lets your agent propose changes to its own source in a draft pull request. You review the changes, merge them, and deploy.

Build with the same public APIs eve uses

We built eve's subagents, sleep, and question tools on the same workflow system you can use through defineWorkflowTool. Your tools can return a result, start a background task, or keep accepting messages as a resumable task. They can wait for a person, webhook, or timer without keeping compute running, and their runs survive restarts. You don't need a separate background-job system to coordinate that work.

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

export default defineWorkflowTool({
  description: "Ask the reviewer to check these notes.",
  inputSchema: z.object({ notes: z.string() }),
  async task({ notes }, ctx) {
    "use workflow";
    const response = await ctx.agent("reviewer").send(notes, {
      signal: ctx.abortSignal,
    });
    return await response.result();
  },
});
“Been stress-testing crash recovery in @eve, and it's really solid: approvals and finished steps come back cleanly after a restart.” George Shostakovych

Upgrade to eve 1.0

If you already have an eve agent, the 1.0 upgrade guide walks through the changes to extension builds, agent APIs, session events, clients, and saved history. Follow it before deploying your upgrade.

To work through the upgrade with your coding agent, copy this prompt:

Read https://eve.dev/docs/guides/upgrade and inspect this project's eve version and configuration. Upgrade it to eve 1.0, following the guide's order and the sections that apply. Update extensions, agent code, event consumers, clients, and saved history where needed. Run the project's typecheck, eve build, and relevant tests. Summarize the changes and any remaining manual migration or deployment steps.

Create your first eve agent

npx eve@latest init my-agent

Learn more in the eve docs.

Explore all 55 articles in today's digest

Fresh dev news, AI-digested daily. Never miss a trend at devoured.fyi