From an Order to a Verified Repair

01 · Separation of responsibilities

Agents decide. Tools enforce and act.

Each agent uses the framework’s ordinary orchestration harness. Its model chooses a plan from discovered capabilities and receives results before deciding what comes next. Tools implement bounded operations; they do not choose the investigation’s next stage.

02 · Reproduce the environment, not just the prompt

Configuration supplies authority and scope.

Where this ran: Kind is a Kubernetes cluster running locally in containers. Kubernetes kept the service, agents and tools running as separate processes in containers called pods. The solution lived in the software-maintenance namespace (a named grouping of resources); the retail service and shared infrastructure lived in truvag3-examples. The model calls left the cluster through OpenRouter, the API gateway routing them to the selected AI models. The models did not run inside these pods.

cd examples/software-maintenance
./setup.sh help
cp .env.example .env    # only if .env does not already exist
# Fill local credentials and owner-approved profiles; keep collection disabled.
# For a cold start only: ./setup.sh full-deploy evidence
# With Kind and shared infrastructure already available:
for component in evidence assessment source workspace publication repair review coordinator; do
  MAINTENANCE_FRAMEWORK_SOURCE=workspace ./setup.sh rebuild "$component"
done
./setup.sh skills-sync
./setup.sh skills-check
./setup.sh preflight

Namespace: software-maintenance. Shared infrastructure: truvag3-examples. Image identities and build logs are preserved in the evidence bundle. At capture end, collection was disabled again to prevent unbounded paid investigations.

03 · The trigger was service traffic

A timer does the polling.
The model does the investigation.

The external test driver sent an authenticated POST /orders, just as a client would. The service saved the accepted order and exposed an observation: a record of that request’s behavior, including its final total and an identifier for the saved order. This is business evidence, not an LLM-generated memory summary.

The coordinator’s scheduled collector ran once a minute, read the service’s observation feed through the evidence tool, and applied the configured sampling and admission limits. Admission means accepting an observation for investigation. It created a case (the application’s investigation record) and queued a task (the worker’s unit of work). A worker then started the coordinator’s orchestration execution. No human supplied a diagnosis to that execution.

{
  "order_id": "auto-20261008T201934.393464000Z",
  "sku": "COFFEE-250",
  "quantity": 5,
  "promotion_code": "WELCOME100"
}

04 · Capabilities are discovered; guidance is bound

A new tool can appear without
rewriting the agent’s workflow.

A capability is a named operation with declared inputs and outputs, such as reading a file or starting verification. Agents and tools register these operations in the shared registry. A skill is written guidance: how to compare evidence, handle uncertainty and report an outcome. The framework inserts the applicable skill text and available capability descriptions into model prompts; neither is a fixed list of steps the agent must execute.

The registry tells the harness what capabilities are available now. Skill packages tell a role how to handle evidence and uncertainty. They are different inputs: publishing a skill does not automatically bind it to every agent, and discovering a tool does not require calling it.

The catalog also contained unrelated capabilities. The planner did not use travel, weather or OpenClaw to repair this order service. Broad discovery demonstrated interoperability here, but the large prompts also show its cost; this run is not a benchmark of minimal context.

05 · Open the model envelope

See how context became a decision.

A prompt is the input sent to a model: role instructions, the admitted case, available operations, selected skill text, historical context and—in later phases—earlier tool results. A model response can be a plan or a final answer. Tool responses are separate: they contain the files, order records and test evidence that the next model call can use. The model does not independently browse GitHub; its planned source-tool calls fetch that material.

The input/output counts below are tokens, the model’s units of text processing, not file bytes. Token budgets are ceilings on generation; they are not a request to write that much. KiB in the budget table means 1,024 bytes. The generous settings describe this diagnostic setup, not a minimum resource requirement.

The excerpts below come from the captured debug records. Select one to see the actual input or output, its role in the run, and its JSON location. They are not rewritten “ideal prompts” or hidden model reasoning.

Loading…

06 · Follow the real execution

One parent. Two delegated executions.
A decision after each phase.

The planner is a model call that proposes a JSON plan. The framework’s executor validates it, supplies earlier results to dependent steps and calls the chosen agents or tools. One cycle of planning and execution is a phase; a step is one operation within it. Ready, independent steps can run together. Synthesis is the final model call that turns accumulated evidence into the agent’s result. The orchestration harness is the framework code managing this cycle, budgets, validation and recording.

The actual Registry Viewer screens

