Designing past the GPU
A GPU is built to run every model. That is exactly why it runs yours slowly. ASIC-based acceleration pushes the whole Pareto frontier for your workloads: speed for a single user, throughput across many, energy per token and cost per token. That takes co-design from the multiplier to the token: dataflow, precision, memory placement, the execution model, the package and the system around it. Two breakthroughs make it happen.
Weights that never move
A GPU keeps the weights in HBM and the arithmetic on the die, so every token drags its weights across that gap. For Inkling 2 Small that is gigabytes per token, and arithmetic is a sliver of the time.
We put the memory next to the circuits that use it. Our Inkling 2 Small core holds all 393 GB of the checkpoint in SRAM across 521 dies, each bank beside the multipliers that read it. The token moves; the weights stay put. And they stay reloadable: a new checkpoint, a fine-tune or a customer's adapter is a load, not a tape-out. Customizable models need customizable silicon.
- faster for one user than B300 GPUs
- 3–4x
- the tokens per joule
- 4x
One program that never stops
On four GB300s, DeepSeek-V4.1-Flash spends half of every decode step waiting: hundreds of dependent kernel stages, all-reduces between GPUs, memory streaming at a fraction of its peak. More bandwidth does not fix waiting.
We replace hundreds of kernel launches with one persistent program in a fixed order. Stages hand off with flags, and the next layer's weights stream in while the current layer's experts are still in flight. Then we designed MDA-1, a decode chip shaped around that program.
- the speed for one user
- 2.1x
- against 3.36 kW for four GB300s
- 1.87 kW
- lower cost per million tokens
- 1.5x
Both studies are open: the simulators, the calibration and the RTL. We show our working, because the number that matters is the one measured on your model.
Three architectures, one method
A model decides where its memory lives, and the memory decides the silicon. So we start every core from the model's own arithmetic, one token at a time. Here is that arithmetic for the three families our designers have taped out, each computed live on this page.
State-space models
A state-space model carries its whole history in a state of fixed size. No cache grows with the context, so the core is weights beside their multipliers and a thin lane of registers, rewritten once per token.
State-space: a state that never grows
One channel of Mamba reading six tokens. Each token sets its own step size dt, which decides how much of each register is kept and how much is written.
Figure: one channel of the Mamba state-space model reads the six tokens The, token, moves, full stop, The, weights. For every token the figure computes a step size dt, the fraction of the old state that is kept, and the value written, for a slow and a fast state register. The registers are rewritten in place: while dt is small they hold, and at the second The, where dt jumps to 0.485, the fast register is replaced and the slow one overwritten. After six tokens the state is still two numbers.
Hybrid transformers
A hybrid buys exact recall with a few attention layers and keeps everything else recurrent. Its silicon needs both kinds of memory: a fixed state held inside each recurrent tile, and a cache in HBM that grows one row at a time.
Hybrid: a fixed state and a growing cache
Nine recurrent layers and one attention layer. Each recurrent tile rewrites its own 32 values in place; the attention layer appends a row to its cache and scores every row.
Figure: a token passes through ten layers in the order of IBM's Granite 4.0-H: five recurrent layers, one attention layer, four more recurrent layers. Each recurrent layer holds a state of 32 values that is rewritten in place as the token arrives. At the attention layer the token adds one row to a key-value cache in high-bandwidth memory and is scored against every row; the scores sum to one. After eight tokens the recurrent state is still 288 values, and the cache has grown to eight rows.
Mixture-of-experts LLMs
A large LLM holds hundreds of experts and uses a handful for each token. On our decode chip for DeepSeek-V4.1-Flash a hardware router picks 6 of 384 in every layer, and only their weights leave memory.
LLM: six experts of 384 leave memory
Two dies and eight HBM3E stacks to a package. In every layer the router scores all 384 experts, and only the six winners' weights stream to the dies.
Figure: a chip package with two dies in the middle and eight stacks of HBM3E memory, four above and four below, holding the weights of 384 experts. For each of six layers the router scores every expert and picks six; the weights of those six stream from their stacks into the dies, each with its mixing weight. The other 378 stay where they are.
How to work with us
Every engagement starts with a conversation about what you run. From there, three ways in, each built to put measured numbers in your hands before any silicon is made.
Proof of concept
A paid proof-of-concept study of your model: where the time and energy go, what a core or system-on-chip around it looks like, and what it saves against what you pay today.
Measure
Your model running on our design, with energy per token measured, not estimated. You decide on the core with numbers in hand.
Build
We take the core to tape-out as a single design run, or as a core production line that ships a new core every three months to keep pace with your models. Or license the design and build it yourself.
Running someone else's model? Buy our cores, tuned for power, speed or context capacity. Every core ships with its measured energy per token and the conditions behind it.
Your model stays yours. Weights and code are exchanged only under NDA, and a core built around your model protects it in silicon. We are booking proof-of-concept studies with enterprise teams now.
Tell us what you runpartners@aercrist.com · Ben reads and replies to every message himself.