The quantitative scorecard
The Agentic-Readiness Scorecard is an opinion. This is the instrument that turns it into a number. Every agent and tool emits a small event as it works; a stdlib aggregator rolls them into the handful of metrics that name the real blocker — so "get better quickly" stops being a feeling. Below is the pipeline measured against one bar: a complete design — validated in simulation, backed by full program management — in a day.
The baseline to beat
These measure the engineering solution only — reliability, simulation, RFLP, electrical, FPGA, software, mechanical, program, BOM, verification, standards, proposal. Building this site to document it is meta-work and is excluded from the numbers.
agent-active build of the engineering solution across 13 deliverables — not a day yet, but every tool action was autonomous
direction, not operation — no human ever ran a tool
under one prompt per deliverable — the engineering itself was largely self-directed
up from 40% — flight-verification and native V&V are now machine-checked
~0.5 per deliverable — the thread kept catching real conflicts (mass, as-built, v2→v3)
concentrated where it was cheap: headless. GUIs got 2–4.
Where the day goes
Agent-active hours per domain (includes seam time). The engineering is spread — no single domain dominates — which is exactly why the connective tissue, not any one tool, decides the total.
The autonomy signal
This is the metric that matters most. Touch time was small (~62 min); touch count is the truth: the agent needed a human to direct the engineering 12 times. Only approve should survive an agentic program layer — every prompt and unblock is work the WBS orchestrator has to absorb.
Design is a loop
Where the tool was headless and fast, the agent iterated freely (Performance: 9 loops — demo → purpose-built → native submodel → re-flown at as-built mass). Where it was a GUI, it got 2–4. Iteration count tracks exactly with which tools can sit inside the loop.
The trust tax
Every escape is a place automated cross-domain verification was missing. These are the actual seven from this build — the honest cost of building fast without machine-checked criteria.
| Deliverable | Cause | What had to change |
|---|---|---|
| amesim-6dof | Headless generator omits the M6DOF/EMD link archives | Hand-fix the linker before it would compile |
| logical-architecture | As-analysed (dual battery) ≠ as-designed (single-string) | Add BT2 / U2 / PWR1 to the architecture |
| compute.html | False claim: "the FPGA is device U2 in Capital" (U2 is the redundant FC) | Corrected — after a cross-session catch, not an automated one |
| nav.js | Two agent sessions clobbered the same file | Hand-coordinated merge (the concurrency gap, live) |
| nav.js | cleanUrls broke the active-state (/compute vs compute.html) | Normalize the href — a silent bug found only by eye |
| rflp.html | Prose said 9 functions / 10 blocks; Teamcenter had 13 / 13 | Reconcile the counts |
Escape rate: ~0.5 per deliverable. Most of them would have been caught by an automated conformance / verification check — the P1 fix on the scorecard.
The hidden tax & the bill
| Handoff | Time | Failures |
|---|---|---|
| bundle → Teamcenter (SOA) | 15 min | 2 (naming-rule reject → auto-id) |
| bundle → Capital (import) | 20 min | 5 (test imports to nail the UID grammar) |
Seam tax: 2.5% of TTS, 7 retries. Low here only because we'd already built the neutral bundle + bridge; without it, the seams are where most of the day is lost.
agent output across the engineering build
tool seat-time — the economic question: cheaper than a team-week?
How it works
The whole instrument is four files and no infrastructure. An agent (or tool wrapper) calls a ~10-line emitter — one shell line per action; a stdlib script rolls the stream into the metrics above; a static page renders them. It runs the moment a single wrapper starts emitting — start with the headless runners (cheap, high-signal) and a one-line-per-turn human-touch counter and the picture is already actionable.
// one line per meaningful action — tool-agnostic, human-readable
{"event":"work_completed","domain":"performance","tool":"Amesim",
"deliverable":"qx250-6dof","duration_s":7200,"result":"pass",
"meta":{"iterations":8}}
{"event":"human_touch","meta":{"kind":"prompt"},"duration_s":120}
{"event":"rework","deliverable":"compute.html",
"meta":{"cause":"false claim: FPGA is a device in Capital"}}
{"event":"verification","deliverable":"safety-interlock","result":"pass",
"meta":{"method":"formal","machine_checkable":true}}
# agents don't hand-write JSON — one shell line per action: python emit.py human_touch --kind prompt # once per turn — the autonomy number python emit.py work_completed --domain fpga --deliverable gateware --duration_s 900 --iterations 2 python emit.py rework --deliverable compute.html --cause "false claim: FPGA in Capital" python emit.py verification --deliverable safety --method formal --machine_checkable true python aggregate.py events.jsonl metrics.json # roll the log into this dashboard
We proved the loop by logging this very task — building the emitter — with the emitter: it captured the prompt, the work, and (honestly) a real rework event for a CLI bug we'd just fixed, then aggregated to live metrics. The single habit that matters: emit human_touch --kind prompt once per turn — that line, summed over a build, is the autonomy number the program layer exists to drive to zero.
Read the full design and the runnable code: Spec (v0.1) ↗ · README (copy-paste) ↗ · emit.py ↗ · aggregate.py ↗ · events.sample.jsonl ↗ · metrics.json ↗