[KongchangAI]
· 3 min read· 1,978 words

eve 1.0 Officially Released: Five Major Upgrades to the Open-Source Agent Framework

eve 1.0 Officially Released: Five Major Upgrades to the Open-Source Agent Framework

Open-source agent framework eve releases 1.0 with major performance gains plus multiplayer, omnichannel access, and observability.

eve 1.0 is officially GA after over 230 iterations since its June preview. Its core selling points are an open-source harness and open-source Workflow SDK for durable execution, deployable self-hosted or on Vercel. The new version adds multiplayer sessions, Ambient channel listening, native Slack/Teams/Discord omnichannel access, multi-tenancy, and cross-session memory. Tracing is rebuilt around OpenTelemetry and shows waits for human approval. Performance-wise, median turn latency dropped from 3.036s in beta to 414ms, and workflow cost for a 50-turn session fell about 76%. A built-in code extension supports coding agents, and the extensions mechanism lets tools, skills, and sub-agents be shared across teams.

eve 1.0 release

The open-source agent framework eve today released its 1.0 official version. Since its public preview in June, the team has worked with early users through more than 230 version iterations and merged thousands of PRs, and eve has now officially entered the GA stage. This update centers on performance, integration, observability, and security, with the core message being: eve takes over the agent's harness and infrastructure, so developers only need to focus on building.

You Own the Harness, eve Handles the Infrastructure

At its core, eve is an open-source harness—the loop that calls models, runs tools, and delegates to sub-agents. You can choose models, add or remove tools, edit instructions, and decide which operations require human approval. The accompanying Workflow SDK saves progress while the agent runs, so it can resume from the last completed step after a crash. Multiplayer sessions and inter-agent calls are built-in capabilities.

If you don't want to self-host, you can deploy directly to Vercel: Workflows handles durable execution, and Sandbox runs agent-generated code in an isolated environment. The three typical scenarios cited by the official team are software factories (turning requests into tested PRs), enterprise brains (answering questions with business data), and customer-facing agents.

"Build custom agents with eve plus Vercel workflows. I admit I'm biased, but I'm not forcing anyone—we think this is the best approach for us." — Mitchell Hashimoto

According to official disclosures, Rillet's software factory built with eve turns customer requests into specs, tests changes, and automatically opens PRs, tripling its release rate within three months; Clay's data agent "monty" saw 30–40% of employees using it weekly more than two months after launch; and Lindy's agent framework evaluation ranked eve as "best suited for durable backend agents."

Harness in the AI Agent context refers to the core loop that drives an agent: calling the LLM, parsing the response, executing tools, and deciding the next step based on results, repeating until the task is complete. It is essentially the agent's "operating system kernel," determining how decision logic interacts with the outside world. Traditionally, the harness is either locked in by a framework and hard to customize, or a team must build it themselves and handle complexities like interruption recovery and state persistence. eve open-sourcing the harness means developers can freely swap models, adjust tool sets, and modify prompts, while infrastructure-level persistence, recovery, and isolation are handled by the platform—allowing them to focus on business logic.

Workflow SDK is eve's open-source component for durable execution. During agent execution, the state of each step (such as model calls, tool results, and user input) is checkpointed. If the process crashes or needs to pause for human input, the agent can resume from the last completed step instead of rerunning from scratch. This mechanism is similar to "workflow orchestration" in distributed systems, but designed specifically for multi-turn interactions and long-running agent tasks. The Workflow SDK also handles lower-level operations like event streaming, history reads, and sandbox initialization; its optimizations (such as saving only changed data and using references instead of byte copies) directly reduce storage and runtime overhead, and these improvements also benefit agents self-hosted on other Workflow backends.

Multiplayer Collaboration and Omnichannel Access

Multiplayer lets multiple people collaborate with the same agent in a shared session. eve records who said what, routes approvals and login requests to the right person, and sets up memory separately for each user or for the entire team.

In native Slack channels, each thread is a shared session: approvals appear as buttons that only the right person can click; live task cards show progress and elapsed time; you can follow up in the thread without @-mentioning the agent again, and you can cancel the current turn or reset the session from Slack.

Ambient mode goes further—the agent can listen to channels you specify even when it isn't mentioned. It decides when to speak, when to help, and when to stay silent based on goals set for each channel. To control model costs, each message is first screened by a small decision model, and only potentially relevant messages trigger a conversation turn.

Beyond Slack, native channels include Microsoft Teams, Discord, Telegram, GitHub, Linear, Twilio, Web Chat, and iMessage, while Chat SDK channels support adapters for WhatsApp, Messenger, Google Chat, email, and more. Each channel is just a file, and the same agent can work across all channels.

Frontend Integration, Multi-Tenancy, and Memory

eve 1.0 expands native integrations for Next.js, Nuxt, SvelteKit, TanStack Start, and Vite; framework integrations set up the agent and its routes alongside the app build. On Vercel, the agent and the site can be deployed as the same project or hosted separately. Client libraries make tool calls, approval requests, and questions handled consistently across frameworks, and you can use session data for custom UIs—streaming replies into a chat interface, embedding the agent into a page, or displaying tool calls in your own components.

For multi-tenancy, a single customer-service agent deployment can connect to each customer's own ticketing system, using their credentials and applying their approval rules. The app authenticates users and determines their tenant, then sets memory, connection credentials, and approval policies for that tenant and user. Before each main-loop model call, dynamic definitions load agent capabilities from the session and external data; in 1.0, dynamic definitions cover models, connections, and sub-agents—not just tools, skills, and instructions.

