Meta News

AI agents are rapidly moving from experimental tools to production systems capable of handling real business workloads. That transition introduces challenges that extend far beyond choosing an AI model or writing a good prompt. Production agents need scalable infrastructure, persistent state, isolated execution environments, reliable retries, observability, security controls, and ways to recover when something fails.

Vercel has been exploring these challenges while building and operating its own internal AI agents. That experience eventually led to eve, an open-source framework designed to simplify the development and operation of durable AI agents in the cloud.

The fundamental problem becomes obvious when an agent needs to serve many users simultaneously. Running a single coding agent on a developer’s computer is relatively straightforward. Running hundreds or thousands of independent agent sessions requires each session to maintain its own context, permissions, tools, filesystem, and execution state.

At that scale, agent infrastructure begins to resemble a distributed system.

Vercel’s work on eve grew partly from its experience developing D0, an internal data agent used by employees to interact with company information.

Building the agent itself was only part of the work. The team also needed infrastructure for execution, state management, sandboxing, workflows, and other operational requirements. Vercel realized that many of these components would be required by almost every production agent.

Instead of rebuilding the same infrastructure for each project, the company created a framework that could provide those capabilities automatically.

Eve allows developers to define agents using relatively familiar building blocks. Instructions and knowledge can be written in Markdown, while deterministic operations and integrations can be implemented as TypeScript tools.

This creates a useful separation: natural language describes what the agent should understand and how it should behave, while traditional code handles operations that require predictable execution.

One of the major challenges when building sophisticated agents is deciding how much information should be included in the model’s context.

Providing everything at once can increase token consumption and introduce information that is irrelevant to the current task. Eve addresses this with skills, which allow specialized instructions and knowledge to be loaded when needed.

An engineering agent, for example, might have separate skills for deployment procedures, database operations, incident response, and application architecture. The agent can access the relevant knowledge depending on the task instead of carrying all of it continuously.

This reflects an important evolution in agent engineering. Context management is becoming almost as important as prompt design itself.

Agents become significantly more useful when they can interact with external systems. They may need to query databases, call APIs, modify repositories, execute code, or trigger workflows.

Eve supports tools that expose these capabilities to the agent while keeping deterministic operations inside conventional application code.

Execution can also occur inside isolated sandbox environments. This is particularly important when agents are allowed to execute code or interact with potentially untrusted data. Isolation prevents one workload from interfering with another and provides stronger security boundaries.

Another important capability is durable execution.

Agent workflows can last much longer than traditional HTTP requests. An agent investigating a production issue, for example, might inspect logs, query services, reproduce a bug, generate a fix, run tests, and eventually create a pull request.

If something fails halfway through that process, restarting everything from the beginning would be inefficient.

Durable workflows allow state to persist while supporting retries and recovery from failures.

Eve also supports the idea of subagents.

Instead of creating one enormous agent responsible for everything, developers can create specialized agents that handle particular tasks. A coordinating agent can then delegate work to them.

A company could theoretically operate separate agents for data analysis, security, infrastructure, software development, or customer support. Each agent could maintain its own instructions, tools, permissions, and specialized knowledge.

This architecture resembles patterns already familiar from distributed software systems, where responsibilities are divided between specialized services.

The difference is that agents combine software capabilities with reasoning and organizational knowledge.

Testing becomes another significant challenge.

Traditional software tests often expect deterministic results: given a particular input, the system should return a specific output. AI agents may produce different but equally valid responses or take different paths to accomplish the same task.

Vercel therefore treats evaluations, or evals, as an important part of agent development.

Tests can verify whether an agent selects the correct tool, successfully completes a task, follows expected constraints, or produces an acceptable response. In some situations, another model can evaluate the quality of the result.

For QA engineers, this represents an interesting change in testing strategy. Agent testing increasingly combines traditional integration testing with behavioral evaluation, tool-call verification, safety testing, and statistical measurements across repeated executions.

The broader lesson is that the difficult part of production AI agents may increasingly be everything surrounding the model.

A serious agent platform may require authentication, authorization, session isolation, persistent state, retries, scheduling, model routing, sandboxed execution, observability, evaluations, human approvals, and connections to external systems.

Once hundreds or thousands of agent sessions operate concurrently, these requirements become distributed-systems problems.

Vercel’s approach with eve is to abstract much of that infrastructure behind a framework, similar to how modern web frameworks hide many of the complexities involved in deploying and scaling traditional applications.

The industry is therefore moving beyond the question of whether an AI model can perform a task. The more difficult question is whether thousands of those tasks can run simultaneously, securely, reliably, and economically.

That is the infrastructure problem Vercel is trying to solve with eve.