Vercel launches eve, an open-source framework simplifying AI agent development

Vercel has launched eve, an open-source AI agent framework that rethinks how developers build, secure, and ship agent-driven workflows. Eve blends the ease of structured Next.js apps with the operational DNA of Vercel’s platform — and it is already running over 100 internal agents, now responsible for almost a third of the company’s deployments. If you want to ship agents that can scale from your laptop to production, sandboxes and all, without rethinking how your team writes or deploys software, eve isn’t just promising — it works.

What is Vercel eve and why is it called "Next.js for AI agents"?

Vercel eve is an open-source AI agent framework, released at the Ship conference in London, with the stated ambition of giving developers a reliable, scalable platform for agent development and deployment. Its defining trait is the way it borrows patterns from Next.js: each agent lives in a self-contained directory that holds three core pieces:

• a model file,
• a Markdown system prompt,
• and a set of TypeScript files for tools.

There’s no need for tool registration boilerplate. Eve scans this directory structure, compiles it, and gives you a functioning agent. The analogy is not superficial — just as Next.js lets teams to ship complex web apps through conventions, eve aims to make agent creation as composable and ergonomic. The result is that agents can be built, iterated, and deployed by anyone familiar with modern TypeScript projects, and they benefit from session durability: workflows can pause and resume without losing state.

This model turns an often-fragmented process — agent setup, prompt tuning, tool wiring — into a single, predictable, code-centric flow. For developers, the learning curve is gentle, the directory model is transparent, and integrations with the rest of the Vercel ecosystem (deployment and monitoring) are direct. More in the official release via techgig.com.

How does Vercel eve enhance security with sandboxing and human approval?

Security in AI automation usually gets bolted on late or implemented as brittle wrappers. Eve makes it part of the architecture. Each AI agent runs in its own sandbox — meaning code execution is isolated from both the host system and other agents. That's not just container-level isolation; it’s runtime-level. If an agent fails or is compromised, the blast radius is capped at the agent’s sandbox. For companies running multiple agents, this is the difference between a controlled failure and a system-wide risk.

Some tools are inherently sensitive (think data deletions, privileged API calls, or expensive operations). Eve addresses this by allowing any tool to be marked as requiring human approval. If an agent’s code invokes such a tool, the action pauses until a human greenlights it. This "human-in-the-loop" checkpoint closes the loop on accidental or adversarial behavior — and it’s configurable per tool, so non-sensitive operations flow uninterrupted.

For AI workflows with real-world side effects, these guardrails are non-negotiable. Sandboxing stops a bad agent from eating your infrastructure. Human approval gives teams a brake pedal before the agent acts outside the sandbox. Eve’s security layer is the kind you rarely find in early-stage frameworks — here, it ships by default.

How to start building and deploy an AI agent using Vercel eve today?

Eve is built for zero-friction onboarding and deployment. You can run an agent locally with a single command and deploy it with your usual Vercel workflow.

1. Create agent directory structure
In your project, define a new agent as a directory. Drop in:

• model.ts
• prompt.md
• TypeScript files for each tool (e.g., tools/sendEmail.ts)

Eve discovers and wires these automatically. No tool registration, no route files, no dependency gymnastics.

2. Write your model and prompt
model.ts can define parameters, environment needs, and runtime logic.
prompt.md is your system prompt — Markdown means your context is readable and versionable.

3. Create tools
Each TypeScript file is a tool (API wrappers, business logic, data fetchers). To require human signoff on sensitive actions, flag them as such:

export const deleteUser = {
  requiresApproval: true,
  async run({ userId }) { /* ... */ }
};

4. Start local development

eve dev

This command spins up the agent locally — with sandboxing already active.

5. Deploy to Vercel

vercel deploy

No special steps beyond your team’s CI/CD pattern. The agent lands in the same environment as other Vercel projects.

Eve is currently in public preview and available on GitHub under the Apache 2.0 license. You can ship experiments and production workloads without vendor lock-in and with the same operational workflow as any Vercel deployment.

6. Durability and session management
Sessions are durable — an agent mid-workflow can pause (waiting for human approval, external events, or other agents), and then resume. That’s baked into the agent runtime.

Fine print: All of this is possible because the agent’s directory is a first-class project root, discovered and built just like a Next.js app. This means you don’t need to learn a new build step or deployment target; the conventions match the ones you already know.

What integrations and observability features does eve offer for AI agents?

Eve is built for operational use: communicating across platforms, and seeing inside each agent’s lifecycle. It ships with out-of-the-box channels for:

• Slack
• Discord
• Microsoft Teams

Agents can surface actions, notifications, and receive commands directly from these platforms. Building for internal productivity? You don’t need glue code to get an agent chatting in your team’s workspace — Eve’s channels handle it.

For observability, eve generates OpenTelemetry traces for every agent action. This isn’t just metrics logging — it’s full traceability. Developers can slice, filter, and examine agent behavior and performance in real time or after the fact, using OpenTelemetry-compatible backends.

In short:

• You see what agents are doing.
• You spot slowdowns, failures, or runaway actions immediately.
• You standardize monitoring across every shipped agent — no hacky instrumentation sidecar required.

This level of integration means agent-driven workflows are as observable as any critical API or service in your stack, not a black box or sidecar.

What impact has Vercel eve had on internal deployments and agent usage?

Eve runs in production at Vercel — not as a demo, but as the engine behind real workflows. According to the official release, Vercel has deployed over 100 internal agents using eve. These aren’t one-off scripts or experiments; they are integral to the company’s operations.

The impact is measurable. Eve-powered agents now trigger about 29% of total deployments at Vercel. That’s nearly a third of all production deployments, driven not by human code pushes, but by agents orchestrating builds, tests, integrations, or automated operations. The productivity gain here is direct: agents handle work that would otherwise eat developer hours, and they do it with auditability, structured prompts, and reproducible workflows.

Scaling up the number of deployments isn’t just about speed; it’s about letting human devs focus on harder problems while operations and integrations get automated. The signal: if agents run a third of Vercel’s production ship traffic, this model is not experimental — it’s operationally proven.

What future possibilities does Vercel eve open for AI agent development?

Eve’s core value is to flatten the path from prototype to production agent. Its file-based pattern and zero-config deployment make iterating on agents as simple as shipping a web page. This positions it as a foundation for:

• Rapid extension: new tools, prompts, or model integrations can be added with a single file.
• Cross-industry adoption: secure, observable, and composable agents enable regulated sectors, internal automation, and customer-facing chat controls alike.
• Open-source velocity: with an Apache 2.0 license, contributions and forks are frictionless, and vendor lock-in is not a concern.

Eve’s design as "Next.js for agents" means developers skip the framework tax and get straight to the logic — and the built-in security and operational baseline mean that agents shipped on day 1 don’t need to be rewritten for scale or auditability on day 100.

Takeaway: the open-source, dev-focused agent framework that works

Vercel eve isn’t just a new agent framework — it’s a reset button for how AI workflows get built, debugged, and shipped. You get a transparent, directory-based agent model. Security that’s runtime-deep, not just a policy document. Channels and observability built-in, from Slack to distributed traces. And, crucially, a workflow that already runs 100+ critical agents for the company building it. Eve is free and open-source (Apache 2.0). If you’re serious about AI agents, building on a foundation with this much operational proof and developer use is now the rational default.

For teams moving fast and shipping safe, the layer of agent infrastructure that doesn’t need a rewrite is finally here.