Computation is the last unmodeled environment. We are building the model.

A Compute World Model is a learned simulator of a compute environment. It answers the question no system can answer today: what happens if this work moves there, now?

Language models learn from what people wrote. Compute World Models learn from what machines do. The exhaust of the entire computing world, which nobody has assembled, and which is sitting there.

The computational world is not only silicon. It is power, and heat, and the envelope the work actually runs inside. A model that knows the chip and not the room does not know the machine.

Consider a GPU with free memory in a rack near its power cap, while coolant temperature is rising. Another workload might fit on the chip but force neighboring machines to throttle. A better placement may be a cooler rack, or no move at all.

Run the same model backward and it answers a second question: what machine does this work need? A simulator that predicts a machine under load is, by construction, a specifier of the machine the load requires. The forward pass is placement. The inverse pass is specification.

A benchmark describes a machine at rest. A Compute World Model predicts a machine under load.

Spatial intelligence is the ability to reason about the physical world. Every person has it.

Compute Intelligence is the ability to reason about computational environments. It is rare, takes years to acquire, is mostly tacit, and does not transfer.

That is why a chip is only as useful as the team available to operate it. It is why the scarcest resource in AI is not silicon and not energy, but the few people who know what silicon will do.

Compute Intelligence gives machines a faculty almost nobody has, and gives it to everyone.

You profile a machine. Then you schedule on it. Characterization first, policy second, for as long as computers have been scheduled.

That order is the bottleneck. It slows the path from a new accelerator to useful production work.

We are removing the first step.

Placement and measurement are the same act. You learn the machine by using it, and the cost of knowledge is paid in work the machine was going to do anyway.

You design hardware. Then you find out what it is good for. Physics first, workload second, and for decades the physics was the slow part, so nobody noticed the order.

The physics is no longer slow. What the design loop still cannot do is say what to put in it. It verifies the design it is handed. It has no idea what the work will do with it, because the work has never run on it, because it does not exist yet.

We are closing that gap from the workload side.

Every piece of work placed on a machine returns a measurement of what that machine does under that work. Enough measurements, across enough unlike silicon, and the record states what the next silicon needs: the mix of architectures per rack, the memory hierarchy the traffic wants, the interconnect the communication pattern implies, the power and thermal envelope the duty cycle will draw. In units a designer can build to and a buyer can hold a vendor to.

We do not design silicon and hold no design seat with any vendor. The specification is a recommendation on the same authority ladder as placement, and the physical realization belongs to the people and the tools that do physics. What they get from us is the one input they have never had: measured demand.

Placement before profiling removes the characterization interval. Specification before silicon removes the guess. Work on machines produces the record. The record produces the specification. The specification produces machines that carry work from the day they ship. Each turn of the loop is faster than the last.

Humanity has been measuring computers for seventy years and has almost no shared record of what they do.

We are building one.

The schema is open. Anyone who runs the benchmark produces a profile, with provenance, contributed to a public index. Profiles are contested, corrected, superseded.

The corpus a Compute World Model needs is exactly the corpus the federation produces. The openness and the capability are the same project. And the specification a designer needs is drawn from the same record, so a chip specified from the federation is a chip the federation can verify.

We hold no privileged position in it. A record whose keeper scores itself is the problem it was built to solve.

The structure of computation shapes the space of possible algorithms. When hardware was uniform, computation could be abstracted. When hardware is heterogeneous, computation becomes an object of scientific study.

Every abstraction in computing was built to hide the machine. Assembly hid the instruction set. Virtual memory hid the address space. Threads hid the core count. Each leaked exactly where performance mattered.

The reflex is to hide a new difference behind another layer. Building a second target does not undo fragmentation. It is fragmentation.

We do the opposite. We model the differences and make them legible to a system that can act on them.

That is a science, not a product. We publish what we find. We publish the problems we cannot solve so that others can take them.