
Introducing Frostbite: A new CPU architecture discovered, designed, and verified end-to-end by AI
Abstract
In our previous post, Redwood, we showed that given an architecture, our AI systems could implement, verify, and deploy an inference accelerator in record time. However, similar to other scientific domains, we believe that AI systems, given the correct freedom and guardrails, can co-design software and hardware together, making optimizations across the stack and opening a design space so large it was previously inaccessible. We set out to answer the question: “Could our AI systems & tools lead to a novel hardware discovery that radically outperforms human-made designs?”
Today, we're introducing Frostbite, a general-purpose CPU with a new instruction set built from the ground up. Frostbite exploits the properties of interaction nets, namely that every step is local, every dependency is explicit, and every value has exactly one owner, to reach a step-function gain in CPU performance that has long stagnated. On a set of 25 initially chosen workloads, including 15 held out until the final evaluation, we achieved a 4.59x performance-per-watt multiple when compared to a modern, silicon-proven superscalar CPU.
Our AI systems autonomously iterated over the compiler, ISA, architecture, microarchitecture, RTL, verification, and final GDS. When we took a closer look at the discovered architectural primitives, we were surprised to find novel hardware implementations and runtime features that would have otherwise been difficult to architect. In spite of stagnation in CPU core improvement, we were able to take a workload concept all the way to a final GDS, and prove a step-function increase in perf/W and perf/area. We believe that as AI systems become more capable, every class of chip we know today, from datacenter-grade CPUs, to AI accelerators, to networking switches and NICs, will go through similar fundamental architectural shifts.
Introduction to interaction nets
Mainstream programming languages, when compiled for general-purpose CPUs, hide the dependencies between the parts of a program. Any piece of code may read or write any variable through a shared, mutable state, and so modern CPU hardware assumes the worst case and rediscovers, at runtime, which instructions actually depend on each other. Moreover, single-core CPU performance has largely stalled since the early 2000s, pushing people towards large multicore CPUs such as Intel Xeon, AMD Zen, and NVIDIA Vera. This forces CPUs to maintain the illusion that every core sees the same memory, and keeping that illusion consistent and performant requires deep cache hierarchies and coherence protocols that cost area and power, and scale poorly.
Interaction nets1 take a different approach. A program is a graph of nodes, and computation happens by rewriting pairs of nodes that are connected through their ports. Every rewrite only touches a small, local part of the graph. Because each node has exactly one principal port, no two of these active pairs ever overlap, so they can be rewritten in any order, or all at once, and the result is always the same. Interaction nets are also linear: every value is used exactly once, so there is no shared mutable state for the hardware to guard. Languages such as Vine2compile ordinary-looking programs directly to interaction nets. For an excellent introduction to interaction nets and why they suit hardware, we highly recommend Tendrils' “On Interaction Nets.” 3
Fig. 1 shows the difference on a small search problem, placing five queens on a five-by-five board. The sequential program visits one candidate at a time. The interaction net exposes all of its independent work: on average, about twelve interactions are ready to run at every step. Nothing about the program was rewritten to get this parallelism; the dependencies were simply never thrown away.
In theory, this should have two large advantages. The first is multithreading for free: rather than varying levels of coarse and fine-grained parallelism, parallelism comes straight from the program. No threads, locks, or race conditions, and none of the out-of-order machinery a conventional core uses to dig it back out. The second is that, since every value has one owner and every step is local, data can live in small local memories next to where it is used. That removes much of the area and power a conventional chip spends on large caching subsystems, and much of the system-level complexity of keeping those caches coherent.
Process
Frostbite was designed with zero architectural priors. We followed the process below, riding multiple agent swarms along the way.

