Last week we launched the Wonderful Agent Builder, an AI agent whose job is to build, test, and improve other agents in production. 

We didn’t start here. We originally built Agent Studio, an agent building interface that significantly streamlined the creation process, but still required technical ability. But after working with dozens of enterprises, taking 100+ agents to production, and accumulating thousands of commits, evaluations, regressions, and fixes, a few things became clear: 

First, building agents well is as much about learned production experience as it is about technical ability. It’s a mix of knowing how to write prompts and code, together with understanding how models behave in practice, where agents break under real usage, and which guardrails actually matter. You don’t learn that from theory. You learn it by building agents, taking them to production, watching them fail, and fixing them. 

Second, that learning takes a lot of time and requires actually being in production at scale - two constraints which many enterprises today cannot afford, and many AI startups lack. It also doesn’t transfer easily, living mostly in people’s heads, not documentation. That’s manageable when you’re building one or two agents, but it breaks down when you’re shipping dozens or hundreds, and when each one needs to adapt as workflows, requirements and models evolve. Hiring experienced people helps, but only up to a point. Experienced agent builders are rare, training new ones takes time you don’t have, and the work that matters most happens after go-live, not before.

And third, agent building was a perfect candidate for the kind of automation we build for enterprises every day. Our entire business is built on helping enterprises automate complex, expert-driven processes. If we were serious about agentic automation, we needed to apply it to ourselves. We already had the foundation in Agent Studio, and crucially, we had the scaled production experience to make an automated agent building tool work the way it should - not as a demo, but as something we'd actually rely on ourselves.

/

How Agent Builder Works

Agent Builder is designed to work the way you would train a human to do a complex job. When you onboard a person, you don’t start with a flowchart or rigid instructions. You give them context. You share documents, policies, examples of good and bad behavior, and recordings of real interactions. You explain goals and constraints. Then you watch how they perform, give feedback, and refine their behavior over time. Agent Builder follows the same pattern.

The process starts with intent and organizational context, not pre-specified workflows. Users provide documents, specifications, recorded calls, instructions - and describe what they want the agent to do. Agent Builder ingests this information and enters a planning phase, where it reasons over the materials, identifies gaps or contradictions, and proposes a concrete plan for how the agent should behave. 

Once the plan is approved, Agent Builder builds the first version by writing prompts and code, connecting tools, building skills, and assembling behavior based on that plan. From there, it moves into testing, generating evaluations that mirror real production scenarios. The Agent Builder runs the evals, and inspects where the agent fails, just like reviewing a trainee’s performance against real cases rather than hypothetical ones.

And because it’s an agent, it can run in an endless loop till the required level of performance is achieved. When the agent behaves incorrectly, the system turns failures into new evaluations, adjusts behavior, and reruns the tests. Any refinements or new requirements all feed back into the same loop, and as constraints change or models improve, the agent is re-evaluated and refined rather than rebuilt from scratch.

Humans stay involved where judgment matters. Instead of wiring prompts or debugging logic, they review plans, clarify intent, and give feedback, the same way a manager would guide a human employee.

What This Enables 

For technical teams, Agent Builder increases leverage. Engineers describe what they want to build, review plans, and focus on higher-value decisions instead of trying to pre-specify every path, action and exception in advance.

Over time, as core skills and integrations are in place, the same interface also allows non-technical teams to participate more directly - improving existing agents, refining behavior, and eventually building new ones through guided interaction instead of code.

Agent Builder doesn’t remove the learning curve. It front-loads it. It takes experience that would normally take months to accumulate, and encodes it into the system to make it available immediately to both technical and non-technical users. 

The result is a different kind of scalability. Not just more agents, but better ones. Not just faster deployment, but more robust behavior in production. And not just technical efficiency, but organizational leverage - where the people closest to the work can shape how AI operates, without becoming engineers first.

This matters because - as we’ve argued elsewhere - the constraint on AI adoption isn't technology anymore - it's implementation expertise. Most enterprises know what problems they want to solve. They just don't have the specialized teams or the runway to learn by trial and error in production. Agent Builder changes that equation, making sophisticated agent development accessible without requiring rare expertise or extended timelines.