Captured directly from the local Registry Viewer on October 8, 2026, after this run completed. These are unedited browser screenshots of the stored executions—not reconstructed diagrams. The list is filtered to this coordinator and its two related executions; its 100% completion figure describes these three requests, not every execution in the cluster.

Expand each agent below. Select an image to open the original 1920 × 1440 PNG, or use the simpler Steps Only view. Full Flow shows the viewer’s current viewport, including planning phases and execution nodes; the saved JSON explorer below provides the complete records and readable step details.

1 · Coordinator — 18 steps · 6 phases · 349.97 seconds

maintenance-case-1791490824160739947

2 · Repair agent — 23 steps · 7 phases · 118.35 seconds

maintenance-repair-1791490887816459463

3 · Review agent — 17 steps · 5 phases · 70.90 seconds

maintenance-review-1791491023774372615

“Completed” is a request-lifecycle status, not proof of production resolution. The candidate, verification and publication receipts establish the draft-PR outcome. Screenshots complement those records; they are not independently signed attestations. Capture provenance and SHA-256 hashes.

Expand a step to inspect the instruction, planned dependencies, actual parameters, dispatch attempts and response. The terminal phase has no executable steps; it is still a recorded planner decision. These views are generated from preserved execution JSON, not manually reconstructed records.

07 · Model confidence is not the acceptance test

Make the failure reproducible.
Make the fix independently checkable.

A candidate is a proposed set of file changes, not yet a GitHub commit or a deployed fix. In repair step-17, the model supplied the full replacement text for checkout.go and a new file, promotion_once_regression_test.go, to stage_candidate. The tool checked the original file’s fingerprint, accepted the exact text and returned a candidate ID. It made two copies of the baseline: one with only the new test, and another with both the test and the production-code change.

A regression test encodes the behavior we want to preserve: this order should save a 4,900-cent total and only one write. Running that same new test against old and proposed code distinguishes “a test that happens to pass” from “a test that detects this defect and then passes with the fix.” The repair model wrote the test; the Go runtime, not another model, executed it.

persisted once-per-order ledger: got {Total:4500 Writes:1} want total=4900 writes=1

// Before: the discount is multiplied by quantity.
unitTotal := receipt.UnitPrice - receipt.Discount
return ledger{Total: unitTotal * receipt.Quantity, Writes: 1}

// After: subtract it once from the subtotal.
subtotal := receipt.UnitPrice * receipt.Quantity
return ledger{Total: subtotal - receipt.Discount, Writes: 1}

PR #15 — Apply WELCOME100 once to the order subtotal contains only checkout.go and the new regression test. Its body distinguishes evidence, provenance, existing work and limitations. The publication capability does not grant merge or deployment authority.

The serving source commit and the pinned contract commit are intentionally different. The source identifies the code actually under investigation; the contract supplies the owner-approved expected behavior. Both identities are recorded. Build provenance is service-reported, not signed attestation.

08 · Success did not mean every HTTP attempt succeeded

Two conflicts. Same references.
Successful bounded retries.

WORKSPACE_EVIDENCE_CHANGED means “the saved job/verification records changed while I was checking them; read the same IDs again.” It does not mean the candidate’s source code changed, the test was rerun, or the model wrote a bad fix. The workspace tool compares record versions before saving a combined verification view so it does not overwrite newer evidence with an older view.

The repair plan read all three jobs concurrently. Job observations also refresh their shared verification record. Two calls encountered this version check and returned HTTP 503 (a temporary service error) with retryable:true. The executor made a second HTTP attempt with the same case and job IDs; both succeeded. This was a retry of reading status, not of running the tests or asking the planner to invent different parameters. The trace does not identify every racing writer; the error and the two recorded dispatch attempts establish the conflict and recovery.

Jaeger contains four error-tagged spans for these two failed attempts: a client and server span for each. Four spans do not mean four failed steps. All 58 steps finished successfully.

09 · Three kinds of state, three different jobs

Memory is context.
A receipt is evidence.

A hook is framework code that runs at a defined point around planning or execution—for example, loading history before planning or recording events afterward. Episodic memory stores summaries of earlier actions, tagged with their originating request. A domain is the shared grouping here named software-maintenance. An assessment is different: an application-owned decision record with the facts and a deadline for checking them again. The second run recalled memory but could not reuse the expired assessment as current authority.

Live activity has a TTL, or time-to-live: an expiry that is renewed while work is running so abandoned activity does not remain visible forever. These concepts describe separate records; the business order, an agent’s remembered summary and a verification receipt are not interchangeable.