Architecture exploration and selection
To begin architectural exploration, we had to establish the set of workloads Frostbite should do exceedingly well in. We decided to look at different ways a program could expose its work: many independent pieces at once, rounds of parallel work, long sequential chains, data-dependent branches, and recursion. Under each category, we created a search set and a held-out eval set to evaluate the final Frostbite on, ensuring the design generalized to programs it was never tuned on. The kernels for FFT, radixsort, and LU follow the implementation in the SPLASH-2 benchmark, although 64 times smaller, because at regular sizes they are not suitable for exploratory work.
Later, we added five more practical workloads to the held-out set: a Kalman filter, PCA, finite element analysis, an LU solve, and LZ4 decompression.

Agents synthesized research papers and existing benchmarks, and built Python models to trade off high-level architectural ideas against each other, before narrowing to a single architectural concept. The output of this exploration was a 141-page PDF covering the proposed programming model, the runtime, and the high-level blocks of the chip. This was nowhere near the final architecture, but rather a starting point where all the prior findings, high-level requirements, constraints, experiments, and runtime traits were described. Once the first architectural iteration completed (first RTL generation), this was deleted, since many of the numbers and estimates were well off what was physically possible.
Formal contracts and system modeling
Once the architecture candidate was selected, our system moved on to building the full software model of the chip. Building software models is essential when exploring an architectural space, as they allow fast iteration between the workloads, the ISA, and the abstracted view of the hardware. Whether we build a CPU, GPU, NPU, or networking switch, mastering this iteration loop allows the fastest exploration of the design space within a finite time. To do this repeatedly, we designed a new in-house specification language, ASL, and wrote Frostbite's system model “Arcmodel” in it. ASL supports machine-checkable translations and refinements between RTL, system models, UVM, SVA, and more, all against a formally backed specification. Its power and performance estimates are accurate to within 1–5%, it runs roughly 200x faster than RTL simulation, and it is formally verifiable through “contracts.”
In every silicon program to date, human architects have written many English PDFs before handing off to an implementation team and a verification team. However, natural language cannot capture every detail an implementation needs precisely and unambiguously, and it cannot guarantee that every agent hallucination is caught while the ASIC is being designed and verified. Natural language was never built for this, and in a world where AI writes the specification, we opt for a formal, machine-checkable specification language instead.
ASL can formally describe both high-level, protocol-like behavior, such as out-of-order handling, CSR programming, memory ordering, and coherency, and low-level details, such as pipelines, arbitration mechanisms, and compute transfer functions. This lets the model leave the specification open-ended where that is useful and constrain it exactly where a precise behavior is required. ASL also translates natively to Lean,4 which we use for all theorem proving when checking AI outputs across RTL, UVM, C, SVA, and more. We will discuss ASL in more detail in a future post.
Throughout the entire development of Frostbite, our AI iterates on the Frostbite ISA, Arcmodel, Design, and Verification tightly together, maintaining the ASL Contract as the source of truth. We've found that having a single, provable source of truth prevents a large class of bugs, silly mistakes, and reward-hacking instances when deploying large agent swarms. Ultimately, this common language allows the models to work across the stack nimbly, reflecting the changes propagated from the workload down to the final hardware. By the end, our Frostbite ASL lowered down to 800k+ lines of Lean.

RTL and alignment
Because ASL is a formally backed specification, designing and verifying the RTL derived from it is the fastest part of the entire Frostbite process. Arcmodel, however, is not physically aware, so its power and performance estimates at first diverge from the true numbers of the timing-converged, synthesis-clean RTL, in the worst case by almost 250%.
Before continuing the ASL autoresearch, one of our systems recalibrates Arcmodel against the RTL. This is a fully autonomous pipeline. It first identifies the power hotspots in the RTL and traces them down to key counters in the formal specification, such as SRAM reads and writes, operation counts, flits sent and received, credit returns, and frame misses. The model may then write any scalar Python function over those counters to predict power, and it repeats this process until the RTL and Arcmodel agree to within 5%.
We find this style of non-gradient learning extremely powerful. Once this first physical alignment has been applied, later iterations are much faster. These are, of course, still pre-silicon power numbers, and over multiple tapeout loops, ASL models can be correlated to true post-silicon, production power numbers.

