Why we built Decagon Duet on Agent Operating Procedures

Last month, we launched Duet, an AI partner that continuously analyzes and improves your Decagon agent. Agent building is inherently iterative, as new conversations surface performance gaps and opportunities to introduce new workflows. Duet compresses that iteration loop by automatically analyzing transcripts and suggesting changes, helping you deliver better customer experiences faster.

When we started building Duet, we first considered connecting a frontier reasoning model directly to our platform. These models excel at intelligence-intensive tasks like coding, but using one would have meant rebuilding the workflow orchestration and tooling Decagon already delivers.

So we took a different path. We built Duet on Agent Operating Procedures (AOPs), our approach to defining agent behavior as natural-language workflows that can adapt to any use case and execute with precision. Since AOPs already power agents that deliver concierge experiences, we knew it could also power Duet.

How AOPs guide Duet's reasoning path

Agents need access to well-defined workflows they can flexibly draw on to accomplish their goals. AOPs are how Decagon solves this on the customer side, and agent building has the same foundational requirement.

The core processes of building an agent can be distilled to:

• Defining workflows and tools based on historical conversations
• Testing those workflows against simulated conversations
• Refining logic by stepping through a trace of the agent's reasoning
• Analyzing performance data to identify drivers of key metrics
• Diagnosing gaps in workflows and surfacing improvements

Building Duet on AOPs meant we could map each of these as its own procedure and specify when Duet should use it. Given a prompt like "analyze conversations related to payment issues and suggest updates to the agent logic," Duet determines the right AOP and follows the instructions reliably.

Taking action across Decagon’s platform

Defining workflows is only half the picture. Each of those agent-building processes also requires taking action: versioning AI logic, running tests against new workflows, filtering and analyzing conversation data, and more.

We'd already built all of this tooling into Decagon to complement AOPs. Rather than building an AI system that operates on your agent from the outside, we could build one that lives inside the platform, fully aware of your context and with direct access to every lever needed to drive performance. The architecture made itself obvious.

Giving every team visibility into Duet's behavior

There was one more reason to build on AOPs, and it had nothing to do with infrastructure. Some of the people best positioned to shape Duet were on non-engineering teams who understood the agent development process deeply from working on enterprise deployments every day.

Requiring engineering involvement to trace Duet's logic would have created a constant drag on iteration speed. We'd seen this dynamic play out before: when business teams have to pull in outside technical resources for every change, iteration slows and performance suffers.

Because Duet's logic lives in AOPs, anyone on the Decagon team can see exactly what it's doing and why, rather than trying to interpret the behavior of a black box.

Duet is building Duet

Duet can build and refine AOPs, and because Duet itself runs on AOPs, every capability it develops for customer agents is one it can turn on itself.

Since launch, Duet has been used to improve its own procedures, tightening the same reasoning loops it uses to improve yours. Each iteration makes the next one faster and more precise.

If that’s the kind of compounding improvement you want for your agent, we'd love to show you what Duet can do.