Skip to content

Scaling Agent Workloads at Vercel

Software Engineering Daily

51m
Transcript

Original podcast

Where to listen

Summary

Written by a model from the transcript; not yet reviewed.

Andrew Barba and Shar Dara join Kevin Ball to discuss Eve, an open-source, cloud-native agent framework developed at Vercel. They explain how Eve bridges the gap between single-user local agent setups and scalable multi-user cloud environments by using declarative file structures, robust state management, and built-in primitives like skills, tools, and channels. The guests detail how Vercel relies on Eve internally for hundreds of agents, ranging from internal data analysis to go-to-market workflows, while emphasizing a vision where company building is fundamentally agent building.

  • Define your agents declaratively using simple directory structures and Markdown instruction files to scale easily. 8:16
  • Use built-in first-class evaluation frameworks to test non-deterministic agent outputs and monitor system performance over time. 12:33
  • Implement output schemas for agent messaging so you can reliably generate structured data and power dynamic user interfaces. 33:07
  • Leverage durable workflows to ensure that long-running agent sessions remain recoverable and partition tasks at scale. 35:41

Chapters

  1. 0:00
    Episode Introduction and Host Overview

    The episode opens with the host introducing the guests and outlining the focus on Eve, a cloud-native agent framework.

  2. 1:42
    Andrew Barba’s Background and Eve Genesis

    Andrew shares his unconventional path to Versale and the origins of Eve, stemming from the need to deploy agents at scale.

  3. 5:51
    Core Primitives: Skills, Tools, and Connections

    Andrew details the primary building blocks of Eve—skills, tools, and connections—and how they enable progressive agent capabilities.

  4. 6:25
    Channels and Entry Points for Agents

    Eve’s channel system provides various entry points (HTTP, Slack, Teams, GitHub) for initiating agent sessions.

  5. 11:24
    Subagents and Team Collaboration

    Subagents allow hierarchical agent structures, enabling teams to own and coordinate distinct agent responsibilities.

  6. 12:12
    Evaluation Framework (Evals) for Agent Quality

    Eve incorporates a first-class evals system to test, monitor, and iterate on agent behavior over time.

  7. 25:59
    Future Directions and Community Impact

    The episode concludes with reflections on Eve’s potential, community adoption, and the evolving landscape of agent frameworks.

  8. 29:28
    Deployment Models: Monorepo vs. Separate Repos

    The hosts discuss how Eve can be integrated into a Next.js monorepo or deployed as an independent backend service.

  9. 37:39
    Memory Management and Self‑Evolution

    Eve introduces memory slots and self‑evolution mechanisms, allowing agents to learn and adapt during operation.

  10. 45:15
    Open Source Contribution Process

    Discussion of Vercel’s strategy for accepting external PRs while managing security and testing constraints.

  11. 46:07
    Open‑Source Governance and Ownership

    Vercel explains its contribution model, ongoing ownership, and the challenges of testing external contributions.

  12. 48:00
    Eve’s Design Philosophy and Future

    Andrew outlines Eve’s horizontal scaling approach, betting on model intelligence, and the vision for the next years.

Highlights

  • 3:42

    From billing team to agent frameworkstory

    The guests explain how they transitioned from leading Vercel's billing team in early 2025 to developing Eve after exploring what it takes to deploy production-grade agents.

  • 4:37

    Scaling agents beyond local machinesinsight

    A speaker highlights the difference between local setups like OpenClaw and cloud frameworks, demonstrating how Eve scales out horizontally to handle thousands of simultaneous requests.

  • 7:28

    The declarative markdown architecturestrategy

    The guests explain the initial extreme stance of defining Eve purely through English Markdown text files to simplify agent deployment.

  • 11:24

    Using subagents for team organizationstrategy

    The guests describe how Vercel organizes internal teams around subagents, creating a hierarchical agent structure where different departments own specific functional agents.

  • 14:27

    Testing framework using internal evalsstrategy

    The speaker explains that the entire test suite for the Eve repository is built using its own evaluation framework to ensure reliable daily shipping.

  • 30:41

    Shipping web apps with agentsstory

    Shar Dara shares concrete examples of user applications built on Eve, including an open-source CRM and an AI music maker.

Quotes

  • “Eve is an open source, cloud-native agent framework from Versale that removes much of the agent scaling burden.”
    Unnamed speaker · 0:23
  • “We think a lot of other agents can almost be entirely expressed in English.”
    Unnamed speaker · 7:19
  • “Eve has a first-class way to just drop in an MCP URL, and we automatically expose those tools for you.”
    Unnamed speaker · 10:24
  • “We have two different types of evals. The first type is more deterministic. The second type is LLM as judge.”
    Unnamed speaker · 13:04
  • “We have a bit of a funny problem right now where we want to accept outside contributions, but one of the problems we actually have is because our test suite is hitting models and is actually deploying projects to Vercel.”
    Unnamed speaker · 46:20
  • “And the way we designed the framework was really meant to take advantage of this.”
    Unnamed speaker · 48:07
  • “So the idea is that Eve is more fundamental than your certificate of incorporation.”
    Unnamed speaker · 49:03
  • “And we do have customers internally that are running Eve on Kubernetes, on their own hardware even.”
    Unnamed speaker · 49:59
  • WarpBuild 17:04–17:46
  • Fingerprint 17:42–18:22
  • GuardSquare 18:23–19:11

About this episode

Most AI agent setups today are built around a single session, where one user interacts with one agent at a time. However, that model breaks down when an agent has to serve a business, where thousands of requests can arrive at once and each session needs to be isolated, durable, and recoverable. Getting agents to run reliably at that scale has meant a lot of hand-rolled infrastructure beneath the agent itself. eve https://eve.dev/ is an open source, cloud-native agent framework from Vercel https://vercel.com/ that removes much of the agent scaling burden. In the eve framework, an agent is defined declaratively through configuration files and these files compile into infrastructure as code so the platform provisions only what the agent actually uses. Andrew Barba https://x.com/andrew_barba is a Member of Technical Staff at Vercel, and Shar Dara https://x.com/shardarais the Product Lead for eve at Vercel. In this episode, they join Kevin Ball to discuss what it means for an agent framework to be cloud-native, why they chose to express agents in plain English, and their view that company building is becoming agent building. Sponsorship inquiries: sponsor@softwareengineeringdaily.com mailto:sponsor@softwareengineeringdaily.com The post Scaling Agent Workloads at Vercel https://softwareengineeringdaily.com/podcasts/scaling-agent-workloads-at-vercel/ appeared first on Software Engineering Daily https://softwareengineeringdaily.com.

Transcript

0:00
51:25

10,216 words · 4 speakers

Topics

  • Eve
  • Vercel
  • Postgres
  • Kubernetes

Page updated · transcript and summary are machine-generated