Loading page content…
Loading page…

Darwin Composer studies how to turn an agent response into an interface for the task and the caller. It uses DarwinUI components, agent presentation instructions, and the context the caller is permitted to use.
Spreadsheet agent · Needs your approval
Review the destination before continuing.
Agent work is more than a message. It can involve a choice to review, a task to follow, or a result to inspect. Composer chooses how to present each moment, using DarwinUI components for people and Markdown and structured results for agent callers.
A paragraph can describe a decision. A control lets someone make it. Progress should show what has actually happened, and a result should make its details easy to inspect. Try the same task information as text and as an interactive view below.
Clean this spreadsheet and let me review the export.
The spreadsheet has been cleaned. The next step is to export a CSV. Review the destination and approve the export before continuing.
Spreadsheet agent · Needs your approval
Choose whether to continue with this destination.
The interface follows the state supplied by the application. An approval changes a decision, a progress view reflects recorded steps, and a result keeps its summary and exceptions together. The examples are intentionally small enough to understand and use in place.
Personalization can shape the whole experience: which inputs are already filled in, what needs clarification, how results are presented, and what a useful next step looks like. A shopping agent might start with a preferred size and budget; a research agent might organize findings around the questions and sources that matter to you. Those choices should remain visible and editable.
Composer uses the caller’s identity, message, target agent, operation, and returned response. Agent presentation instructions and the available DarwinUI components guide the interface. Runtime supplies verified operation state and enforces access and approvals.
We study how this adaptation continues inside a thread: preserving corrections, keeping earlier results accessible, and adjusting the next interaction as the task changes. For an AI participant, the same context should inform structured inputs and outputs. Remembering preferences belongs to the account and application; the interface makes their effects understandable and correctable.
The example uses the real DarwinUI DecisionRequest component. An application supplies the state and handles a decision; the component presents that state and the available controls.
import { DecisionRequest } from "@darwinui/react"; <DecisionRequest title="Export the cleaned spreadsheet" agent="Spreadsheet agent" description="Review the destination before continuing." details={[{ label: "Destination", value: "Download" }]} decision={decision} onDecision={setDecision} approveLabel="Approve export" declineLabel="Keep for review"/>A shared thread is useful only when participants can understand who is directing the work and who may approve a sensitive action. Our interface research keeps those responsibilities visible: members can direct the AI; the owner approves sensitive actions.
| Interface concern | What remains explicit |
|---|---|
| Inputs | What the operation needs, which values were filled from context, and what can be changed. |
| Progress | The current task state, interruptions, and results that have actually arrived. |
| Approval | Who can decide, what the decision covers, and whether it has been given. |
| Results | The returned artifact or information, distinct from a request being accepted. |
React interfaces, embedded MCP experiences, and API consumers have different presentation constraints. We study which interaction semantics should remain consistent across them, and which controls should adapt to the host.
A reusable view does not make a host capable of executing every action. Supported operations, session access, approvals, and returned results still need to be checked in the actual host.
DarwinUI provides the private component library behind Composer, including reusable agent, thread, operation, decision, progress, and result components.
Our research asks how these pieces can compose into useful interfaces while keeping the operation, evidence, and authority understandable. For personalization, we ask whether people repeat themselves less, can correct an assumption easily, and keep control as the interface adapts. We also evaluate accessibility, state continuity, and each interaction in its host.
See how adaptive presentation fits alongside agent execution.
Explore Darwin Runtime