The memory hypervisor that turns a rack of CXL silicon into a fleet of independent, isolated, metered virtual memory machines — allocated in seconds, billed by the gigabyte-hour, rented to the AI industry.
Traditionally, the DRAM in a server belongs to that server, and nothing else can touch it. When one box is starving for memory and the box beside it sits half-idle, there is no way to move the capacity across. CXL broke that wall at the hardware level: memory can now leave the server and live in a shared pool. MemVM is the software that makes the pool usable as a product — it aggregates every module across every chassis into one fabric-wide address space, then slices that space into virtual memory machines that behave like real, dedicated memory to each tenant, while Neutron keeps them isolated, metered, and continuously earning.
A virtual memory machine is the unit a holder owns and a tenant rents. It has a capacity, a bandwidth class, a tenant binding, and a live meter. MemVM can spin one up, resize it, migrate it across the fabric, and tear it down — all without touching the physical hardware.
A tenant asks for capacity — a size, a bandwidth class, a duration. Or a holder's share comes online and needs a machine placed against it.
The allocator asks the Fabric Manager to cut a slice from the pool using dynamic capacity, picking modules that keep the tenant on the shortest fabric path.
The slice is bound to exactly one tenant, address-fenced from every other, and given a hard bandwidth ceiling so neighbours never bleed into each other.
The tenant reads and writes at pool latency. Every gigabyte-hour is metered and streamed to the ledger, where it becomes yield for the share's holder.
Memory is carved and reclaimed in 64 MB extents while everything stays online. A machine grows, shrinks, or moves without a reboot on either side.
Each virtual machine sits in its own fenced address range. A tenant can never read, corrupt, or even observe another's memory. Faults are contained to a single slice.
Every machine carries a bandwidth class with an enforced ceiling, so one noisy tenant on a shared switch can't starve the others. Performance is a contract, not a hope.
The engine tracks access heat and keeps hot pages on the fastest media, cold pages on the cheapest. Tenants get near-local speed on the data that matters.
Inline ECC, memory poison handling, and per-module telemetry. A failing module is drained and swapped with the tenant migrated live — no data lost, no downtime billed.
Usage is measured continuously in gigabyte-hours per machine and written to the on-chain ledger. That stream is exactly what a share's yield is computed from.
Nothing to install, nothing to port. A Neutron machine surfaces on the tenant host as a standard system memory node — the operating system, the allocator, and the AI framework use it exactly as they use local RAM. Provisioning is one command; the working set simply gets bigger.
The host sees ordinary system memory on a second tier. The kernel's tiered-memory logic places pages across local and pooled DRAM with no help from the application.
CXL.mem is native load and store — the CPU reads and writes it directly. There is nothing to install and nothing to rewrite; existing binaries run unmodified.
vLLM, PyTorch, and CUDA unified memory allocate into the pool like any RAM. The KV-cache and the hot working set grow into Neutron without a line of glue code.
Bars are log-scaled for shape. The pool answers in hundreds of nanoseconds — the same order as memory, roughly 100× faster than the SSD tier where inference caches would otherwise spill. That gap is the product: keep the working set in real memory, priced by the hour, instead of buying and stranding DRAM for peak.
The meter is not a dashboard afterthought — it is the spine of the whole model. MemVM measures exactly how much memory each virtual machine served and for how long, in gigabyte-hours. That record is written on-chain per machine, aggregated per share, and paid out on the pulsar cadence.
A holder owns a share. A share maps to one or more virtual memory machines. Those machines are rented and metered by MemVM. The rent, net of operating cost, is the yield. The chain, not a spreadsheet, is the source of truth.
MemVM meters delivered service in gigabyte-hours and settles it on-chain. Distributions follow the metered record, per machine and per share.
MemVM is Neutron's control-plane software, built on open industry standards — CXL, Dynamic Capacity Devices, and multi-logical-device pooling — running on commercial chassis and enterprise memory. Neutron builds the intelligence; the silicon is proven.