Neuron Network · architecture
A language model that runs inside Solana
The model's weights live in a Solana account, and a Solana program computes every token with whole-number math, so any machine that replays it gets the same bytes. One integer core powers everything: the program, the rollup's native shortcut, and the off-chain reference that checks them.
- 260K
- weights, Llama architecture
- 313,751 B
- model account, SHA-256 locked
- 2.85
- tx per token on stock Solana
- 0.27
- tx per token on the rollup
- 369 tok/s
- streamed from a live rollup node
01 · The system
From a client to the chain and back
Clients never run the model. They upload it once, start a session, and send Step transactions; the program does the rest, and the clients read the result straight out of the session account. The same program runs on stock Solana and, faster, on the Neuron rollup, which settles back to Solana.
02 · One core, four places
The same code everywhere, checked to the byte
The forward pass is written once, in a no_std Rust crate with no floating point. It is compiled into both builds of the program, linked into the rollup's sequencer as a syscall, and linked into the host tools as the reference. Because every copy is the same integer code, their results can be compared exactly, and the tests do: they compare the entire session account with the host after every single layer.
03 · One token
What a Step transaction does
A Step transaction doesn't name a position. It loads the session, runs the next unit (one layer, or the final classifier) as many times as its compute budget allows, and saves the session again. Any Step continues from wherever the last one stopped, so a client can fire dozens at once and the chain simply runs them back to back.
04 · Two builds
Stock Solana and the Neuron rollup
Both builds run the same program and produce the same tokens. The difference is where the two heaviest jobs run. On stock Solana, matrix math and attention execute as metered bytecode inside the VM. On the Neuron rollup, they leave the VM through two syscalls and run as native code.
Measured
The numbers so far
| What | Result | How it was measured |
|---|---|---|
| Model on chain | 313,751 bytes | Uploaded in 329 transactions, each under the 1,232-byte packet limit, then locked by its SHA-256rollup + stock validator |
| Stock Solana build | 2.85 tx / token | A full 255-token story, 2.43M compute units per token, no transaction over its limitsequencer test, plain bytecode |
| Stock Solana validator | ≈4 tokens / block | 123-token story on solana-test-validator, identical to the off-chain referencerun-chain.cjs, Agave 3.0.13 |
| Neuron rollup build | 0.27 tx / token | 0.36M compute units per token with native matmul and attentionsequencer test, sol-infer build |
| Live rollup node | 369 tokens / s | 251 tokens in 0.68 s across 2 blocks, over RPC, byte-identical to the referencenpm run llm:live -- --greedy |
| Integer vs float | 114 of 255 | Tokens identical to the float model before the first divergence on the reference story; the text stays coherent afterneuron-llm compare |
Trust
What you can check today, and what's still open
Checkable now
- The weights are pinned by SHA-256 and can't be written after
Finalize. - Every step is integer math, so any machine that replays a session gets identical bytes.
- Sampling is seeded and the seed is stored in the session, so even creative stories replay exactly.
- The rollup's native attention runs the same function as the in-VM path; tests compare them after every layer.
Still open
- The program is upgradeable until it's made immutable, so the deployer key could still change the code.
- The rollup is a single sequencer: it posts checkpoints to Solana, but fraud proofs aren't built yet.
- The model is tiny (260K weights): coherent short stories, not a chatbot.
- Model and session deposits can't be reclaimed until a close instruction is added.
What's new
Why this is different
Most AI on blockchains is a model on a server with a wallet attached; the chain sees payments, never the thinking. Here the thinking is the transaction: a complete transformer (RMSNorm, rotary positions, grouped-query attention, SwiGLU) executes inside Solana's own runtime, every token is reproducible by anyone, and the fast path on the rollup is provably the same computation as the slow path on stock Solana. The pieces that make that work are general: an integer core that compiles to SBF and native code alike, sessions that let one token span transactions, and Step transactions that can be fired in parallel because they never name a position.
Next
Order of work
- Devnet is done: the model is locked on devnet and a first story there matched the reference token for token.
- Tighten the stock-Solana cost estimate across more stories (about 2.35 tx per token instead of 2.85).
- Add a close instruction, then deploy to mainnet and decide whether to make the program immutable.
- Train a bigger model of our own for the rollup, where compute is cheap enough for it.
Neuron Network · figures measured 2026-11-20 to 2026-11-21 on an Apple M4 Pro (local rollup node and solana-test-validator) · program address BfH35VV5cSVsxqU16YJLJQSvSKQjygY5X12Hn8Me5yMt on devnet and mainnet