Interaction Nets: The 1990 Idea Behind a New CPU

Every few years an old idea from a 1990s compiler paper wakes up and asks for a second chance. This week it's interaction nets. Architect Labs says it built a whole CPU around them, and that AI agent swarms did the design work from instruction set to final layout. I think the chip claim needs a pinch of salt. The idea under it is worth ten minutes of your time.
What interaction nets actually are
Yves Lafont introduced interaction nets at POPL in 1990. The pitch is simple. A program is a graph of little nodes. Each node has exactly one "principal" port plus some extra ports. When two nodes touch principal port to principal port, they form an active pair, and a rule swaps that pair for a small new piece of graph.
That's the whole engine. No global memory. No "read this variable over there." Just local rewrites.
The clever part falls out of the one-principal-port rule. A node can sit in at most one active pair, so two pending rewrites never share a node. You can run them in any order, or all at once, and you land on the same answer in the same number of steps. Lafont proved that property in the original paper.
Quick example. Say you're adding up a list by splitting it in half again and again. On a normal CPU, the code hides which parts depend on which, so the hardware burns energy figuring it out at runtime. As an interaction net, every "add these two halves" pair sits there, visibly independent, waiting for any free worker to grab it. Parallelism for free, no locks, no race conditions.
Why a CPU built on interaction nets is interesting
Architect Labs published Frostbite on November 18. Programs are written in Vine, a Rust-like language that compiles to interaction nets. The chip is a grid of tiles, each with its own small memory. A tile runs its own work first, steals from a busy neighbour if it's idle, and goes to sleep if there's nothing to steal. No central scheduler, no cache coherence.
Their numbers, from their own post: a 4.59x geometric mean in performance per watt across 25 workloads, with 6.02x on the 10 workloads the agents tuned on and 3.83x on the 15 held out until the end. They report 8.77x performance per area. The design spec lowered to more than 800k lines of Lean for formal checks, and the swarm tried 58 architecture ideas and kept 37.
Now the salt. The comparison CPU is an unnamed dual-issue, in-order core; they say they can't name it for legal reasons. That's a modest baseline, not a big out-of-order server core. Results come from a 7 nm synthesis and layout, not chips back from a fab. Nobody outside the company has checked the numbers yet. Their own roadmap includes an FPGA playground, an OS, wider benchmarks like SPEC and PARSEC, and releasing the RTL and ISA. I'd wait for that last one before getting excited.
My take: the hardware story is the headline, but the real lesson is about software. We spent decades writing code that throws away dependency information, then built huge caches and reorder buffers to guess it back. Interaction nets keep that information in the program. Whether Frostbite ships or not, I expect more runtimes and accelerators to steal the trick.
This isn't the first try, either. HVM2, the runtime behind the Bend language, ran interaction combinators on GPUs and reported peaks of 74 billion interactions per second on an RTX 4090. Here's the twist: Bend 2 dropped interaction nets for a new runtime, and its own docs note that memory traffic still costs real time even when the graph says the work is independent.
So which do you think wins: hardware built for interaction nets, or a smarter compiler that brings the same trick to the chips we already have?