Ten forward-looking artifacts specified across three issues and six cycles. None of them built. Issue #10 said it plainly: the unbuilt artifact is the single largest constraint on your AI-native positioning. Your verbal story keeps running ahead of the evidence that's supposed to carry it.
The reason none of them shipped is that the domain separation generating them was wrong.
Inference-Aware UX, Intent-Based Interaction, Agent Infrastructure as UX, Human-Agent System Design. These are useful analytical categories. They are not how a person experiences handing off a task. When a broker delegates a consequential insurance action to an agent, intent-setting, infrastructure visibility, inference tradeoffs, and human-agent coordination all happen at once, in one interface, on one screen. Splitting them into four artifact tracks produced specs that were each too narrow to anchor a portfolio piece and too numerous to build in parallel.
One artifact ships instead. Working title: The Delegation Contract — a specification of what an agent was permitted to do, what it actually did, what changed after the fact, and what the user is left holding. This piece is the build spec.
Backlog verdicts
Every accumulated item gets a ruling. Absorbed items map to a named element of the Delegation Contract. Deferred items carry a trigger.
Absorb:
- Correction Lineage (Issue #8) → the correction-to-next-run chain
- Confidence/Authority Matrix (Issue #9) → the authority envelope
- Three-Phase Revocation (Issue #9) → the compensation sequence
- Contract-Variance Disclosure (Issue #9) → commitment-boundary states
- Commitment Envelope (Issue #10) → absorbed directly; it was already converging here
- Contract-Variance State Diagram (Issue #10) → visual states of variance between authorized and actual terms
Kill:
- Obligation-Transfer Mental Model — too abstract to generate visual decisions; the compensation residue section covers the concrete version
- Attention-Load Analysis — an analytical tool, not a portfolio artifact; the attention problem surfaces through the Contract's departure and re-entry states
Defer:
- Safe Departure and Bounded Re-Entry — trigger: a second Agentic Labs app ships with a consequential action gate (right now only CarrierIQ has Approve Bind)
- Inference Conflict Surface — trigger: inference cost becomes a user-facing decision in a shipped app (none of the three currently expose it)
The scenario
A commercial insurance broker uses CarrierIQ to quote auto fleet coverage across five carriers. Agents execute in parallel through the Session → Navigate → Fill → Extract → Verify sequence. Four carriers return bindable quotes. One returns a referral. The broker reviews coverage deltas between what was requested and what each carrier returned, checks carrier trust signals, writes an operator note, and approves a bind with Carrier A.
The bind request reaches the carrier's portal. The carrier's system accepts it but modifies the collision deductible from $1,000 to $2,500. The broker's client expects coverage effective Monday. That Monday was Labor Day. The underwriting desk was closed through the weekend, and the modified terms landed Tuesday morning with the policy start date already behind them.
So the broker is holding a bind request sitting in the carrier's system under terms nobody authorized, a client who believes coverage is in force, and a gap between what was approved and what was committed.
That scenario crosses all four of the old domain categories without being forced into them. Intent-setting: the broker specified coverage requirements and carrier selection. Infrastructure visibility: five agents ran in parallel, each at a different stage. Human-agent coordination: the broker approved, and then the ground moved. And the deductible change is an inference-cost problem in different form: a deeper verification pass on Carrier A's conditional-acceptance patterns might have flagged the modification risk before submission, at the cost of time and processing.
Where Watch → Verify → Delegate breaks
The Design Context File v5 already rejected the linear reading of the Trust essay and reframed Watch → Verify → Delegate as a supervisory posture scoped to a specific delegation rather than a journey the user travels once. The Delegation Contract makes that correction visual, then extends it.
At the moment the broker approves the bind, three trust postures are live at the same time toward the same task:
- Delegate toward the quoting process. It ran. Results came back. The broker accepted the output.
- Verify toward the coverage terms. The broker is actively reading deltas between requested and returned coverage.
- Watch toward a re-verification running on Carrier A's trust signals.
A single trust scalar can't represent that state. The artifact needs per-aspect trust indicators, each facet of a delegated task carrying its own supervisory posture.
Then the carrier modifies the deductible. Trust in the bind process drops from Delegate back to Verify. Trust in the quoting process doesn't move. Regression is per-aspect, and the artifact has to show it without implying the whole delegation collapsed. Regression is a normal operating condition. The visual treatment should read as "this aspect needs you" rather than "the system broke."
Production foundations
Each Agentic Labs application contributes a specific visual starting point. The spec names the foundation and then shows where it extends past anything shipped.
CarrierIQ gives you the most complete one: structured intake, the five-stage parallel execution sequence, then the review drawer with coverage detail, coverage deltas, carrier trust signals, case file checklist, operator note, carrier verification panel (Watch live, Verify this carrier, Re-run verification), and the gated Approve Bind action that stays disabled until completion conditions are met.
That already separates requested inputs, machine execution, returned evidence, review classification, supplemental verification, and final human authorization. What it doesn't show is anything after Approve Bind. Frontier extension: commitment states on each carrier row (proposed / staged / authorized / externally committed / settled / variance detected), a compensation sequence for terms that change post-commitment, and a residual-obligations view showing what stays active after a cancellation. Issue #9 proposed adding commitment states to carrier rows. This executes that proposal and carries it through settlement.
Brand Pulse gives you source-labeled evidence cards with verbatim excerpts, sentiment and theme classifications, and a Sentiment & Sources panel showing each source agent's contribution to the aggregate. It establishes which source produced a claim and how much each platform contributed. It does not establish whether a source is reliable or whether anything corroborated it independently — contribution without credibility.
Frontier extension: the verifier-independence layer borrows Brand Pulse's attribution model and adds a reliability dimension. When the artifact displays a verification result, the viewer should see whether the verifier used independent evidence or worked from the same data the acting agent produced. This comes out of a recurring pattern in TinyFish agent traces. An agent extracts data from three sources, then verifies by re-reading those same three sources. The trace looks thorough — three verification passes, all clean. If the relevant information lived on a fourth source the agent never touched, every pass confirms the same hole. Independent verification means checking against something the acting agent didn't consult, and the trace has to make that visible.
Retail Velocity gives you the ranked account table with confidence badges (high, medium, low), opportunity classification, evidence snippets, and an agent log. Its contribution is narrower than the other two. The confidence badge becomes the model for the authority envelope's per-element confidence indicator, inspectable down to the supporting evidence rather than presented as a global score, and the account-level agent log extends into the execution trace. But Retail Velocity has no consequential external action anywhere in it, so its contribution to the commitment-boundary work is structural — how to display ranked, inspectable synthesis — not procedural.
Visual structure
The Delegation Contract is a multi-state interaction specification: a connected sequence of annotated states showing how authority, visibility, and commitment change as a delegated task unfolds. Production-fidelity states with explicit transitions and decision annotations, not a hero screen.
State inventory:
-
Authority Envelope. The opening state. What the agent may do at this phase, with boundaries drawn explicitly. Carries forward the confidence/authority separation from Issue #9: an agent can hold high confidence in a recommendation and low authority to act on it, or the reverse. The envelope is visible to the user, not merely enforced by the system. That's a deliberate departure from Meta's Muse approval card, which shows the proposed transaction with binary Deny/Allow controls but never displays grant scope, duration, or reversibility class, even though Meta's Sentinel system supports one-time, session-scoped, task-scoped, time-bounded, and perpetual grants internally. The Delegation Contract surfaces those distinctions in the authorization moment itself.
-
Commitment Sequence. Six states. Proposed (agent recommends), Staged (user reviews, nothing external has happened), Authorized (user approves, system prepares to act), Committed (external action dispatched, the bind request reaches the carrier), Settled (carrier confirms or modifies), Compensating (terms changed or cancellation requested after commitment). The visual distinction that matters most is between Authorized and Committed. Before Committed, stopping is free. After Committed, stopping leaves residue. Issue #9's formulation still holds: "The system does not return to 'before the run.' It returns to a state that acknowledges partial execution."
No shipped product has this sequence in complete form. Amazon's Buy for Me separates order review from agent execution but routes cancellation and returns back to the merchant. Google's Agentic Checkout adds a price invariant and likewise hands recovery to the merchant. Microsoft Copilot Tasks lets a user stop a running task but documents nothing about already-dispatched external effects. You are establishing a convention here, and that's the positioning claim the artifact makes.
-
Per-Aspect Trust Indicators. Attached to each facet of the delegated task rather than to the task as a whole. In the insurance scenario: quoting (Delegate), terms review (Verify), carrier trust-signal check (Watch), bind execution (moving from Authorized to Committed to possibly Compensating). These update independently. When the carrier modifies the deductible, the bind-execution indicator regresses and the quoting indicator sits still.
-
Compensation Residue. The post-cancellation state. A visible inventory of what completed and can't be reversed (the bind request exists in the carrier's system), what is being unwound (the payment authorization), and what needs a human outside the system (a call to the underwriting desk, which is shut for the holiday until Tuesday). This is where the Saga pattern's compensating-transaction model arrives in interaction design: compensation produces an acceptable new state, not the prior one. The artifact shows that difference rather than papering over it.
-
Execution Trace with Authority Indexing. Adapts MUSE's five-level semantic representation — stage title, summary, substeps, detailed actions, raw traces — but indexes the levels to authority instead of comprehension. When the broker opens the bind-execution step after the deductible modification, the index determines what they find. At "what you can see": the request was submitted, the carrier responded with modified terms. At "what you can question": why wasn't Carrier A's conditional-acceptance pattern flagged before submission? At "what you can stop": nothing, the request already landed. At "what you can reverse": the deductible change can be disputed, but the request's existence can't be erased. MUSE showed that semantic representations should be actionable — drag a step into chat, invoke Revise, request verification. The Delegation Contract keeps that principle and reorients it, so a user at the "what you can stop" level sees different controls than one at "what you can see," looking at the same execution step.
-
Correction-to-Next-Run Chain. The temporal evidence element. The broker rejects the modified deductible and flags Carrier A's conditional-acceptance pattern as something the system should catch pre-submission. Two weeks later a different client's fleet quote runs through the same five carriers, and Carrier A's row carries a pre-bind flag: this carrier modified deductible terms on two of three prior binds. Both ends of the pair are visible in the artifact, the September correction and the October run where the flag appeared. That's the correction lineage from Issue #8 made concrete: receipt of the correction, incorporation into changed behavior, verified improvement on a comparable later run, all inspectable.
Key design decisions
These are the judgment calls the artifact has to illustrate. They're where your taste is legible.
Show the mess. Compensation residue is ugly, and most products hide it by routing recovery to the merchant or to the user's own phone calls. Show it. A user can't assess their actual situation without seeing what's still active, what's being unwound, and what's waiting on them.
Make authority boundaries visible, not just enforced. A user should see the envelope of what the agent can do rather than discovering its limits by running into them. Sentinel enforces scope internally. The Delegation Contract puts it on screen.
Separate confidence from authority in every visual element. The agent's confidence in a recommendation and its authority to act on that recommendation are independent. High confidence with low authority: the agent is sure and needs permission. Low confidence with high authority: the agent has permission and isn't sure. That second quadrant is the dangerous one, and the artifact should make it visually prominent enough that a reviewer asks about it.
Treat verification independence as a visible property. When a verification result appears, the viewer should be able to tell whether it came from an independent check or from the acting agent reviewing its own work. In TinyFish production, an agent verified its own carrier-data extraction by re-querying the same portal and returned consistent results across three cycles. All three were wrong. The portal's cached page hadn't updated, and the error only surfaced when a human pulled the carrier's separate rate-filing database. Self-verification catches a different class of error than independent verification, and an interface that conflates them misleads the user about how strong the evidence actually is.
What the artifact resolves
Five problems the domain-separated backlog couldn't address individually.
The commitment-and-settlement sequence fills the territory after Approve Bind, where no shipped product tells the user what happened, what changed, and what's left. CarrierIQ already builds the first half; this completes it.
Per-aspect trust indicators replace the scalar model that couldn't represent the broker holding Delegate, Verify, and Watch simultaneously toward different facets of one task. The scenario generates that correction on its own, which is the argument for it — you don't have to assert that the linear model fails, the walkthrough shows it failing.
Verification independence becomes an inspectable property of every result, grounded in a specific failure pattern rather than a principle.
The four domain categories collapse into one interaction surface, and the spec proves the collapse holds by running a single scenario through all of them without visible joins.
The correction-to-next-run chain closes the temporal evidence gap — the form of proof AI-native credibility specifically demands: whether a correction changed what the system does next.
The backlog is cleared. Build it this weekend, while the scenario is still loaded in your head.
- Anthropic's independent review: METR's investigation of the four unauthorized-access incidents — including the case where a monitoring model accepted the acting model's biased reasoning — was still pending at research cutoff and will directly test the verifier-independence problem the Delegation Contract treats as a design variable.
- OpenAI's Identity role: The Product Designer, Identity posting covers human-to-agent authorization, agent-to-agent identity, permissions, governance, and remediation at $245K–$310K plus equity — the closest live role description to the Delegation Contract's scope.
- Agents API cancellation gaps: OpenAI's session documentation lets developers cancel an active turn while retaining the session, but does not document reversal of external effects already dispatched before cancellation — the exact boundary the commitment sequence is designed to make visible.
- Muse's approval architecture in practice: Meta's Sentinel system documents five grant types and scoped capabilities, but no independent usability evaluation has yet established how often users approve reflexively or whether the checkout card's binary controls adequately represent the underlying scope distinctions.