Blog
[model results measured on GPUs; board throughput derived, not measured] One Artix-7 200T holds the layers of a 13M-parameter ternary model in its own block memory. In our own twin experiment the 100M ternary model passes 0.97% vs 1.68% for full precision across eight languages, and compile rate, not correctness, is the gap. A model that is wrong most of the time becomes useful only where a compiler checks every answer.
The proposal was the owner's: instead of one large model, a network of narrow agents, one per FPGA. Each agent is rewarded for its own work, and open firmware lets anyone connect a device. Before any of it is built, the arithmetic decides what it can be. Nothing below is measured on a board. The capacity numbers are block-RAM bits divided by 1.6 bits per ternary weight. The model figures come from GPU training runs.
| Board | Block RAM | Ternary weights at 1.6 bits | Layers of a 13M model |
|---|---|---|---|
| ALINX AX7203 (XC7A200T) | 13.46 Mb | 8.41M | fit, using 53% |
| XC7A100T boards | 4.98 Mb | 3.11M | do not fit (142%) |
| Sipeed Tang Mega 138K | 6.27 Mb | 3.92M | do not fit (113%) |
An XC7A200T holds the transformer layers of one 13M-parameter ternary model. A 100M model fits on none of these parts. It has to stream its weights from DDR3, and the AX7203's DDR3 delivers 3.2 GB/s, about a fifth of a Raspberry Pi 5's memory bandwidth. Streaming is not where an FPGA wins.
At 13M parameters with a 32,000-token vocabulary, the embedding table, which doubles as the output head, holds 8.19M of the 12.62M parameters. The ternary layers need 0.89 MB. An 8-bit head needs 8.19 MB, read once for every generated token. That read, not the ternary arithmetic, caps one stream at about 330 tokens per second on the AX7203. Eight streams sharing each read reach about 2,650. JetBrains ships its local 100M code model with a 16,384-token vocabulary. A board-sized IGLA needs a smaller vocabulary and a 4-bit head before it needs a faster adder.
Splitting one large model across nodes does not survive the internet: spread a model over a hundred boards and every token pays a hundred network hops. A task, such as completing one spec or repairing another, travels once and takes seconds, so a 50 ms hop is noise. Branch-Train-Merge and c-BTM trained experts independently on separate slices of data and routed each document to one of them. They report matching dense models trained with the same compute. One expert per request means one board per request.
| Model | HumanEval pass@1 | pass@100 |
|---|---|---|
| Codex-12M | 2.00% | 8.58% |
| Codex-85M | 8.22% | 22.4% |
These are the only published code results under 100M parameters, and they come from the Codex paper. A 12M agent that answers once is right 2% of the time. A network of such agents with nobody checking their work mostly produces noise. Now give the same agent a cheap, exact judge and let it try a hundred times: it solves 4.3 times as many problems. At 200 tokens a try, a hundred tries take 8 to 60 seconds on one board.
t27c turns a spec into a syntax tree, types and generated code, and refuses a spec it cannot handle. The corpus carries its own tests and invariants, and t27c test-report runs every test in isolation. Today the swarm uses that judge only in part: its merge gate checks structure, and the tests run nightly on master, not before a merge. A device lane would change two things. The worker becomes an IGLA model on the owner's board instead of a provider token. And nothing the lane sends counts until the spec's own tests pass. It takes only the work the compiler can judge: complete a spec skeleton, repair a spec until t27c accepts it, or port a function into .t27. The swarm already records an accepted turn as a non-transferable integer against the name that made it, and a device lane earns the same way. Ternary inference in integers is bit-exact, so any node can rerun a sampled task and settle a dispute by comparing the outputs. tri-net's compute-challenge spec already applies that rule to single operations.
The judge argument needed our own numbers, not only the Codex table. We trained a controlled twin pair: two 100M-parameter models, one full-precision, one ternary (b1.58), on the same 10.0 billion tokens of code, then ran both through MultiPL-E (HumanEval-164 translated into eight languages, n=20 samples, temperature 0.2, native execution).
| Language | pass@1 FP | pass@1 ternary | compiles FP | compiles ternary |
|---|---|---|---|---|
| python | 2.35% | 1.25% | 86% | 84% |
| c++ | 1.43% | 0.12% | 59% | 47% |
| go | 1.01% | 1.23% | 45% | 46% |
| java | 2.41% | 2.18% | 62% | 55% |
| javascript | 1.68% | 1.15% | 72% | 75% |
| php | 0.68% | 0.62% | 100% | 100% |
| rust | 1.57% | 0.16% | 38% | 12% |
| typescript | 2.33% | 1.38% | 65% | 49% |
Mean pass@1 over the eight languages: FP 1.68%, ternary 1.01%. Full precision leads in seven of eight languages; go is the exception. The striking column is not pass@1 but compiles: the ternary model produces code that fails to compile far more often (rust 12% vs 38%). Compile is the judge's first gate, so compile rate is the natural ladder step.
We also measured knowledge distillation from the FP teacher into the ternary student on the same 2-billion-token budget: the distilled student is worse in every language (mixed bits-per-byte 0.897 vs 0.713 for plain cross-entropy), at roughly seven times the GPU cost. The teacher is not far enough ahead of the student to teach it. Distillation from this teacher is rejected on measurement.
Work with me
I audit RTL and build independent, bit-exact models, then take the result through synthesis and, when useful, onto an Artix-7 board. The first conformance module is free.