We loaded it onto Ethereum and wired the output into an AMM. Now the fly brain decides what your swap costs. Live on Sepolia.

When we introduced Gas Killer, we described the Turetzky Upper Gas Limit: any deterministic computation can settle on-chain for the cost of verifying an aggregate signature plus the storage you actually need to write. We pushed this to its limits by putting an LLM fully on-chain. 

So why put the fly brain on-chain? Well, because we can!

We took the Janelia reconstruction as published and modeled every neuron in it as a leaky integrate-and-fire unit. Every one of those 25.6 million synapses carries a weight taken from the reconstruction. The graph lives on-chain across 4,196 data contracts. The model is not a pointer to a server we run somewhere, it runs fully on Sepolia.

How the brain sees a trade

A brain needs sensory input, so we gave it eyes.

For each swap intent we rasterize the market state onto a fresh 160x120 canvas. Rows encode how far the price has drifted from the pool reference, how large the order is against the reserves, and how much slippage it would cause. Those pixels land as input current on the photoreceptor neurons, exactly as an image of the world would.

Then it runs. All 166,700 neurons integrate for 1,000 steps. Four population firing rates come out the other side, and fixed published tables map them onto a fee and a skew. Fee gets clamped between 5 and 100 basis points, skew to within plus or minus 30. Buyers pay the fee plus skew. Sellers pay the fee minus skew.

Underneath it all the pool is an ordinary constant product x·y=k AMM. The difference is that every swap becomes an escrowed intent rather than an immediate fill, and the number that prices it comes out of its nervous system.

Unbounded Computation

One swap decision would normally be over 14,000,000,000 gas of computation.

Sepolia caps a single transaction at 16.78 million gas under EIP-7825. The fly is roughly 850 times past what one transaction is permitted to spend. As a normal on-chain call it cannot happen at all. But with Gas Killer we are able to do unbounded computation, ie, make on-chain transactions that go beyond the block gas limit.

The two settlements cost 406,341 gas and 355,521 gas. A reduction of over 99.9%. These are the kinds of results you’re able to get with Gas Killer.

How does it work?

A trader submits an intent and the FlySwapPool escrows the tokens without pricing them. A keeper posts a settlement task to the Gas Killer router, which validates it and distributes it to operators. Each operator independently runs the complete brain simulation off-chain.

Because the computation is deterministic, every honest operator lands on an identical result. The quorum signs that result once as an aggregate signature and posts it. The contract verifies the signature and writes a single 32-byte fill word.

That word carries the whole decision: 16 bits of fee, 16 bits of skew, 8 bits of flags, 24 bits of epoch, and a 160-bit spike root committing to all 28,000-plus spikes the episode produced. The pool reads the word and executes the swap at the brain's price.

Try it

The visualizer at gas-killer.github.io/fly-amm shows the connectome firing during a real settled swap, and you can open it full screen to watch the populations light up as the retina image hits them. The contracts are all on Sepolia if you want to go read them directly:

• FlySwapPool: 0xD9adC740c61c2362AA9649cDe79D1A20B537fa69

• FlySwapPolicy: 0x474c62c9931e5a501986f6E27AC4Cc084dFf9908

• FlyEngine: 0xB61fd991A4A6afAEf54404bA54DC6123d2B9E4fC

• Connectome directory: 0xe7c83910719ea03d80f7dd71caee4489a0a05641

What's next

We are opening API access for builders shortly, so if you want to point Gas Killer at something in your own stack, come find us in the Telegram group and tell us what you would run with a trillion gas. Check out the docs and the code.

We are also raising our pre-seed and would like to talk to people who find this as strange and promising as we do. Reach Josh at josh@gaskiller.xyz or tbsoc on Telegram.

Follow @gaskiller_ for what comes next.

Gas Killer removes that constraint. Write the contract you actually want to ship, and let an optimistic off-chain coprocessor handle the execution.

How it works

Gas Killer is a network of shared security operators that runs your contract's computation off-chain and settles the result on-chain. Each operator simulates the call independently, so no single party is trusted, and the chain verifies one signature instead of executing anything, no matter how much computation it took.

The cost of a transaction drops to essentially the cost of its real effects: the internal state changes it makes, plus any external calls, plus a small fixed overhead for signature verification. The cost of the signature verification, we call the Turetzky Upper Gas Limit (TUGL). In practice, the signature verification runs on the order of tens of thousands of gas, so iterating an array of ten thousand accounts that used to cost around twenty million gas can settle for a tiny fraction of that.

Gas Killer is optimistic. In the normal case there is no proof, just the operators' signature on the correct state transition. Zero-knowledge proofs are used to be able to verify the compute and slash operators in the case of a dispute.

