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.

Neuron rollup: live locally Stock Solana validator: verified Devnet: first story verified Mainnet: next
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.

CLIENTS PROGRAM RUNTIME CORE Website hero replay · terminal page Agent terminal terminal.cjs · 4 sessions Story runners live.cjs · run-chain.cjs chain.cjs · tokenizer · upload · sessions · Step batches live feed upload · start · Step txs reads session neuron_llm program Init · Write · Finalize · Start · Step Model account 313,751 B: int8 weights + scales SHA-256 locked at Finalize Session accounts one per story or character tokens · residual · KV cache bytecode build sol-infer build Solana (stock validator) devnet → mainnet packed int8 kernel inside the VM ~4 tokens per block per story Neuron rollup (solana-svm) one sequencer, 400 ms blocks matmul + attention as syscalls ~125 tokens per block checkpoints neuron_settlement neuron-llm-core one integer-only forward pass, compiled into the program, the sequencer and the host
Clients only send transactions and read accounts. The program owns the model and the sessions; the rollup runs the same program with two hot paths moved into native code, and posts state-root checkpoints 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.

neuron-llm-core no_std Rust · Q16 fixed point forward pass · attend_head Reference + Packed kernels Host CLI + tests Reference kernel · the oracle neuron_llm.so Packed kernel · stock Solana Sequencer syscall runs attend_head natively neuron_llm_rollup.so attention + matmul via syscalls linked in compiled in linked in compiled in same session bytes after every layer calls sol_infer_attn_i8(args)
Four copies of one function. The dashed edge is the lockstep test (the same check runs against the rollup build); the solid teal edge is the rollup build handing attention to the sequencer, which runs the identical core code natively.

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.

any Step continues from where the last one stopped a unit: one layer or the classifier Step tx Session pos · layer x · KV cache Embed token row Layer × 5 RMSNorm → qkv → RoPE KV write → attention out → SwiGLU FFN Classifier 512 logits Sample greedy / seeded token appended + logged · next position
Everything a token needs between transactions lives in the session account: position, which layer is next, the residual vector, and the int8 key/value cache. That is what lets one token span transactions, and many Step transactions share a block.

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.

STOCK SOLANA Step tx SBF VM · metered, 1.4M CU per tx layer glue norms, RoPE matmul packed kernel attention in bytecode 2.85 tx per token ~4 tokens per block per story NEURON ROLLUP Step tx SBF VM layer glue norms, RoPE, sampling native syscalls sol_infer_matmul_i8 sol_infer_attn_i8 0.27 tx per token ~125 tokens per block
The two teal hops are the whole difference. Stock Solana is capped by its 12M compute units per writable account per block, which is why one story gets about four tokens per block there; separate stories run in parallel.

Measured

The numbers so far

WhatResultHow it was measured
Model on chain313,751 bytesUploaded in 329 transactions, each under the 1,232-byte packet limit, then locked by its SHA-256rollup + stock validator
Stock Solana build2.85 tx / tokenA full 255-token story, 2.43M compute units per token, no transaction over its limitsequencer test, plain bytecode
Stock Solana validator≈4 tokens / block123-token story on solana-test-validator, identical to the off-chain referencerun-chain.cjs, Agave 3.0.13
Neuron rollup build0.27 tx / token0.36M compute units per token with native matmul and attentionsequencer test, sol-infer build
Live rollup node369 tokens / s251 tokens in 0.68 s across 2 blocks, over RPC, byte-identical to the referencenpm run llm:live -- --greedy
Integer vs float114 of 255Tokens 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

  1. Devnet is done: the model is locked on devnet and a first story there matched the reference token for token.
  2. Tighten the stock-Solana cost estimate across more stories (about 2.35 tx per token instead of 2.85).
  3. Add a close instruction, then deploy to mainnet and decide whether to make the program immutable.
  4. 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