Cover photo

We Put a Language Model On-Chain

Verifiably deterministic AI, running on Ethereum

We've run a large language model directly on-chain on Ethereum with fully deterministic, verifiable outputs—settling standard LLM inference for a tiny fraction of traditional costs. Try the live demo right now at llm.gaskiller.xyz.

Play Video

Check out the demo here and subscribe on YouTube!

When we introduced Gas Killer, we described the Turetzky Upper Gas Limit: the idea that any computation, no matter how complex, can be reduced to the cost of aggregate signature verification plus necessary storage writes. That includes computations that go beyond the block gas limit entirely.

An LLM is about the most extreme test of that claim we could think of. A single answer from a large model represents trillions of gas worth of computation, orders of magnitude past what a block can hold. If Gas Killer can run that, it can run almost anything. So we built it.

What We Built

We took a local LLM, Qwen, and put the entire thing on-chain, not a pointer to a server. The weights are stored on-chain as raw bytes and the architecture (the actual sequence of math that turns a prompt into an answer) was reimplemented as a smart contract in EVM bytecode.

Because the whole model is on-chain code operating over on-chain data, the computation is fully specified by the chain itself. The most important consequence of this is determinism. The EVM executes the same bytecode the same way on every machine, so the same prompt with the same information always produces the exact same output. 

Why Determinism Is the Whole Point

Standard GPUs running LLMs use floating-point math in order to produce outputs from prompts. Floating-point math rounds differently across hardware, libraries, and execution order, and those tiny differences compound across billions of operations.

Our on-chain version removes that. It runs as integer math on a single deterministic virtual machine with a fixed execution order. There's no rounding to drift and no hardware variance. It's something anyone can independently reproduce and verify. 

Running LLM inference on-chain the naive way is impossible. A single answer from a 35-billion-parameter model represents roughly 3.6 trillion gas of computation, far beyond any block limit. As a normal transaction, it simply cannot happen.

We settle it for around ~350,000 gas, and we expect to push that lower with optimization. That's about a 9.4 million times compression in on-chain execution cost.

When you submit a prompt, operators run the on-chain model's computation off-chain. Because the bytecode is deterministic, every honest operator arrives at an identical result. Those results are aggregated into a single aggregate BLS signature and posted on-chain, where the contract verifies the signature and settles the result. 

Try It Yourself

Two models are live on Sepolia right now: a 35-billion-parameter Qwen3.5 model, which takes a bit over an hour to produce an answer, and a smaller half-billion-parameter Qwen3 model, which returns in about four to five minutes.

There's also a section on the page explaining the security model behind all of this, worth a look if you want a deeper picture of how operators commit to results.

Where This Goes

We believe that the opportunities for this kind of onchain AI can be summed up as: verifiable, tamper-proof judgment over on-chain data. A few directions we find compelling:

  • Agent arbitration and dispute resolution, where two parties or agents disagree and need a neutral call nobody can claim was rigged

  • Credit reporting and similar judgment calls, where the reasoning behind a decision needs to be auditable rather than opaque

  • Any reasoning over data that already lives on-chain

  • Fair, verifiable automation that a contract can act on without trusting whoever ran the model

What's Next

There is plenty of room for improvements to be made. These models were built for floating-point math and then made to run as integers. Architectures designed from the ground up for integer arithmetic, like BitNet-style models, are a natural fit for on-chain execution and should cut runtimes, making larger models practical on-chain. It's a direction we're excited to explore.

We are going to be opening up API access for builders to start using Gas Killer very soon so be sure to join the telegram group for the latest information.

We're also opening our pre-seed round, and we'd love to talk with people who find this as interesting as we do. Reach out to Josh at josh@gaskiller.xyz, or tbsoc on Telegram.

Try the demo at llm.gaskiller.xyz, and follow us on X for what comes next.