By aligning the Arcmodel and RTL so closely, the continued swarms were able to explore and exploit much faster. The full Arcmodel chip simulations are much faster than the RTL (660x faster), which led to many cross-stack optimizations. For instance, our AI systems discovered very fine-grained clock gating tricks, and adjusted the software runtime accordingly to accommodate them in a matter of hours. Such a cross-stack optimization is near-impossible to execute on in a traditional ASIC flow.
Contracts, Arcmodel, RTL, and power, iterated together
Once Arcmodel and the RTL agreed, the original Python models and the architecture PDF were deleted, and the ASL contracts became the only specification of the chip. From then on, contracts, Arcmodel, RTL, and power moved forward together. Swarms of agents proposed architecture revisions in parallel worktrees; each change was checked against the contracts, modeled in Arcmodel, implemented in RTL, and measured for power, and then either kept or dropped. Across four searches and a final round of ablations, the swarm tried 58 ideas and kept 37 of them, from clock gates on a running tile to smaller L3 tables and one shared expander.
Architectural novelty
The architecture in full detail would warrant its own post. Instead, we choose to focus here on the features that we considered either novel or creative and highlight the capability of our systems to push the frontiers of hardware design.
Programs for Frostbite are written in Vine,2 which is a fully fledged programming language with syntax similar to Rust. A Vine program is compiled to Ivy, an intermediate representation (IR) that encodes the interaction net structure. The optimizer also tries to apply as many of the graph reduction rules as it can, so the final Ivy net, as it is called, has a (mostly) fixed shape, composed of three primitives: data, computation nodes, and control nodes. However, the runtime of this net is still very dynamic, because unlike the typical computation graph, where the parallelism is encoded in the structure and pipelined over time, the parallelism has to be derived at runtime from the state and pipelined spatially. The initial naïve implementations were slow, so our agents had to get creative.
The generated ISA follows from this set of constraints. A lot of it is expected: wide bundles, hardware loop counters, and streams. We found the dynamic features more interesting, particularly operations to take, peek, and copy values from other parts of the net that would be running in parallel. The tiles then come alive, communicating across space.
Emergent property: stealing work
Because the parallelism is spread over space, there is no central scheduler. Instead, we saw the agents design these elegant rules for propagating the work. A tile follows three rules: it runs its own work first, meaning work in its input ports. If those are empty, it takes work from a neighboring tile that has work to spare. If no such tile is found, it can just go inactive and save power.
The agents demonstrated remarkable sophistication in how they implemented this. Below, we have the hardware for a single Frostbite tile:

A lot of them should be familiar. We are interested in the RUNTIME domain that is responsible for the work-stealing behavior described above.
The compiler breaks code into short sections that run uninterrupted once their inputs are ready. These are run in the engine and are mostly organized like traditional computation through the front end. Whenever a loop or branch splits into parallel pieces whose sizes aren't known ahead of time, the running section parks whatever comes after into a small record in local memory, the frame manager. It then drops the new tasks onto a hardware queue called the work queueand picks up the newest one itself. Idle neighbors are then free to pull the remaining tasks over the network. As tasks finish anywhere on the chip in any order, their return packets tick down the parked record's counter and automatically wake the next section the instant the last piece arrives.
This is what it looks like in hardware:
We can think of each “task” as the current board, one level down, with one more queen. Tile 0 has to queue three tasks for all the possible queen configurations before it can finish the present board state. It's free, so it takes the newest task (from itself) and runs it. Meanwhile, its neighbors have gotten the other ones, except for Tile 5, which goes back to sleep.
This behavior was never specified by any human. We can directly trace it back to necessity on specific regressions and hill-climbing performance metrics.
Results
We synthesized Frostbite on a 7 nm process, reaching 800 MHz timing at synthesis and 500 MHz in the final GDS. Each Frostbite quad (a two-by-two grid of tiles) paired with four L3 nodes is 0.792 mm². We benchmark one Quad+L3 cluster against a single core of a modern superscalar CPU, which we refer to as TCPU (“Traditional CPU”). This TCPU is 0.895 mm² at the same process, and is a dual-issue, in-order processor.†