If the operators ever signed an incorrect transition, any honest observer, even one outside the operator set, can reconstruct what the execution should have been and open a slashing process. The security is crypto-economic: as long as there is more at stake than value that could be extracted, the system is secure.

What this unlocks

The point is not only cheaper gas, it is that you can write straightforward contracts without thinking about gas optimization tricks that lead to potential mistakes. For example:

• Just iterate over the array. You do not have to build a mapping plus a custom data object to make a query cheap, or set up complex index fetching. Write the loop in Solidity.

• Real-time instead of snapshots. Snapshot-based governance exists mainly because you cannot iterate the voter set at execution time. Gas Killer lets you do live, always-available voting and tallies.

• Affordable security checks. Take your entire test suite and every invariant check and run them before or after each call. With Gas Killer, it does not meaningfully add to their cost. Many exploits happen precisely because contracts get stripped down for gas; this lets you keep the guards in.

• Break the block gas limit entirely. Some things are not merely expensive, they are impossible on-chain today because one call exceeds a block. The team demonstrated this by rewriting Qwen (a small language model) in Solidity and running full model inference on-chain through Gas Killer, at a cost that would otherwise be trillions of gas.

The philosophy of Gas Killer is to help make Solidity more expressive without increased complexity. You keep writing Solidity, which is battle-tested and widely understood, and you do not have to learn a new language or become a zero-knowledge specialist. The goal is to meet developers where they are and not overcomplicate.

Getting started

Gas Killer is live on the Sepolia testnet, and anyone can request an API key here. There are example contracts in our repo you can start with or try building that contract you wanted to make but couldn’t get the gas costs right..

We believe this only scratches the surface of what becomes possible with Gas Killer: on-chain games, order books, computation-heavy logic, model inference, cheaper on-chain infrastructure, and primitives that have not been built yet. If you have a contract that does real computation and you have been fighting its gas cost, or you have shelved an idea because it could not fit on-chain, this is worth a look.

Join our Telegram group and share the most computationally expensive idea you have while staying close to what’s coming next.

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.

ICYMI

Gas Killer is a shared security protocol that transforms how we think about on-chain computation. Instead of executing expensive calculations directly on Ethereum, Gas Killer uses a network of operators to simulate transactions off-chain and write back only the essential storage updates and external calls. You can think of it like an optimistic coprocessor as it’s similar to existing ZK coprocessors but with optimistic execution, only needing a proof for slashing.

To test that Gas Killer works in production, not just in theory, we needed a real contract. So we partnered with Bread Cooperative to help with reducing gas costs for their Solidarity Fund. Specifically we helped with distributing yield that was based on the input of users who hold their BREAD token (~$500k TVL).

Yield distribution is what happens when a pool of funds generates returns and those returns need to be split between numerous recipients based on votes of the users supplying the principle. In practice, this means the contract needs to read every participant's vote, calculate their share, and execute the transfers — all on-chain. The more participants, the more expensive this gets.

For this transaction to work with Gas Killer while in-production, we combined EigenCloud for economic security, Commonware for p2p signature aggregation, and Helios for bridging securely.

The Results

We calculated that running the yield distribution method fully on-chain would have cost 1,937,259 gas. Running the transaction with Gas Killer cost 779,715 gas, saving 1,157,544 gas.

That's a 59.7% reduction. This is also a function that is called repeatedly throughout the year, so ~60% recurring savings can be major for many teams. On Gnosis (where gas costs are cheap) the dollar amount is small right now, but the same function running on Ethereum mainnet (or any high fee environment) would produce proportionally larger savings. This also excludes savings on gas for the transactions users need to make for casting a vote which is 350k for a system like this.

The live transaction is publicly verifiable on Gnosisscan here.

The bigger picture

Because yield distribution computes over an array of voters, gas cost grows linearly with every participant added. More voters, more computation, more gas. Gas Killer's approach keeps the on-chain footprint flat regardless of how much computation happens off-chain.

That has an interesting implication: there's a class of transactions that are simply too cumbersome or impossible today because they would exceed Ethereum's block gas limit. With Gas Killer offloading the computation, those transactions become executable by adding one line of code. We think that's worth exploring in depth and it's something we're planning to demonstrate as a proof of concept in the future.

What's next?

Our next objective is to begin the first steps for scaling: setting up the infrastructure for a persistent Gas Killer service on the Ethereum mainnet. Once it’s live, Gas Killer goes from a proven concept to something developers can integrate into a production application on Ethereum.

Expect more from the team in the coming months. In the meantime, if you’re building something brushing up against gas limits, reach out to contact@gaskiller.xyz for inquiries and early access.

Learn more about how Gas Killer works here.

