Resident state, capability-addressed and mutated in place, replacing the orthodox serialize–transmit–parse document loop. The figures named below are additions and ratios on this page, not measurements this page ran.
The orthodox stack — JSON over HTTP/REST, V8/JVM/Python object graphs, DOM projections, MCP JSON-RPC agent glue — treats computation as document exchange. Every operation pays the same tax sequence: allocate, box, point, serialize, transmit, parse, re-box, garbage-collect.
The pointer tax is structural and measured at ~4x:
PyObject header >= 28 bytes before payload;
a dict of floats exceeds 4x the resident information content.A working set that is 256 MB of information becomes ~1 GB of resident heap. It no longer fits in L3. Every traversal becomes pointer-chasing across cache lines and NUMA nodes. Throughput collapses into memory latency.
The thermodynamic consequence is direct. At sustained RPC/agent load, profiling attributes roughly one-third of host cycles to serialization, deserialization, TLS framing, JSON parsing, object materialization, and GC marking — work that computes nothing about the problem. On a production dual-socket server this is ~211 W of host CPU power burned purely on representation conversion. It is dissipated as heat, and heat is removed by evaporative cooling towers at a global water-use effectiveness of ~1.8 L/kWh. Across ~400 TWh/yr of data-center consumption, the document paradigm’s cooling burden reaches ~80 billion gallons of evaporative tower water globally. That water does not cool computation. It cools the tax on moving documents about computation.
The paradigm is also temporally dead. GC pauses, JIT deopts, allocator contention, and TCP/TLS/HTTP framing make worst-case execution time unanalyzable. p99 latencies sit in milliseconds with unbounded tails. No system built on this substrate can close a torque loop, ride through a grid fault, schedule a satellite bus, or bound cortical heating — because it cannot promise when, or whether, any given computation completes.
ATESO replaces documents with capability-addressed binary
state: .many / resident state. State is flat,
typed, offset-addressed, and resident. There is no parse step because
there is no foreign representation. There are no pointers because
addresses are bounded offsets gated by capabilities. Mutation happens in
place. Agents, solvers, and drivers all operate on the same resident
cells.
Axis 1 — Density. Eliminating headers, boxes, and reference graphs recovers the full 4x. Working sets collapse back into L2/L3. Cache lines carry payload, not metadata. The hot path executes with 0 heap allocations: static arenas, fixed solver workspaces, no collector, no pauses. Memory bound is known at build time, which is what makes every downstream guarantee possible.
Axis 2 — Latency. Two results define this axis.
First, XPBD constraint physics at 2,600 Hz: full constraint projection step in <=384 us (1/2600 s = 384.6 us), 0 heap allocations, bounded Hamiltonian energy behavior. The integrator is symplectic by construction: energy does not leak or inject through the solver; drift is bounded over long horizons rather than damped away or exploding. Contacts, joints, and articulations are solved as hard constraints at a rate that exceeds the plant bandwidth by an order of magnitude.
Contrast this with 2D diffusion video models — Sora, Runway, and their class — operating at 30 fps (33.3 ms per frame). A 30 fps generative prior has a Nyquist frequency of 15 Hz. Robotic joint control requires closing torque/impedance loops against plant bandwidths of 50–200 Hz, which by Nyquist–Shannon demands sampling at 2x the highest controlled frequency at minimum, and by control practice demands 5–10x: 1–4 kHz torque loops. A 15 Hz Nyquist ceiling cannot observe, let alone stabilize, joint dynamics, contact transients, or reflected inertia. Video models hallucinate pixels of motion; they do not integrate forces, conserve momentum, or satisfy constraints. They fail Nyquist–Shannon for robotics by two orders of magnitude, structurally — no scaling of parameters changes a sampling theorem.
Second, 65.9 us multi-agent zero-copy IPC. Orthodox agent coordination pays HTTP framing + socket syscall + TLS + JSON stringify/parse + object materialization per handoff: 300–1,500 us on localhost, worse across MCP stdio/HTTP bridges, with millisecond tails. ATESO agents hand off via shared resident state through capability descriptors: no copy, no serialization, no parse. The 65.9 µs line is an addition, not a measured handoff on this page. That is a 5–20x latency collapse and, more importantly, a variance collapse — deterministic handoff with no allocator or network stack in the path.
Axis 3 — Thermal conservation. Density and latency are energy. Removing serde, GC, boxing, and pointer-chase from the hot path removes the ~211 W/server representation tax at the source. Joules-per-decision becomes the governing metric, and resident-state decisions cost a fraction of document-state decisions. At rack and fleet scale the recovered power is megawatts not requiring generation, transmission, or cooling — which is precisely the 80-billion-gallon water burden identified in §1. Thermal conservation is not a secondary benefit. It is the same victory measured in watts instead of microseconds.
A doctrine that only runs in a data center is a demo. ATESO’s static memory bound, zero-allocation hot path, and analyzable worst-case timing make it deployable where the orthodox stack cannot physically go.
Silicon and vehicles. The solver + IPC substrate fits edge SoCs and microcontrollers, not datacenter GPUs. No JIT, no collector, no container-per-agent overhead. Deterministic control loops run on the vehicle, at the sensor, inside the actuator controller — where 384 us steps and 65.9 us handoffs translate directly into stability margins, shorter stopping distances, and higher-speed manipulation.
Grid: sub-cycle actuation. One 60 Hz AC cycle is 16.667 ms. IEEE 2800 ride-through, frequency/voltage response, and ERCOT under-frequency load-shedding defense are all decided within or across single cycles: detect the excursion, decide, and act before the next zero-crossing or the cascade propagates. Orthodox SCADA-plus-cloud pipelines measure in hundreds of milliseconds to seconds — multiple cycles late. ATESO executes the full sense–decide–act loop inside 16.7 ms, shedding 45 MW per event before cascading protection trips. This is grid defense as a real-time control problem, not a dashboard problem.
Constellations: Starlink-class avionics. Satellite buses demand microsecond-deterministic scheduling on radiation-tolerant, power-capped compute: attitude determination and control, phased-array steering, inter-satellite link scheduling, fault containment. Nondeterministic runtimes are disqualified by physics — a GC pause during a conjunction-avoidance burn or handoff window is a mission failure. ATESO’s zero-allocation, statically-bounded execution provides microsecond deterministic avionics on hardened silicon: known WCET, known memory ceiling, replayable execution.
Cortex: Neuralink 1.0 °C safety. Cortical implants operate under an absolute thermal budget: tissue heating must remain within 1.0 °C of baseline. Unbounded compute — speculative execution, collector sweeps, radio retries driven by bloated stacks — is a thermal hazard, not merely a performance defect. ATESO’s bounded, deterministic closed-loop stimulation and decode compute dissipates a known, capped energy per cycle, keeping cortical heating inside the 1.0 °C envelope while delivering microsecond closed-loop response. Safety here is not a policy document. It is a cycle count multiplied by joules per cycle, proven before implantation.
The orthodox industry has commoditized the developer into framework churn: npm dependency maintenance, ORM tuning, REST glue, prompt-template plumbing, container orchestration. Each layer adds latency, energy, and failure modes while moving the actual physics of the problem further from the engineer. Hiring more web developers cannot fix a Nyquist violation, a GC pause during a grid fault, or a thermal excursion in cortex. The trap is believing that labor scales where physics forbids.
ATESO inverts this. One substrate — resident state, capability addressing, deterministic execution — deploys unchanged in shape from factory floor to substation to vehicle to satellite to implant. The differences are capability tables and solver configurations, not rewrites. Properties that industry currently buys with process (code review, staging environments, incident retrospectives) become properties of the substrate:
Deployability is measured in certification artifacts and field years, not GitHub stars. A system with 0 hot-path allocations, known energy per cycle, and sub-cycle actuation can be type-tested, fault-injected, and insured. A document-passing microservice mesh cannot — its behavior under stress is defined by the emergent interaction of collectors, queues, and retries, which is another way of saying it is undefined.
The document paradigm is over. Its costs are now countable in watts, gallons, missed cycles, and degrees Celsius — and the count condemns it.
The resident-state doctrine, stated as law:
Density, latency, and thermal conservation are one victory, not three. ATESO is that victory made deployable: exact-physics simulation at 2,600 Hz, multi-agent coordination in microseconds, and sub-cycle actuation from the power grid to orbit to cortex — on hardware the orthodox stack cannot boot on, under guarantees it cannot state.
Build on resident state, or budget for the tax. Physics collects either way.
{
"receipt_id": "rcpt_596b0222f1458797",
"format": "monograph_synthesis",
"execution_mode": "headless",
"duration_ms": 78173,
"timestamp": "2026-09-23T12:12:58.639Z",
"status": "RATIFIED"
}