We benchmarked on a wide set of workloads, from dense, parallel kernels such as gemm and conv2d, to irregular, branching programs such as JSON parsing, Huffman coding, k-d trees, and recursive Fibonacci. A search set of workloads drove all architectural optimization, ISA design, RTL, and verification, and the chip was evaluated on both the 10 search-set workloads and the 15 held out, including the five practical workloads added later (Fig. 3).
For a fair comparison, we chose to first measure “single-core” performance by benchmarking one Frostbite quad against the TCPU, since they have similar area. Across all the workloads, we average an 8.77x performance-per-area, and across all 25 workloads, search set and held out together, Frostbite reaches a geometric mean of 4.59x the TCPU's performance-per-watt: 6.02x on the 10 search-set workloads, and 3.83x on the 15 held-out workloads it was never tuned on. As expected, the architecture does most strongly on highly parallelizable tasks, but it also outperforms the TCPU on branching, dynamic code.


The energy breakdown shows where the savings come from. Leaving out clock distribution (49% of TCPU energy, 41% of a Frostbite quad's), the TCPU spends 57% of its energy on memory and 27% on fetching, decoding, and issuing instructions. Frostbite cuts memory to 38% and fetch, decode, and issue to just 6%. In exchange, it spends 26% on its on-chip network and scheduler, the cost of sharing work and moving messages between tiles. What's more exciting, however, is that as we scale the chip to a four-by-four array (four quads), the power distribution is relatively the same. In a general-purpose multi-core CPU arrangement, scaling the number of cores requires adding heavy coherency mechanisms and large caches, whereas when running interaction nets, the same data locality rules always apply, and more cores do not increase system complexity. This is illustrated below. In the coming months, we'll be benchmarking Frostbite mesh-like configurations against multi-core “TCPU” arrangements with large caches and larger, wider, out-of-order CPUs, over a larger set of industry benchmarks such as SPEC and PARSEC.

What comes next
While interaction nets have been around for more than 35 years, their production value has never been fully clear. Historically, there has always been a risk of exploring out-of-distribution architectures, for the time, investment, and labor required to come to conviction. We believe AI fundamentally changes these economics. In the search for higher performance and lower power, extreme co-design of workloads, ISA, and hardware will continue to be demanded. With large agent swarms, sophisticated search-space techniques, precise guardrails, formal verification, and faster EDA tools, AI systems will be able to discover and build novel accelerators at a quality that exceeds human cognition. While there is much more to do, we feel it is the right time to share with the world what the future of autonomous chip design could look like. We plan to continue scaling development on Frostbite, including but not limited to:
- Deliver a software playground for anybody to run a program on Frostbite, hosted on FPGAs.
- Build a preliminary operating system capable of managing hardware resources, multiple programs, virtualization, and more.
- Scale swarms to bring Frostbite to higher performance-per-watt, and benchmark it on a much larger set of workloads against a broader set of CPUs.
- Release the RTL and ISA for Frostbite.
We are having a lot of fun!
Notes
†For legal reasons, we cannot disclose the exact CPU.
References
- 1.Lafont, Y. (1990). “Interaction Nets.” Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’90), 95–108. doi:10.1145/96709.96718
- 2.The Vine programming language. vine.dev
- 3.Tendrils (2026). “On Interaction Nets.” tendrils.co/blog/2026-04-26/on-inets
- 4.de Moura, L., and Ullrich, S. (2021). “The Lean 4 Theorem Prover and Programming Language.” Automated Deduction – CADE 28, LNCS 12699, 625–635. doi:10.1007/978-3-030-79876-5_37
Partner with us
If your edge depends on the silicon underneath it, whether you're an AI lab, a fabless chip company, an OEM, a defense prime, or ASIC design partner, we want to hear from you.