This means that no matter how computationally intensive a smart contract function is, Gas Killer can theoretically reduce its gas consumption to just the cost of verifying a signature (250k gas) and updating state. For privacy protocols, which rely on heavy cryptographic operations, this represents a fundamental shift in economics where privacy can be more affordable for everyone.

In this case study, we'll break down how we calculated Gas Killer to be able to cut gas costs in half for RAILGUN, one of the most popular privacy protocols on Ethereum. We specifically analyzed their Relay contract and its two main methods, shield and transact.

What is RAILGUN?

RAILGUN is a privacy protocol that allows users to conduct shielded transactions on Ethereum while maintaining compatibility with some DeFi protocols. RAILGUN enables you to hide transaction details (sender, recipient, amount) by converting public funds into "shielded" funds, which are then kept private until withdrawal. To do this they use zero-knowledge cryptography, specifically zero-knowledge Succinct Non-Interactive Arguments of Knowledge (zk-SNARKs), to prove transaction validity without revealing the underlying data.

However, privacy on Ethereum comes at a steep cost. RAILGUN enables users to shield their transactions and protect their financial privacy, but the complex zero-knowledge proofs and cryptographic operations required mean users can pay a hefty fee for a single private transfer. While RAILGUN has recently experienced an increase in usage and interest with the Kohaku wallet announcement from the Ethereum Foundation, this cost barrier has prevented privacy from becoming accessible to everyday users, limiting adoption to only those who can afford the premium, making decreasing the costs paramount to adoption of privacy preserving protocols.

One of RAILGUN’s main smart contracts is its Relay contract which has two main methods:

Shield: Converts public tokens into private shielded tokens by depositing them into the privacy pool using zero-knowledge proofs. This creates a commitment that hides the depositor's identity while proving they own the funds.

Shield method calls tend to hover around 720k to 750k gas.

Transact: Performs private transfers, withdrawals, or interactions with DeFi protocols. This function processes the zero-knowledge proofs that verify the transaction is valid without exposing the sender, receiver, or amount.

Transact method calls can range from 450k to 1.15M gas.

Both operations involve computationally expensive cryptographic verification that consume substantial amounts of gas. There are more complexities to the system but we focused on these two methods for this analysis.

RAILGUN Relay Analysis

To help us with understanding the savings that Gas Killer can potentially yield, we created the Gas Analyzer, a tool that simulates historical transactions as if they were routed through Gas Killer to identify the savings possible. By feeding actual RAILGUN transactions through the tool, we can pinpoint approximately how much gas savings Gas Killer could achieve for RAILGUN and its users in its current state.

The analyzer examines the execution trace of historical transactions, categorizing gas consumption by operation type and calculating potential savings. Gas Killer is able to abstract away all operations that are internal reads and computation as well as some external reads.

For this analysis we took 100 shield and 300 transaction method calls that were performed successfully during the month of October 2025 and calculated the potential Gas Killer gas savings using the Gas Analyzer tool. We created a dataset for each method that included the gas used for the original method call as well as savings output when run through the Gas Analyzer.

For shield method calls our results showed that Gas Killer could save 40.9% in gas savings on average and for transact method calls we found a 53.9% gas savings on average. Our analysis showed that an integration with Gas Killer could cut total gas costs nearly in half for users of RAILGUN!

These savings are expected in large part because zero-knowledge proofs are still computationally expensive on Ethereum. If you’re interested in seeing whether Gas Killer can get your app or protocol some gas savings then reach out at contact@bread.coop or press the button below.

What's Next?

At the moment we’re still hard at work on getting to mainnet but it shouldn’t be too much longer. But let’s say Gas Killer was already deployed on mainnet, what would be the next steps for RAILGUN to integrate Gas Killer and pass on savings in gas to users?

First it would require potentially one of the easiest contract upgrades possible. RAILGUN developers would need to add one line of code per method which would point them to the Gas Killer network to be computed. Once that is done, then all shield and transact method calls would be sent to the network which would return the output onchain with BLS signature aggregation. And that’s really about it.

But what happens if there’s something wrong with the network?

Gas Killer is designed so that no operator of the network is able to return an incorrect or fallacious output. If they do, it is rejected via the protocol and the operator risks getting slashed. If there is a situation where the network is down or something similar where a transaction cannot be pushed through Gas Killer, the transaction defaults to run onchain, the old school way. Therefore, integrating Gas Killer introduces very few new risks for protocols and applications. Gas Killer avoids being a bottleneck while providing gas savings for users.

Privacy should not be a luxury reserved for those who can afford expensive gas fees. Cutting RAILGUN gas costs in half would make privacy within reach for more users and in turn make its privacy pool stronger. This democratization of privacy is essential for adoption.

