Tom Occhino has built foundational infrastructure at the kind of scale almost no one in B2B will ever touch. He spent over 12 years at Facebook, where he co-created React and React Native and shaped the open-source tools that a huge chunk of the web still runs on. His CTO at Vercel, Malte Ubl, spent 12 years at Google as a principal engineer on search and created Core Web Vitals.
So when Occhino, now Vercel’s Chief Product Officer, got up at SaaStr AI Deploy to talk about agents, the interesting part wasn’t the product pitch. It was the operating lesson buried inside it.
Vercel didn’t build a few agents to show off. They built hundreds. And they built them for themselves first, on their own stack, before turning around and selling the tools to anyone else. The numbers they’re posting from running those agents in production are the kind of numbers that should make every B2B + AI founder rethink their 2026 headcount plan.
The one observation that reframes the whole agent conversation
Occhino has spent his career obsessing over what he calls “undifferentiated heat loss.” Every minute a company spends configuring infrastructure, building bespoke frameworks, and wrangling DevOps is energy that isn’t going into product, pipeline, or customers. At Facebook and Google, the investment in that foundation ran at roughly the same level as product development itself, even though product is what drives revenue and the foundation gets treated like a tax.
The kicker: almost none of that foundational work had to be purpose-built. Occhino and Ubl joke that you could run Google Search on Facebook’s infrastructure and Facebook’s newsfeed on Google’s. The plumbing was generic. The differentiation lived somewhere else entirely.
That’s the lens to carry into the agent era. Most of what teams are about to build for agents is undifferentiated. The question isn’t whether you can build it. It’s whether building it is where your scarce energy should go.
The shift from pages to agents
For the last several decades, software meant a purpose-built UI. Website, web app, desktop, mobile, the form factor changed but the model didn’t. Everything you accessed or updated happened through a dedicated interface. The UI was the tree trunk, and every action branched off of it.
Agents flip that. The UI becomes a leaf node, a lightweight surface that helps an operator make a decision or understand an outcome. The new trunk is headless, autonomous software that runs on its own.
Two things make agents genuinely different from traditional software, and the second one matters more:
- Interaction changes. A lot of new software isn’t UI-first anymore. Sometimes there’s a conversational interface. Often there’s no interface at all.
- Agents act autonomously on your behalf. They wake up on a trigger, an inbound lead, a fraud signal, a monitoring alert, take action against the rules and goals you gave them, and escalate to a human only when they have to.
Occhino’s framing is that every company on earth is going to need at least two agents. One for employees, sitting inside the collaboration tools you already use, handling internal knowledge, actions, and workflows so people stop navigating legacy systems. One for customers, handling support, transactions, education, and self-service across any channel.
“Agents as a service” don’t work
This is the line founders building agent products need to sit with. Vercel’s conclusion, after two years and hundreds of agents, is that you can’t buy a one-size-fits-all agent off the shelf any more than you can buy a one-size-fits-all website. Every team is going to build its own.
That doesn’t kill the build-versus-buy question. It moves it. You don’t buy the agent. You buy the infrastructure and the tools that make building the agent cheap, fast, and safe. Vercel uses Vercel to build Vercel, and that dogfooding is the entire argument.
The production numbers
Here’s what running their own agents looks like in practice at Vercel today:
- Content agent: turns long Slack threads into blog post drafts in the company’s voice. Around 96% of marketing content now starts this way. A human still edits and reviews, but the first draft, the slow part, mostly disappears.
- Lead qualifying agent: replaced a large SDR team doing manual, repetitive qualification. The people who did that work got redeployed into higher-impact roles.
- Customer support agent: handles 93% of customer inquiries with no human intervention. The best part, in Occhino’s framing, is that anything the agent can’t handle is now a real signal. It’s either a product gap or a misconfiguration, not mechanical ticket-clearing. The team only touches the genuinely hard or genuinely valuable stuff.
Read those three together and you get the real story of the lean AI-native company. It’s not that headcount goes to zero. It’s that humans stop doing the work an agent can do and move to the work that actually compounds.
Inside “DealOne,” a real GTM agent
The agent Occhino deep-dived is DealOne, Vercel’s go-to-market agent. It ingests every sales call, generates notes with action items, posts coaching suggestions into an internal Slack channel, proposes CRM field updates, tracks competitive mentions and objections over time, and runs a postmortem on every closed-lost deal. All of it lands where the team already works, in Slack.
The architecture is worth walking through, because it’s a blueprint any B2B team could copy:
- A Gong call ends and fires a webhook to a Vercel function.
- That kicks off a durable 10-step workflow that finishes start to finish every time.
- The workflow pulls the transcript and runs it through Claude via Vercel’s AI Gateway to produce a structured summary: topics, objections, deal stage, sentiment, stakeholders.
- That summary gets embedded into a hybrid vector and keyword index, alongside other call summaries, atomic objections and blockers, and cross-deal patterns.
- The whole index is exposed through a single secure MCP server, so any agent (DealOne, Claude Code, whatever they build next) gets the same context through one authentication boundary.
- Reps @-mention DealOne in a deal channel and ask anything. “What were the top objections from this customer?” “Why did this deal slip?” “Coach me before my next call.” They get back a cited answer linking to specific moments in the transcript or Slack messages they have access to.
Agent execution runs inside a Vercel sandbox. After each turn, the sandbox is snapshotted and resumed for the next message in the thread. Durable conversation state, no infrastructure to babysit. A Next.js dashboard guarded by Okta SSO sits on top for anyone who wants the structured view.
The pattern underneath all of it: every sales call a rep takes automatically becomes structured data, then intelligence, then a coaching surface delivered to the rep where they already are. No new tool to adopt. No behavior change.
The agent stack
To build DealOne, v0, and the rest, Vercel had to fill gaps in their own infrastructure. The collection of tools they ended up with is the part of the talk that doubles as a roadmap for what an agent-native company needs:
- AI SDK to integrate models in a few lines of code and swap models without touching application logic. If a better model ships tomorrow, you try it without a new deploy.
- AI Gateway for one unified entry point to 100-plus models, with fallback routing so a rate limit or an upstream provider outage silently fails over instead of dropping requests. This is how DealOne reaches Claude reliably.
- Chat SDK, a TypeScript SDK for building bots across Slack, Teams, Discord, and WhatsApp from a single codebase. Anyone who has integrated Slack and Teams separately knows you normally write everything twice and share none of the code.
- Fluid compute, which pairs serverless scale with server-style flexibility. For traditional apps this was a price-performance nice-to-have. For AI apps it’s essential, because they’re IO-bound, sitting and waiting on model responses, and you don’t want to burn compute idling.
- Vercel Sandbox, a secure, ephemeral, isolated environment for running untrusted or experimental code without exposing production.
- Workflow SDK for durable orchestration with built-in retries, state persistence, and observability. Agents have to pause, resume, wait for a human in the loop, and retry. Workflow makes that the default instead of custom plumbing.
Vercel is pitching itself as the foundation so you can spend your energy on the agent, not the scaffolding. Whether you buy their stack or someone else’s, the categories on that list are the ones your team will be assembling in 2026.
How to build your first agent
Occhino’s advice for anyone who hasn’t built one yet is refreshingly unglamorous, and it’s the part founders should act on this week:
Pick low-value, highly repetitive work. Support triage, data pulls, lead qualification. Something a person on your team does dozens of times a week. That’s where the ROI is fastest and where you’ll learn the most about how agents behave in your environment.
Document it in painful detail. This feels backwards. You can already do the task, so writing it down seems like wasted effort. It isn’t. An agent is only as good as the process you hand it. If you can’t write down exactly how a human should do the work, an agent won’t be able to do it either. The act of documenting is the actual work.
Hand the documented process to a coding agent. Use Claude Code, v0, or whatever you prefer, give it the plan, and iterate all the way to production. Use a coding agent to build your first agent.
Start small. Pick something you do every day. Learn as you go.
5 Unexpected Learnings From Tom:
1. The thing the agent can’t handle is the most valuable output, not the failure. Everyone measures support agents by deflection rate. Vercel’s reframe is sharper: the 7% that gets past the agent is a curated list of real product gaps and misconfigurations. The agent isn’t just clearing tickets, it’s filtering signal from noise so humans only see the problems worth solving.
2. Documentation is the bottleneck, not the model. The hard part of building DealOne wasn’t the AI. It was being able to write down exactly how the work should be done. Teams that have never documented their own processes are going to discover that’s the real blocker to deploying agents, and it has nothing to do with which model they pick.
3. “Build vs buy” didn’t die, it moved up a layer. The instinct is to read “every team builds its own agents” as pure build. The actual lesson is that you buy the foundation (the SDKs, the gateway, the sandbox, the workflow engine) and build only the thin differentiated layer on top. The buy decision got bigger, not smaller. It just moved.
4. Reliability infrastructure that was optional for software is mandatory for agents. Durable workflows, automatic retries, fallback routing across model providers. For traditional apps these were nice-to-haves. For agents they’re load-bearing, because an agent that silently fails mid-task or can’t fail over when a provider rate-limits isn’t an agent you can trust in production. The boring plumbing is the moat.
5. The fastest path to your first agent runs through your most boring work. The reflex is to point AI at the flashy, high-value problem. Vercel’s advice is the opposite: pick the repetitive thing someone does dozens of times a week. Lowest risk, fastest ROI, and the place you learn the most about how agents behave before you trust them with anything that matters.
