Multi-Agent Engineering System

The delivery loop

The core is a workflow contract: agents hand each other structured, schema-validated artifacts — never chat.

Developer

Implements one precisely-scoped task. Reports MISSING_PREREQ instead of improvising around a missing dependency.

→

Reviewer

Independent agent, refute-by-default: re-runs every piece of evidence itself. Verdict is a schema-validated APPROVED / REJECTED with findings.

→

Instructor

After two failed rounds, diagnoses the root cause and either rewrites the task for another cycle — or parks it with a question a human can answer in one message.

Rules that make it safe to run unattended

Durable resume: a run-state ledger (one row per task: id, status, evidence pointer) is committed at launch. A killed terminal or usage-limit stop costs only the in-flight task's uncommitted minutes; any fresh invocation continues from the ledger.
Parked ≠ blocked: a parked task accumulates a question for the morning; it never stalls the rest of the batch.
Singleton resources serialized: tasks that drive Sierra Chart (one live instance) run one-at-a-time; everything else parallelizes.
Workspace snapshots: a clean committed tree before every unattended run makes all agent work diffable afterward.
Overnight self-continuation: launching a batch also registers its own continuation — a scheduled job (local task scheduler or cloud routine) fires a fresh "continue from the ledger" invocation every couple of hours, skips while the run is clearly active, and removes itself when every task is done or parked. Usage-limit stops, closed terminals and reboots cost only the in-flight task's minutes.
Morning report: each run ends with a committed report file plus the parked questions — review over coffee, answer in one message each, relaunch.

Cost discipline

Per-task model tiers — light | standard | critical — with the operating rule "economize on generation, never on the gate."
Template repeats of a proven pattern run on cheap tiers with narrow-checklist reviews (re-run the test, check the artifact); heavy models are reserved for genuinely novel work.
Related work is batched into one task per family — per-task agent onboarding is the dominant overhead of large programs.
An adaptive brake: on abnormal burn, stop launching and invoke the planner in procedure-review mode to restructure the program.

The workflow contract (excerpt)

.claude/workflows/dev_review.js

export const meta = {
  name: 'dev-review',
  description: 'Developer → independent-reviewer task runner; instructor escalation after 2 failed rounds; sierra tasks serialized',
  phases: [
    { title: 'Develop',  detail: 'feature-developer implements; reports MISSING_PREREQ instead of improvising' },
    { title: 'Review',   detail: 'feature-reviewer re-runs evidence, refute-by-default' },
    { title: 'Instruct', detail: 'task-instructor rewrites the task or parks it after 2 failed rounds' },
  ],
}
const REV_SCHEMA = {
  type: 'object', required: ['verdict'],
  properties: { verdict: { enum: ['APPROVED', 'REJECTED'] },
                findings: { type: 'array', items: { type: 'string' } } },
}

The reviewer cannot return prose — only a verdict that validates against the schema. A rejection carries findings the developer must address; approval means the reviewer reproduced the evidence itself, not that the developer's report sounded plausible.

Evidence gates — agents must prove, not claim

The hardest part of agentic delivery is verification, and it gets harder when the target is a closed GUI application (Sierra Chart) whose message log cannot be read from outside. The answer is an instrumentation layer built specifically so agents can produce court-quality evidence.

Verification toolkit

File-based structured debug logs replace the unreadable in-app message log.
A fleet of probe studies and console tools link the production decision functions directly (pure, host-free cores) — no mocks — and feed them the literal bytes the live system would see.
A Python replay driver requests bounded chart replays and reconciles the results fill-by-fill against an append-only order journal.
A mandatory loop in the repo contract: instrument → build → drive the app → read the log → prove which DLL is actually running before believing anything.

Skills & scaffolding

A new-strategy skill scaffolds a complete C++ study from a tokenized template and registers it in the Visual Studio solution.
Six research skills (baseline, discovery, cross-validation, family rollup, stability screen, export-reconcile) encode the standard procedures so any agent runs them identically.
Agent role definitions (developer, reviewer, instructor / planner) live in the repo — versioned, reviewable, and improvable like any other code.
Infrastructure ownership is split: an infrastructure agent owns shared libraries and validation tools; strategy agents own isolated folders and cannot edit the shared layer.

What it shipped

A feature-parity campaign porting ~19 numeric kernels from Python to C++, each proven bit-identical — delivered batch by batch through the dev-review loop.
A frozen 3-model trading portfolio taken through a formal gate series — data audit, bias review, freeze report, reconciliation, precision parity, full parity run (100.00%, 0.000000 R difference), order layer, replay harness — each gate an independently reviewed task with its own defect ledger.
779 commits in two months on the research platform alone, with a log whose most common entry is a refutation: negative results written into the run ledger and turned into permanent, tested rules.
The same protocol was reused for a production LLM product delivery and generalized into an umbrella task-batch runner usable in any repo.