@hwchase17: Great conversation with @SierraPlatform’s Head Of Product @ZackRW on the Max Agency podcast. YouTube: https://youtu.be/…

Great conversation with @SierraPlatform’s Head Of Product @ZackRW on the Max Agency podcast. YouTube: https://youtu.be/uCKhOmth2ms Apple: https://podcasts.apple.com/nz/podcast/the-best-ai-agents-are-simpler-than-you-think-zack/id1891551672?i=1000773278465… Spotify: https://open.spotify.com/episode/2jWGobitRmBQUygBiVhD2c?si=c1bded05fc374161…

TL;DR

Sierra builds customer engagement agents for Fortune 20 companies. Its core architecture achieves efficient interaction by parallelizing thinking, listening, and dialog, and uses a no-code Journeys layer that lets operations staff directly define agent behavior, while isolating payment infrastructure to meet PCI certification standards.

From Customer Service to a Full Customer Engagement Platform

Sierra initially became known as a customer support platform, but the actual vision covers every key moment in the customer lifecycle. For an airline, those moments include browsing flights, booking, selecting seats, adding a pet in the cabin, and handling rebookings, delays, cancellations, and baggage issues. There’s both sales and service, plus customer loyalty touchpoints. Sierra agents exist across all of these, with an outcomes-based pricing model — in some cases the agent actually earns a commission from sales.

“We like to say… we try to make simple things simple and hard things possible.” — Zack Reno Wedeen, Head of Product at Sierra

The platform’s scalability means the fundamentals across different use cases are very similar, but each customer can tailor a completely different agent to their needs.

Three Core Phases of Agent Building

The Sierra platform is primarily divided into three parts: Analyze, Build, Release.

Analyze: Explorer Agent & Monitors

• Explorer Agent: Similar to a long-running ChatGPT Deep Research, handles all customer conversations and data.
• Reports & Monitors: Continuously running evaluators on conversation data, tracking metrics like customer satisfaction, resolution rate, sales conversion, etc.

Build: Ghostwriter & Journeys

• Ghostwriter: An agent similar to Codex or Claude Code, specialized in building agents.
• Journeys: The underlying source code layer, but not traditional code — it’s declarative natural language or standard operating procedures. It deterministically compiles into Sierra’s Agent SDK code, and supports “isomorphic” two-way conversion — code can become no-code, and no-code can become code.

“In a single conversation turn, 10 to 15 different models might be invoked. So sometimes you’re classifying while simultaneously replying.”

Release: Governance & Change Management

Sierra primarily serves Fortune 20 companies, with about 40%–50% of the Fortune 50/100 as clients. These customers have strict governance, release processes, and change management needs. So the platform has built-in collaborative review and change management workflows, similar to Figma or Claude Code’s collaboration model, but deeply optimized for no-code agent building.

Parallelized Thinking, Listening, and Conversation

A major breakthrough for Sierra agents is parallelized model invocation. In a single conversation turn, multiple (10–15) different models may be called in parallel:

• Frontier models with top-tier reasoning (for complex tasks)
• Internal models specialized in specific tasks
• Efficient, low-cost classifier models

The entire system is orchestrated by a layer called Agent OS. Agent OS is responsible for breaking down tasks into prompts and injecting data between different models. The key mechanism: If a model says it’s silent, trust it; if not, trust another. This ensures reliability and responsiveness during parallelization.

Why No-Code Journeys?

Over the past 18 months, most agent development on Sierra has fully shifted to the Journeys no-code layer. Reasons:

1. Knowledge ownership: Those who best understand the customer experience are operations staff (customer experience managers, etc.), not engineers. No-code lets them contribute directly to the platform without programming.
2. Deterministic compilation: Pure text approaches lead to non-deterministic compilation or prompt engineering headaches, while Journeys uses a declarative DSL that’s neither fully plain text nor fully code.
3. Ghostwriter empowerment: Ghostwriter is itself an agent, but it directly uses the Journeys product (not code) to build agents. Users just say “I want to orchestrate a returns flow” or “I want to do flight booking”, and Ghostwriter generates the corresponding Journeys, which users can then inspect and modify.

“For example, due to our outcomes-based pricing model, in some cases Sierra agents actually earn a commission from sales — I think that’s quite different from what most people imagine for services.”

Payment Infrastructure Independence & Compliance

Sierra built a completely independent payment infrastructure layer. Payment information never reaches any external large language model, because no LLM provider meets PCI certification standards. The isolated infrastructure ensures payment data security, reflecting financial-grade compliance.

The Model Abstraction Dilemma: Leverage Model Strengths vs. Invest in New Abstractions

In agent building, there are two strategies:

• Leverage what models are good at (e.g., file systems, Git, grep): Coding agents excel at these structures, so you can materialize problems into these abstractions and let models do their thing.
• Keep custom abstractions: Some scenarios (like Sierra’s Journeys DSL) can’t easily be shoehorned into a model’s comfort zone, requiring investment to teach the model new concepts.

Zack believes 80% of the time you should prioritize leveraging abstractions models already handle well, leaving the remaining 20% for truly special cases. Additionally, models are familiar with technologies in their training data (e.g., LangGraph) but may not excel with brand new packages (e.g., Deep Agents). So choosing abstractions requires balancing model familiarity with the value of a custom DSL.

Relationship with Coding Agents

Although the platform core leans toward no-code Journeys, you can absolutely use the Agent SDK to build agents directly in code. The Agent SDK is Sierra’s code-level orchestration and context management — all early agents were built on it. As model reasoning capabilities improved, the Agent SDK was reinvented two or three times, gradually reducing deterministic guardrails and increasing reasoning room per step. However, for Ghostwriter, editing the no-code layer is currently the highest-ROI focus; making Ghostwriter good at both code and no-code is an extremely difficult task, so Sierra chose to specialize.

Who Participates in Agent Iteration?

The daily optimization process typically starts from analysis: operations staff (customer experience managers, etc.) look at metrics and insights, use Ghostwriter to return Journeys for modification, then go through change management for release. There are also engineering teams building other agents that interact with Sierra agents, or extending the platform via tools/packages. The key is removing barriers between the people with the most knowledge and directly contributing to the platform.

Source: YouTube video: @hwchase17 in conversation with Sierra Head of Product Zack Reno Wedeen (https://www.youtube.com/watch?v=uCKhOmth2ms)