With the Ethereum Foundation’s renewed focus on cypherpunk values and the proliferation of zero-knowledge proof implementations, Gas Killer is important infrastructure for scaling privacy.

The Problem

Ethereum's gas costs have created a fundamental barrier: complex computations that involve multiple storage reads, calculations, and state updates are prohibitively expensive for mass adoption.

Simple operations that are negligibly cheap on a single computer like computations on a dynamic array are too expensive to do on the Ethereum mainnet. Layer 2 EVM blockchains have helped with scaling however they have also produced a fragmented ecosystem and capital, making it difficult to onboard new users. It has also pushed value away from the Ethereum L1, the original blockchain that brought many of us together in the first place.  

For many use cases, the cost of computation has made otherwise valuable applications economically unviable. This limitation in computation affects everyone. From privacy protocols requiring heavy cryptographic operations to applications needing complex on-chain logic, on-chain computation must scale in Ethereum.

This is where Gas Killer comes in.

How Gas Killer Works

Gas Killer is a shared security protocol that transforms how we think about on-chain computation. Instead of executing expensive calculations directly on Ethereum, Gas Killer uses a network of operators to simulate transactions off-chain and write back only the essential storage updates and external calls. You can think of it like an optimistic coprocessor.

The core innovation is simple but powerful: replace complex on-chain operations with aggregate signature verification. When a transaction comes in, Gas Killer's operators execute the logic off-chain, compute the final state changes, and return an aggregate signature proving the computation was performed correctly. The smart contract then verifies this signature and applies the storage updates and external calls—consuming a fraction of the original gas cost.

The important caveat is that Gas Killer is able to save gas specifically on all internal reads (reading from within a contract’s own storage or memory during execution), some external reads (calling another contract to fetch data) and computation (arithmetic, logic, or cryptographic operations inside the EVM). So any storage writes needed will still need to be paid for through gas fees. Additionally the aggregate signature verification will also incur a cost every time Gas Killer is used.

Taking the implications of Gas Killer adoption to its conclusion, it implies the existence of what we call the Turetzky Upper Gas Limit (TUGL), or that on any deterministic blockchain, any function with internal reads and calculations above the cost of aggregate signature verification can be reduced to just that verification cost plus necessary storage writes. In other words, no matter how complex your computation, Gas Killer can bring it down to a theoretical minimum.

If you’d like a more detailed and technical explanation of how Gas Killer works, be sure to subscribe here.

The best part about all this is that in order to use Gas Killer for their method, developers will only need to add a single line of code. No reworking of any smart contract logic, no need to learn a new programming language, no other changes need to be made and you and your users can save on gas fees.

This means at least two very big things.

1. Smart contract developers do not need to do nearly as much gas optimizations as what is the norm today. Instead of optimizing for gas costs, developers can now optimize for other things like security or expressiveness. This also means we can do calculations on dynamic arrays! 

2. We can now run methods that go beyond the block gas limit. No matter how complex the computation, even if it’s more gas than is technically allowed in a block, Gas Killer can run it. Of course the exact extent of how far this can go needs to be tested but it should be ok if it can be run on a single computer.

We believe Gas Killer is just the start of a Cambrian explosion of new use cases and applications that it can enable. Some of the areas where we’ve already found Gas Killer to be a potential scaler includes:

• Voting mechanisms

• Privacy

• ZK Proof verification 

• Deep Infrastructure 

• On-chain Art

• Token Rebasing

• On-chain AI

• Airdrops

• Slow DeFi

• Gaming

And we’re excited to see everything else that others will be able to build now with Gas Killer that we can’t even imagine at this point in time.

Ready to Test Gas Killer?

We're proud to share that Gas Killer v1.0 is now released and soon will be operational on testnet, Ethereum mainnet and Gnosis Chain. If your organization is dealing with high gas costs and wants to explore whether Gas Killer can optimize your smart contracts, we want to hear from you. We're actively working with early partners to test integrations and demonstrate real-world gas savings.

Whether you're building privacy infrastructure, complex financial protocols, or any application where gas costs are a barrier, Gas Killer could fundamentally change your economics. Fill out our form and our team will reach out to discuss how we can help optimize your contracts.

What's Next

Over the next three months, we'll be conducting comprehensive research on Gas Killer's impact across different use cases, measuring exact gas savings, and working with partners to prove the real-world benefits. Our goal is simple: to super scale Ethereum computation.

The future of Ethereum isn't just about scaling transactions—it's about scaling computation. Gas Killer is here to make that happen.

Want to learn more? Follow us on X and subscribe for technical deep-dives, case studies, and updates as we continue building. Have questions? Reach out to our team through the form above.