For memory, eve adds native memory so agents can carry context across sessions. You can choose the memory scope and use built-in file memory, third-party memory providers, or build your own. Built-in fileMemory stores data in memory during eve dev and in your configured private Blob storage on Vercel. Third-party providers include claude-mem, Hindsight, Kybernesis Arcana, Memanto, memco, Supermemory, and Upstash AgentKit.

OpenTelemetry Tracing, Lower Latency and Cost

eve's tracing system has been rebuilt around OpenTelemetry, so it can plug into the tracing tools you already use. eve dev records traces locally by default, and self-hosted deployments can export to any OpenTelemetry backend. Tracing integrations currently include Raindrop, with more options in the integrations directory—add them with eve add instrumentation/<name> or build your own via the instrumentation API.

New traces show when an agent is waiting on a person—including tool approvals, questions, budget prompts, and logins—and record model selection and approval decisions, as well as model usage and cost, following calls into MCP servers and remote agents. You decide what is collected: excluded content never reaches any destination, and you can filter spans or redact inputs and outputs per destination; in production, private conversations send only metadata by default, without prompts or tool results.

The performance numbers are impressive. In a hosted stress test on Vercel Workflows in early September, median per-turn latency was 3.036 seconds; in 1.0, the same 100-turn load takes just 414 milliseconds. The test sent messages one by one with the model immediately returning a simulated response, no tool calls per turn, measuring time from sending a message to the end of the turn—i.e., eve and Workflow overhead, excluding model generation time. In spec 9, the workflow team introduced a single orchestrator per run, so background steps no longer replay the entire workflow, moved event and stream writes to WebSocket, and reduced redundant history reads.

On cost, for a 50-turn Evo Docs session, the estimated Vercel Workflows cost dropped from 5.4 cents to 1.3 cents, a reduction of about 76% (assuming about two model steps per turn and a 30-day retention period). eve now uses Workflow SDK 5.5, saving only session data that changes between turns; steps that don't need history no longer receive it; checkpoints store references to images returned by tools instead of byte copies; and sandboxes started from a prepared snapshot skip redundant initialization. These storage optimizations are part of the open-source Workflow SDK, so agents self-hosted on other Workflow backends benefit as well.

On the model-call side, tool and skill lists can wait until needed before entering the initial prompt; connection tools run via eve__search and eve__tool, so search no longer requires expanding the model's tool list; and the parts of the prompt used for provider caching have been adjusted so more content can be reused across calls.

An Evisions engineer wrote in a migration report: "Switching to eve delivered immediate, high-impact results. To name a few: we cut 25,000 lines of code, halved AI costs, and improved runtime performance by 66%."

OpenTelemetry (OTel) is an open-source observability standard and toolkit for generating, collecting, and exporting traces, metrics, and logs from distributed systems. It defines unified APIs and protocols so applications can send telemetry data to various backends (such as Jaeger, Datadog, Grafana Tempo, etc.) without vendor lock-in. Rebuilding eve's tracing system around OTel means every span of agent runtime—each model call, tool execution, and human wait—can be exported in a standard format, letting developers reuse existing monitoring pipelines and visualization tools instead of building a separate tracing system for eve.

Extension Mechanism and Coding Agent

Extensions, new since the preview, let teams share tools, skills, instructions, connections, channels, schedules, hooks, and sub-agents without copying files between agents. You can use ready-made 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 video assets and editing tools, and Link adds wallet and purchasing tools. eve builds workspace extensions from source and hot-reloads them during development.

The 1.0 code extension builds on eve's default file tools, adding coding instructions and skills that follow a repository's AGENTS.md, included directly in the eve package with no extra installation. Give the sandbox a repository and the agent can investigate code, edit files, and run project checks. It uses the same harness and extension system as other agents, so you can swap or disable tools, override skills, and add your own instructions. The companion eve/extensions/git adds GitHub and PR workflows; on Vercel, an optional remote self-modification extension lets an agent propose changes to its own source in a draft PR for you to review, merge, and deploy.

eve's sub-agent, sleep, and question tools are also built on the same workflow system and exposed to developers via defineWorkflowTool. Tools can return results, start background tasks, or act as resumable tasks that keep receiving messages; they can wait on people, webhooks, or timers without consuming compute, and runs survive restarts. You don't need a separate background job system to coordinate this work.

AGENTS.md is a convention file placed in a code repository to describe project structure, coding standards, test commands, and caveats to AI coding agents. It's like a README for newly onboarded engineers, but aimed at automated agents. When an agent is given a repository in a sandbox, it reads AGENTS.md first and adjusts its behavior accordingly—for example, using a specified package manager, running specific check commands, or following code style. eve's code extension has built-in AGENTS.md adherence, helping coding agents integrate faster into existing engineering practices and reducing errors caused by unfamiliarity with project conventions.

Upgrading and Getting Started

Existing eve agent users should refer to the 1.0 upgrade guide, which covers changes to extension builds, the agent API, session events, clients, and saved history. eve follows semantic versioning: breaking changes to stable APIs occur only in major versions, while experimental and internal APIs may change between major versions.

Creating a new agent starts in the terminal and requires Node.js 24 or higher:

npx eve@latest init my-agent

In an interactive terminal, this installs dependencies and opens the eve terminal UI. If your team has AI Gateway access, you can start chatting without creating a Vercel project or copying API keys; eve can use existing Vercel CLI credentials to call models locally through AI Gateway. In eve dev, you can ask the agent to add tools, modify instructions, or write skills; with self-modification enabled, it edits its own source and hot-reloads.

#eve 1.0#open-source agent framework#OpenTelemetry tracing#multiplayer sessions#Workflow SDK
Share:

Related articles