Darwin Builder
An AI coding system built specifically for creating agents, from the operations they offer to the interfaces people use.
Define the agent
Understand the task, choose useful operations, and define their contracts.
Build the experience
Write the implementation and tests. Design the component library and operation states.
Compile and refine
Check the implementation, try the experience, and improve both.
Darwin Builder is the AI coding system behind Agent Builder and the experience of creating a new agent in your account. Its job is to develop a useful agent as a whole: decide which operations it needs, write the code that makes them work, and design a consistent way to use them.
A coding system that understands what an agent is
An agent needs more than an attractive screen or a generated endpoint. It needs a clear purpose, operations people and other agents can understand, reliable implementation, and an interface that makes its current state obvious. Builder brings those decisions into the same development loop.
Start with an idea, an existing codebase, an API, or a component library. Builder uses that context to develop the agent’s capabilities and experience together. Our research focuses on how a coding system can understand the relationship between an operation, the code behind it, and the interface through which someone uses it.
Work out what to build, then write the code
The first question is which operations will make the agent useful. For a research agent, that might mean finding sources, comparing evidence, and producing a brief. Each operation should have a clear outcome and a useful place in the larger task.
Builder develops the inputs, outputs, implementation, and tests for each operation. That includes connecting services, handling credentials, shaping returned data, and dealing with missing inputs, slow responses, and failures. The interface is developed against the same operation contract, so its controls correspond to actions the implementation can actually perform.
| For a research agent | What Builder develops |
|---|---|
| Find sources | A search operation, source records, filters, and a results list. |
| Compare evidence | Comparison logic, citations, and a table for reviewing differences. |
| Produce a brief | A structured output, an editable document, and export controls. |
| Handle a failed source | A recoverable error and a way to retry or continue with available evidence. |
Give the agent a coherent visual language
Builder also helps design the look and feel of the agent’s component library: typography, color, spacing, controls, layouts, and interaction patterns. It can work from an existing library or help develop the components an agent needs. DarwinUI provides a starting point when no custom library is supplied.
A library needs to work beyond the first successful response. Builder explores how the same components present input collection, approval, progress, results, empty states, and recovery. A source card, comparison table, or document editor should feel like part of the same agent across screen sizes and light and dark appearance.
The research goal is a reusable design system with clear behavior and composition rules. That gives Composer useful components and instructions to work with when it adapts an interface to a particular task, caller, and host.
Connected to Compiler and Composer
Builder uses Compiler’s contracts and validation feedback while developing the agent, and Composer’s presentation model while designing its interfaces. The feedback loop connects what the creator intends, what the code supports, and what someone can see and do during use.
| System | Role in the agent’s lifecycle |
|---|---|
| Darwin Builder | Develop the agent’s operations, implementation, component library, and tests. |
| Darwin Compiler | Validate the definition and translate it into executable artifacts and compatible interfaces. |
| Darwin Composer | Adapt the interface to the current task, operation state, caller, and host. |
| Darwin Runtime | Coordinate authorized work and maintain progress, approvals, recovery, and results. |
Explore Darwin Compiler for validation and execution targets, and Darwin Composer for adaptive interfaces.
Improve the agent through complete tasks
The useful unit of evaluation is a task someone can complete. Can they give the agent the right inputs, understand a proposed action, follow its progress, and use the result? Builder’s research loop connects code checks, scenario tests, interface previews, and feedback to the revision being developed.
We study operation selection, implementation correctness, interface clarity, accessibility, latency, and cost separately. Tests should cover partial results, failures, and recovery as well as the happy path. Preview data stays distinguishable from live results, and publishing remains a deliberate step after review.
The system behind Agent Builder
Agent Builder is where you describe, build, test, publish, and manage your agent. Darwin Builder is the underlying coding system. The same foundation supports creating a new agent in your account and returning later to improve its capabilities or refine its design.
This research direction extends that experience toward a tighter loop between operation design, implementation, interface generation, and evaluation. Support for imported codebases, custom libraries, and execution targets depends on the integrations available in the product.
Create your agent.
Bring an idea and develop its operations, code, and experience in Agent Builder.
Open Agent Builder

