1 Sierra Beyond Customer Support
Sierra is best known as a customer support platform, but Zack clarifies that from day one, the vision has been a full engagement platform across all customer moments that matter. For an airline, that spans browsing, booking, seat selection, pet-in-cabin, rebooking, baggage — some sales, some service, some loyalty.
There are cases where the Sierra agent is actually getting paid a commission on a sale through outcome-based pricing, which is fundamentally different from how most people imagine customer service AI.
Sierra works with most of the Fortune 20 and roughly 40-50% of the Fortune 50/100. The platform is extensible enough to handle radically different use cases through the same underlying infrastructure.
2 Analyze, Build, Release
Sierra's web app has three main sections:
- Analyze — Explorer agent (deep research over customer conversations), reports, monitors (always-on conversation evaluators)
- Build — Ghostwriter (the agent that builds agents), Journeys (the no-code layer / source code), variables and configurations
- Release — collaboration, change management, governance procedures
Most people start with Build using SOPs, transcripts, or a conversation with Ghostwriter. Once the agent is live, the daily routine shifts to Analyze → Build → Release — finding insights, making improvements, and deploying changes.
The primary users are operations people — customer experience managers who have the deepest domain knowledge. Engineering teams build integrations and extend the platform via tools and packages.
3 Inside Ghostwriter & the No-Code Layer
Sierra's stack has three layers:
- Agent OS — the constellation of models. A single conversation turn might invoke 10-15 different models: frontier models for top-tier reasoning, in-house models for specific tasks, and cheap classifier models
- Agent SDK — the code-based agent orchestration and context management layer (where Sierra started)
- Journeys — the no-code layer that compiles down to Agent SDK code deterministically and isomorphically (round-trip: no-code → code → no-code produces the same result)
Ghostwriter writes Journeys directly (not code), so outputs are inspectable by operations teams. The language is declarative — "when customers ask about X, unlock these conditions and flow in this direction" — mapping closely to how you'd onboard a human to a CX role.
For customers needing code (CI/CD pipelines, complex streaming API tools), no-code compiles to code files that can be imported alongside hand-written code — because they're literally the same thing under the hood.
4 Meeting Models on Their Turf — 80% of the Time
Zack frames a fundamental tension: do you reframe your problem into structures models already understand, or do you invest in making models good at your custom abstractions?
His personal perspective: 80% of the time, meet the models where they are. Coding agents are great at file systems, git, and grep — so materialize everything into those structures and let the models "cook." Reserve custom training for truly special cases where your way of thinking is genuinely the correct abstraction.
The Overconfidence Trap
If you do something models are almost familiar with (like Agent SDK which is close to code but not quite), the model can become overconfident — it thinks it knows the abstraction when it doesn't. You need to go all the way to what models know, or not at all.
Harrison Chase adds that models trained on certain packages (like LangGraph, which is in training data) will recommend them naturally. For newer packages like Deep Agents, they have to think about what makes models good at writing certain frameworks.
5 Agent-to-Agent — When an API Call Still Beats MCP
For agent-to-agent communication, the most common approach at Sierra is a plain API call. When you know who you're talking to in advance, you save tokens and get 100% accuracy.
That said, Sierra agents support both MCP and A2A protocols. Agents can be MCP clients or servers — which is how Sierra powers ChatGPT apps. Example: Redfin's AI search is a Sierra agent under the hood, and it's available in ChatGPT as well.
Sierra agents can also invoke other Sierra agents or call out to a customer's in-house platforms. Enterprises with their own AI projects (e.g., specialized document generation) can integrate via agent-to-agent calls.
6 Why Agentic Commerce Will Be Bigger Than E-Commerce
Zack's thesis: the way we get things done is shifting from clicking through websites to asking agents. Managing subscriptions, ordering supplies, making dinner reservations — it's all heading to agents. Brands need to be ready on the other side.
PCI-Certified Voice Payments
Sierra invested in payments early, achieving PCI DSS Level 1 certification — the only voice payments platform (at launch) where you don't need to transfer to another system for checkout. They built isolated infrastructure where payment info never touches an external LLM (no LLM providers are PCI certified).
The Personal Agent Future
Zack believes the majority of agentic commerce will come from personal agents (Claude, ChatGPT, Codex) talking to brand agents (Sierra). Brands will want platforms like Sierra to present products correctly, make checkout easy, and show up well — whether for a human browsing or an agent browsing.
7 Running Models in Parallel & Ensembling Transcription
Sierra runs massive parallelism in production. Examples:
- Speculative execution — looking up answers before knowing if they're needed; classifying and responding at the same time
- Transcription ensembling — running two transcription models in parallel. For northern UK accents, one model has the highest quality but hallucinates during silence. Solution: if model A says silence, trust it; if model A says speech, trust model B for content. Specific logic determines which model to trust in each scenario
Modular Voice Architecture
Sierra made an early decision to be modular across voice — multi-homing providers across transcription, synthesis, and native voice-to-voice models. For any language, any customer, any use case, they can swap providers. This was driven by the reality that no single provider is best at everything — especially across 60+ languages.
In-House Models
Sierra builds in-house models where they're pushing limits that off-the-shelf solutions can't reach. Knowledge retrieval and reranking is a prime example. They have a sizable research team but are deliberate: "We try not to do it just for the sake of doing it."
A typical conversation turn: roughly a third frontier models, a third classifiers, a third speculative/progress indicators. Frontier models do 1-2 inferences for the bulk of reasoning.
8 Inside the Agent Data Platform
LLMs are excellent at in-the-moment empathy — recognizing when someone's frustrated, late to a reservation, or just had a long flight. But they don't inherently know what you care about at a deeper level. Previous-generation AI (recommender systems) often knows that better.
The Agent Data Platform bridges this gap by combining:
- Structured data — from customer data platforms, CRMs, internal systems (what to recommend, which offer to present)
- Unstructured data — the live conversation context (the "here and now")
Example: during sales, structured data knows the right offer, but previous-gen AI presents it in a stilted way. LLMs can understand how to present an offer, weigh two options based on conversation context, and pick the right one for the moment.
Explorer Agent
Sierra's Explorer is "ChatGPT Deep Research for all your customer data." Instead of manually spelunking through reports, you ask: "Why did resolution rate dip?" or "How can I generate more sales?" Explorer can be set up with daily automations and partners with Ghostwriter to close the loop — suggesting fixes based on insights.
9 Context Engineering — Everything It Needs, Nothing More
Zack's definition: "Showing agents everything they need to do the right thing, but nothing more."
Progressive Disclosure
Don't bring information into the prompt before it's relevant. But be careful removing it — if you do prompt compaction and create incoherence between history and system prompt, things break. One part of the prompt saying X while another says Y is a top source of hallucinations.
Prompt Caching
Sierra's stance: it's a "nice to have." They don't invalidate caches for no reason, but quality always comes first. They're not zealots about it. When agent outcomes are high-value (selling a $100 product or a $1,000 lifetime value plan), the cost savings from caching are a rounding error compared to quality impact.
RL & Fine-Tuning
Sierra has explored RL extensively. The biggest practical benefit has been distillation — getting open-weights models to match frontier performance at lower cost. Two challenges: (1) regurgitation risk means you can never fine-tune on data you don't want regurgitated, and (2) frontier models improve so fast that RL gains can become a rounding error within 3-6 months. Capacity (not cost) has driven most of their multi-provider strategy — preparing for Black Friday/Cyber Monday spikes that translate to billions of conversations annually.
10 Why Multi-Agent Systems Are a Trap
Zack is a self-described "monolith loyalist". His critique of multi-agent systems:
- Shipping your org chart — if you want multi-agent so one team works on one agent, you're just mirroring organizational structure
- Information deprivation — splitting triage and task agents deprives each of the other's context. The triage agent loses procedural knowledge; the task agent loses triage context. This is "typically destructive of value"
- Premature microservices — people reach for multi-agent the same way they reach for microservices before they're ready
Sierra agents tend to be one agent representing the brand. If you're managing context correctly with good context engineering, you typically don't need multiple agents — you're not exposing wrong context to wrong agents.
The right time for multi-agent: when you have truly separable jobs where there's no purpose for the first context being part of the second context. But this is rare.
11 Voice Architecture — Latency, Naturalism, and 60 Languages
The majority of Sierra conversations are voice, and the one constraint they have that coding agents don't is latency — if you don't respond in 1-2 seconds, people wonder where you went.
Key Voice Challenges
- Latency — parallelism and progress indicators ("Hang on while I look up your account")
- Naturalism — a combination of what the agent says (the text) and how it sounds (synthesis quality). Often when something sounds robotic, the text itself reads robotic too
- Multilingualism — fluent in ~60 languages. Some languages have 20% word error rates from the best provider (e.g., Hungarian), solved by ensembling multiple transcription providers
The Turn-Taking Breakthrough
Before Sierra's innovation, voice AI had "50 lines of Python (Silero VAD) deciding when to speak, and a trillion parameters deciding what to say." That balance is way off. In human conversation, deciding when to speak is roughly 50% of cognitive effort.
Sierra's unlock: parallelizing thinking, listening, and talking. While listening, the agent is already thinking about what to say next. While talking, it's listening for interruptions.
Voice-to-Voice Models in Production
Sierra now has production agents running native voice-to-voice models, but they're used selectively — for simpler journeys where naturalism matters most. Current limitations: still almost an order of magnitude more expensive, not quite as reliable with tool calling and instruction following, and only competitive in English. Over/under for 50% of traffic on voice-to-voice: ~24 months.
12 Making Memory a First-Class Primitive
Memory is a first-class primitive on the Sierra platform. Three layers:
- Explicit per-turn — the agent explicitly saves something to memory during a conversation
- Journey-defined — the agent builder specifies what's important to remember (e.g., "remember birthdays")
- Implicit/automatic — the agent autonomously decides what's worth remembering
Real impact: resolution rate has meaningfully increased from memory — greeting customers by name, remembering their last call, knowing yesterday's hour-long frustrating experience.
Authentication Matters
Memory requires trust in authentication. Over phone, you can't always confirm identity from the number alone (office networks, family lines). Every business must define policies for which memories are sensitive and when extraction is appropriate. "Hey Harrison, thanks for calling again" is fine. "Hey Harrison, are you calling about your social security number?" is a completely different standard.
Memory Structure
Zack says the underlying structure (knowledge graph, vector store, file system) doesn't really matter. Reason: a typical customer's memory store is three orders of magnitude smaller than the knowledge base. The retrieval and ranking problem is simple enough that structure is irrelevant.
13 Why There's No Breakout Memory Company
Despite memory being a hot topic with startups for 2+ years, none have become massive breakout successes. Zack's theory: memory is bundled with authentication. To sell memory B2B, you also need to sell identity verification, and that's a much harder trust problem.
Claude and ChatGPT succeed at memory because users already trust them — the trust relationship is pre-established. A standalone memory startup has to earn that trust from scratch plus handle identity, which is "biting off more than you think."
14 Evals, Monitors, and the Tau-Bench Universe
"The Solution to All AI Problems Is More AI"
Sierra's philosophy: something 90% accurate gets verified 90% of the time, which gets verified 90% of the time — and you end up with three or four nines of reliability through layered AI monitoring.
Monitors
Always-on evaluators that run on every conversation, flagging issues for review. Instead of reading 10,000 conversations each morning, teams review 5 flagged ones and feel comfortable.
Simulations
Sierra's dedicated eval product for customers. Supports multiple personas, adversarial users, background noise scenarios for voice, and cross-language testing. Having good simulations is the unlock — it lets you make changes with confidence that you're not regressing.
Self-Improving Agents
Today: monitors detect → Ghostwriter suggests fix → human reviews and pushes. Near future: agents will start self-improving with confidence-based autonomy. High-confidence fixes (e.g., obvious knowledge article contradiction) get an FYI notification instead of requiring approval. All primitives are there; it's about customer comfort with the level of control.
The Tau-Bench Universe
Sierra's research team has released four benchmarks: tau-bench (tool calling / process following), tau-voice, tau-knowledge, and MuBench (multilingual transcription). They're primarily used to evaluate providers, not agents — for internal agent evaluation, customer-specific simulations are too important to rely on general benchmarks.
15 How Outcome-Based Pricing Aligns Incentives
Zack considers outcome-based pricing the #1 operational reason for Sierra's success. It aligns incentives — when you deliver $100 outcomes and keep a portion, everyone rows in the same direction.
How It Works
- Pricing is necessarily customer-specific — troubleshooting a complex device setup (20 turns, heavy context engineering) is far more valuable than a simple balance check
- Some outcomes are worth tens of dollars per interaction; others are near-commodity
- They can differentiate pricing within a single customer's agent, but they're not dogmatic about it — aligned incentives matter more than engineering every detail
Why More Companies Don't Do It
Two reasons: (1) many products have become more similar to what you could buy with raw tokens as models improved, and (2) it's still very early. Zack expects outcome-based pricing to become the norm for high-value activities, while commodity tasks (knowledge base lookups) will stay on usage-based pricing.
16 Who Thrives as a Forward-Deployed Agent Builder
Zack joined Sierra from consumer products (Google Lens, Google Podcasts, Robinhood) and discovered he loves enterprise sales. The ability to call individual upset customers and help them directly felt empowering in a way that building for a billion Google Search users never did.
The Formula One Analogy
Coding agents are like faster cars — but faster cars need more pit stops. Product judgment and customer intuition are needed more often, not less, because code ships so fast. People who bring both engineering and product skills are in "an amazing loop of moving fast." Those who split engineering and product judgment need even tighter daily collaboration.
The Hiring Rubric (in beta)
- Customer intuition — deep understanding of what customers actually need
- Agency — "Why not today?" mindset, expanding what's in your locus of control
- Product judgment — knowing what to build, not just how
- Technical depth — systems thinking and architecture design
- Communication — ensuring product isn't the bottleneck
- Intensity — staying locked in like an F1 driver
- Leadership — drawing activity into the correct direction
Interviewing for Agency
Sierra's "AI native interview" has candidates build a product end-to-end over a few hours and then review it with the team. You can see which candidates think things are out of scope and which ones pull them into scope and build on top. Agency shows as an expanded sense of what's in your control — especially with coding agents bringing so much more into the locus of control.
🎯 Key Takeaways
🔑 Key Takeaways
- Sierra is a full engagement platform — not just support. Agents handle sales, loyalty, booking, and payments across the entire customer lifecycle
- 10-15 models per conversation turn — a mix of frontier models, classifiers, and in-house specializations running in parallel
- No-code compiles to code isomorphically — Journeys and Agent SDK are the same thing; you can round-trip between them
- Meet models on their turf 80% of the time — materialize into file systems, git, grep; only invest in custom abstractions for truly special cases
- "Whenever you think the model's too dumb, it's actually too smart" — hallucinations usually come from contradictory context, not model limitations
- Multi-agent systems are usually a trap — splitting agents deprives each of valuable context; solve with better context engineering instead
- Voice requires parallelized thinking/listening/talking — 50 lines of VAD code vs a trillion parameters was the wrong balance
- Memory requires authentication — which is why standalone memory startups struggle while Claude/ChatGPT succeed at it
- Outcome-based pricing is Sierra's #1 success factor — incentive alignment cuts through all prioritization and resource allocation problems
- Product is the new bottleneck — faster coding means you need product judgment and customer intuition more often, not less
- Agentic commerce > e-commerce — personal agents talking to brand agents will exceed hundreds of billions in transaction volume
- The "solution to all AI problems is more AI" — layered monitoring achieves three to four nines of reliability through cascading verification
🔗 Resources & Links
- Agent2Agent (A2A) Protocol — open protocol for agent-to-agent communication
- Model Context Protocol (MCP) — standard for model-tool integration
- LangGraph — LangChain's agent orchestration framework
- Deep Agents — LangChain's new package for deep agent patterns
- Not Another Workflow Builder — LangChain blog post on agent architecture philosophy