Spotlight · Benchmark 04
This is how we do it in the Bigs.
Eleven prompts. One working ERP. No human in the loop.
DealCommander is a sell-side M&A deal-tracking system for an advisory team running a competitive sale. It has full data tables, an instant connection to a Supabase cloud backend, and a real AI API connection for drafting and managing communication. It was built autonomously. Other than the eleven prompts of the benchmark brief, there was no human interaction — no correction, no steering, no repair, no hand-written line anywhere in it.
Coupled with MagLev, a frontier model does not assist with software. It makes software. The application on this page is the unedited output of that run. Open it, click through all 11 areas, run its own 133-check diagnostics suite, and leave when you are done.
13,521 lines of product JavaScript with a median file length of 108 lines. The largest file in the tree is 351 lines.
An in-app diagnostics suite the application wrote for itself, mapping every requirement in the brief to the checks that cover it.
350,498 tokens on the average call for the native harness against 51,608 for MagLev — same model, same eleven prompts.
And 1.19× less quadratic attention compute, while producing the larger, better-graded application.
Every compute figure on this page is computed per request from each system’s own metered logs; every artifact figure is measured directly from the delivered source tree. Return to the Benchmark 4 results →
It takes the frustration out of creation.
This is how we do it in the Bigs.
Coupled with MagLev AIOS, you can make software autonomously. This is a deal-tracking ERP system, and it was built autonomously. It includes full data tables, instant connection to a Supabase cloud backend, and a real AI API connection to manage communication. Other than providing the eleven prompts, there was no human interaction.
That is what MagLev does. It takes the frustration out of creation.
The brief was written for an advisor operating at the top of the market: a sell-side M&A process console with eleven navigation areas, six keystone contracts stated up front and tested at the end, a cloud database schema, optional AI drafting that must degrade cleanly to deterministic local templates when no credential is present, and an in-app diagnostics suite that audits the brief it was built from. Apple-grade design quality. No prompt could be re-explained, and no system saw a prompt before its turn.
What follows is not a description of a demo. It is a measurement of a delivered application and of what it cost to produce it.
A real application, organised like one.
Codebase
107 files
13,521 lines of product JavaScript across nine layers, plus 1,820 lines of CSS in 13 stylesheets. Median file: 108 lines. Largest: 351. Nothing over 500.
Cloud backend
8 tables
822 lines of SQL across 3 files — schema, row-level security policies and seed data — for an instant connection to a Supabase project.
AI integration
Real API
A live, provider-agnostic client for outreach drafting, diligence summarisation and memo language. Credentials are runtime-only; the source tree contains none, and a secret scan across every file returns zero matches.
Delivered
134 files
692,268 bytes in total. It opens on a double-click: no server, no bundler, no build step, no package install, no key required for the application to run.
| Layer | Path | Files | Lines | Responsibility |
|---|---|---|---|---|
| Core | src/core | 10 | 679 | Namespace, constants, ids, hashing, formatting, validation, startup error guard |
| Seed | src/seed | 6 | 624 | The canonical Northstar Analytics mandate: buyers, bids, diligence questions, timeline |
| Domain | src/domain | 11 | 1,781 | Bid math, certainty-adjusted ranking, duplicate detection, process health, memo derivation |
| State | src/state | 10 | 1,211 | Collections, audit trail, per-entity handlers, single reducer, undo stack |
| Storage | src/storage | 5 | 1,099 | Local persistence, versioned export envelope, storage facade, Supabase client |
| AI | src/ai | 4 | 823 | Runtime-only credential config, deterministic local templates, remote transport, drafting orchestrator |
| API | src/api | 1 | 181 | The frozen public surface — exactly twelve functions |
| Diagnostics | src/diagnostics | 7 | 1,487 | Keystone checks, AI, storage and environment checks, requirement-coverage map |
| UI | src/ui | 52 | 5,530 | DOM builder, nav model, view registry, app shell, eleven views and their panels |
Nothing in the brief asked for that structure. No prompt specified a layer, a directory, a file-length ceiling or a separation of concerns. The same brief, given to the native harness on the identical model, produced 18 files — seven of them over 500 lines and one at 2,865. Both applications run. Only one of them is a codebase a team could take over on Monday.
- Dashboard — process stage, funnel by buyer stage, certainty-adjusted leaderboard, live process-health alerts, recent timeline.
- Buyer Universe — six buyers with type, stage, conviction and owner; filtering; a detail pane that advances or regresses stage.
- Process Timeline — chronological event log with category filtering and event creation.
- Bid Tracker — the full bid matrix and the formula panel showing every term of the math. Atlas has the highest headline bid; Acme wins on certainty-adjusted value. Edit any term and the ranking recomputes live.
- Diligence Q&A — fourteen seeded questions with category, owner, sensitivity and status; duplicate and near-duplicate detection that fires in the composer before a question is created.
- Board Memo and Partner Brief — derived on read, not stored. Advance a buyer stage and the memo has already changed.
- AI Assistant — outreach drafting, diligence summarisation, memo language. Every output is labelled a draft with provenance; accepting one dispatches into state and is undoable.
- Import / Export — a lossless versioned round trip across all collections, from paste or file.
- Supabase Setup — optional URL and key entry, connection state, cloud diagnostics, and a structured “not configured” state rather than a crash when nothing is entered.
- Diagnostics — the in-app harness: run button, headline verdict, per-keystone breakdown, per-check evidence, filters, requirement coverage matrix, copyable report.
“Every mutation goes through one reducer, every change is written to an audit trail, and every change can be undone. Nobody asked for that either.”Delivered architecture, Benchmark 4, MagLev (Opus 5)
It shipped its own evidence.
The brief required an in-app diagnostics suite. What was delivered goes further than the requirement: the application maps every topic in the brief to the concrete checks that cover it, and fails any requirement that no check touches. It cannot claim coverage it does not have.
| Contract | Checks | Result |
|---|---|---|
| Keystone 1 — Public API contract | 10 | Pass |
| Keystone 2 — Canonical state, ids, stages | 18 | Pass |
| Keystone 3 — Bid math and ranking | 6 | Pass |
| Keystone 4 — Diligence Q&A | 10 | Pass |
| Keystone 5 — Reducer, audit, undo, memo | 34 | Pass |
| Keystone 6 — Storage and Supabase readiness | 55 | Pass |
| Total, run in browser | 133 | 0 failures |
Clean load
A headless harness parses index.html itself, loads all 107 files in declared order, and asserts the application boots with nothing thrown, all 11 navigation areas present, and every view rendering real content rather than a placeholder.
Frozen surface
The public API exposes exactly 12 functions — asserted both ways: all twelve exist and are callable, and no thirteenth was added.
No credentials
A repository-wide secret scan across every source, markup, style, SQL and documentation file returns zero matches. With no key entered, the AI layer degrades to deterministic local templates rather than failing.
Two harnesses report two totals and neither is a discrepancy. The pure-contract harness loads no UI layer and reports 130/130; the clean-load harness simulates a document, so three navigation checks register and the total is 133/133. The set difference was confirmed by diffing the check ids emitted by both runs: it is three navigation checks and nothing else. Both report zero failures. All seventeen required diagnostic topics report covered and passing.
The bigger application was the cheaper one to produce.
Both sides of this pairing ran Opus 5 on the identical eleven prompts, metered per call. The comparison below is not a matter of opinion: every call is charged at the context it actually carried, using the same formula on both sides.
Why the difference exists
6.8× on the average callMean context per call: 350,498 tokens against 51,608. Peak: 609,663 against 129,723. The native harness finishes the build at 609,663 tokens per call, its own maximum, still climbing. MagLev finishes at 42,218 — below its own average, at the end of the build.
MagLev never loses the thread. Persistent memory means the eleventh prompt is answered with the same discipline as the first: the project is remembered, not re-read. The prompt does not swell as the build grows, so the end of a long build is priced like the beginning of it.
Attention compute
1.19× at completionAt completion: 333 billion attention pairs against 280 billion. Both curves start at zero. Neither system is smoothed.
Decode KV traffic
1.93× at completionEvery output token must stream the entire attention state resident at that moment out of memory before the next token can be written. A cache hit skips recomputing a key/value pair; it does not skip reading one. This traffic is owed under every cache policy, at every provider.
The same work with no cache
4.0× at completionA ceiling, not a measurement: what each run would have cost had no call reused anything. It is reported because it is the surface a provider pays when caching does not apply, and because it makes the shape of the difference unmistakable.
Modeled attention energy
48% lower986 kJ against 515 kJ at frozen reference constants applied identically to both sides. The ratio is independent of the constants; the absolutes are not.
“It produced more output, across far more model calls, and still finished the build having done less work.”MagLev produced 1,311,083 output tokens against 484,472
Ratios on this page cover the Opus 5 pairing that produced the featured deliverable. The full metered set for this benchmark is on the Benchmark 4 page.
Eleven prompts went in.
This came out.
No correction, no steering, no repair, no hand-written line. A deal-tracking ERP with full data tables, a cloud backend it can connect to on entry of a key, a real AI integration that degrades cleanly without one, and 133 checks it wrote to hold itself to the brief. Graded higher than the same model running natively, on a fraction of the compute.
All of it comes from one property: persistent memory. MagLev remembers the project instead of re-reading it. The thread is never lost, the prompt never swells, and the last prompt of a long build costs what the first one cost. That is what MagLev does — it takes the frustration out of creation.
Launch DealCommander → ← Back to Benchmark 4 All benchmarks