The first run proves memory recording and attribution, not successful historical recall or duplicate avoidance caused by memory. The initial read returned zero events. Related assessments came through a separate tool; they were expired/ineligible and history coverage was truncated. Current PR inspection—not remembered conclusions—established that open work did not address this defect.

10 · Explainability is emitted, not painted on afterward

Trace a decision all the way
to its side effect.

Telemetry is the execution data the components emit: recorded plans, model calls, step results, timing and logs. A trace connects related operations across services; each timed operation is a span. Its trace ID lets you follow a coordinator call into a tool or delegated agent. Jaeger displays spans, Loki stores log messages, and Registry Viewer displays framework execution records. The screenshots are views of those records; the downloadable JSON contains the underlying detail.

“DAG” means directed acyclic graph: a diagram of steps and their dependencies. A downstream step waits for the earlier outputs it needs. In the Viewer’s Full Flow view, planning and hook nodes appear alongside tool steps, so the node count is not the tool-step count.

Model usage: inspect all 43 calls

Planning ran on openai/gpt-6.1-sol, auxiliary calls on openai/gpt-6-luna, and synthesis on deepseek/deepseek-v4.1-flash, all through OpenRouter. Total reported usage: 1,138,715 input + 29,043 output tokens. Repeated context is counted again per call; these are not unique-document tokens or a dollar-cost estimate.

Choose a call, then load it.

Jaeger trace: 762 captured spans

Trace ID: 96d6e8f893e567f2932538c400475058

This is a derived explorer over the actual Jaeger export, not a Jaeger screenshot. Filter by service or the error tag, then open a span for IDs, parent references, tags and logs. Widths show duration on the shared trace timeline.

Download the original-shape Jaeger JSON export (sanitized)

{namespace=~"software-maintenance|truvag3-examples"}
  |= "96d6e8f893e567f2932538c400475058"

11 · A second real run · October 8, 21:52–21:54 UTC

The same defect arrived again.
No duplicate PR was opened.

We left draft PR #15 open, changed neither its code nor the planning model, and sent one new ordinary order: COFFEE-250, quantity 5, promotion WELCOME100. A fresh finite admission run let the scheduler collect this new observation. No one called the investigation endpoint or told the agent which PR to choose.

The distinction that matters: duplicate avoidance passed in this run. Structured existing_remediation linkage did not. The prior assessment expired at 21:26:14 UTC; the fresh lookup at 21:53:45 UTC returned assessment_expired. This run neither refreshed that assessment nor issued a new one. It did not claim the order was fixed, or that the PR was merged or deployed.

Actual Registry Viewer capture · one coordinator, no delegated repair or review

Decoding that caveat: result distillation asks an auxiliary model to shorten a large tool response before final synthesis. finish_reason:length means the provider stopped generation at a length limit; stop means it ended normally. Here the shortened text was cut off, despite the trace flag saying no content was lost. That is why the full original tool response is retained beside the model’s summaries. OpenClaw is another registered tool in this shared cluster, not a repair component used in either run.

Reported usage: 203,656 input + 10,540 output tokens, across 3 Sol planning calls, 8 Luna auxiliary calls and 1 DeepSeek synthesis call. No dollar-cost estimate is inferred.

12 · Keep the proof with the story

What this demonstrates.
What it leaves open.

The comparison below describes the first run. The second run adds historical recall and one no-duplicate outcome, with a blocked case. It does not establish universal duplicate prevention or the stronger structured-link path.

Adapt the solution without tailoring the harness

Downloadable execution proof

The first bundle contains 43 allowlisted source captures plus a derived tutorial dataset and SHA-256 manifest; its six Viewer screenshots have a separate manifest. The repeat run has its own bundle. Exported records replace local user paths, personalized cluster labels, private IP addresses and recognizable credential values. Each source capture records its source hash and exported hash; sanitized files are not claimed to be byte-identical originals.

13 · Questions about these runs, answered

Follow the explanation.
Then check the original record.

This is an evidence map for the setup and executions described above, not a list of requirements for a different system. The links open saved files; they do not contact a model or trigger work. In execution JSON, look under result.steps for the named step_id. Step numbers are local to each agent execution: repair step 1 is different from coordinator step 1. Its parameters show the actual inputs; response contains the tool’s JSON reply. Model prompts and answers are under interactions in debug JSON.

The demonstrated finish lines are a tested, reviewed draft PR in the first run and no duplicate PR in the repeat. Neither run merged or deployed the fix, repaired an already-saved order, or proved that every future duplicate will be prevented.