The engine under the console. A build run like a factory.

What a customer is owed is not a rack. It is live, ready-to-serve capacity by a committed date. So the top of the model is not a project plan, it is a schedule of those commitments: for each order, the capacity promised and the date it has to be serving. Everything below exists to hit those dates and to say early when one is at risk. It is the manufacturing view, where the schedule says how much ready capacity by when.

What the customer buys is a workload, training or inference, not the kit underneath it. So the workload is the top of the bill of materials, and it explodes down into the nodes and the infrastructure that carry it. Training and inference are different bills, because their infrastructure profiles differ, and modelling them that way keeps the difference honest instead of hiding it.

Because the sale of a workload is what drives its build, what is sold at the top and what is delivered at the bottom are the same structure seen from two ends. Sold against built against still-to-build stops being a monthly reconciliation and becomes a question the model can answer.

Under each commitment sits its bill, and it has to be broader than the AI kit. A rack of GPUs serves nothing without the power to it, the cooling to it, the fabric it hangs off and the works to install and commission all of it. So the bill carries the things, across space, power, cooling, fabric and compute, and the works, the patching, the fills and pressure tests, the energisation and the burn-in. What the build produces is not loose parts, it is nodes: the working aggregate of the systems that together make usable capacity.

Once each commitment has a bill, the build can be planned the way manufacturing has planned for decades: take what is needed, net it against what is on hand and on order, apply the lead times, and see what has to be ordered, staged, installed and tested, in what order, to hit the date. That is where the real constraints show up honestly, power and cooling capacity and the specialist trades, not the servers. The planning core is a solved problem, so the right move is to buy an appropriately scaled engine and extend it, rather than write one. What gets built is only the part nothing off the shelf does: the connective tissue that reconciles everything into one model, and the loop that turns a scan into a test.

The hardest items to plan are the long-lead plant, the transformers, switchgear, generators and the large modular and cooling units, whose lead times run to many months and which sit on the real critical path, ahead of the compute. They have to be committed before the design is frozen. So the model plans, schedules and commits them ahead of the rest: it reserves a manufacturing slot against a bounded spec envelope rather than a final drawing, and from each commitment's ready-to-serve date it back-calculates the date the slot must be committed and the date the spec must be frozen. It then watches one thing, whether the evolving design still sits inside the committed envelope, so a design decision that would break a slot becomes an early, costed alert rather than a surprise at the factory. Each long-lead item carries two states at once, how far along its delivery is and how firm its spec is, and committed-but-not-yet-frozen is a normal, visible status. It is the discipline that gets a transformer on order long before the hall it will feed is fully designed, which is the only way the date is ever real.

Nothing here replaces what an operator already runs. The model is the spine, and the existing systems, and the planned ones, become feeds into it. The physical estate, the building systems, vendor telemetry, procurement and the orchestration layer each update the part of the bill they own, and every data point carries its age, so a stale reading looks stale instead of looking true. A feed can be wired in as it arrives, and nothing is locked to one vendor.

The field is the first sensor. Rather than a person walking the floor and typing it up later, the work is captured where it happens, by scanning what is in front of them. That scan moves a task from planned to installed, stamped with when and who.

Commissioning is usually a manual checklist. Here the scan is an event, and the event asks the relevant subsystem to prove itself: a patched port asks the switch to confirm it is up, a coolant loop triggers flow, temperature and a leak check, a power feed triggers a load and redundancy check, a compute tray triggers health and burn-in. Each task moves to verified on its own evidence, not on someone signing a sheet. Those checks stack into gates: a task is verified, a rack when its tasks are, a hall when its racks are, a commitment when its halls are. Ready to serve stops being a judgement call and becomes a state with the evidence behind it.

The model does the mechanical work, the capture, the reconciliation, the planning and the verification, on its own. What people spend their time on is the insight and the decision. Agents watch, reconcile and surface, and invent nothing; every derived record carries a marker to the source that produced it and when. People decide, design and own.

This is a demonstration of the approach, run against an illustrative reference design, not a system stood up at scale and not a product for sale. The capture-at-the-point-of-work spine is built and proven on live estate. The engine, the workload-as-bill layer and the trigger loop are the extension, and they are built by adopting a mature engine and wiring the parts together, not by writing a platform from scratch.