Blockspace is the capacity of a blockchain to finalize and commit operations. Over the last 16 years, what we pack into that precious space has evolved in three sweeping chapters:
- Era 1: Move Numbers (2009). Bitcoin proved value could move without banks.
- Era 2: Move Logic (2015). Ethereum embedded self‑executing code next to balances.
- Era 3: Move Meaning (2025). OpenGradient makes intelligence the native asset of a ledger.
Welcome to the third era, where a block records not just what happened and how, but also why.
A Story in Three Acts
Every paradigm shift starts with a tension, a breakthrough, and a horizon.
Act I The Black‑Box Tax
A treasury wants dynamic fees, a hospital dashboard needs early warnings, a game craves smarter NPCs. Each turns to an off‑chain model—and must now believe what no validator can inspect. Latency creeps in, budgets blur across fiat and gas, and the audit trail disappears behind an API key. Innovation stalls under the weight of trust.
So we asked: what if the trust gap could shrink to a single proof?
Act II A Ledger That Thinks
OpenGradient embeds the computation itself into consensus. A transaction, its prediction, and the proof of that prediction share a single Merkle root. No sideband oracles, no secret endpoints — just block N capturing both the choice and the reasoning.
When proof becomes native, something new emerges.
Act III A Commons for User-Owned Intelligence
Model outputs now settle like balances, turning every model into forkable public infrastructure — owned by the people who train and fund it. Builders branch, fine‑tune, and merge weights as easily as code, earning from every inference their fork powers. Liquidity comes in two flavours: tokens and data — and both flow where users point them.
Why Status-Quo Compute Fails
Picture a swap in mid‑flight. The signature is valid, the gas is paid, the ledger is ready—then the contract whispers off‑chain for a routing hint, and the spell breaks.
- Lag The request sprints through fibre, idles in a GPU queue, and returns 1.2 seconds later — three whole rollup blocks of slippage risk.
- Fog What comes back is a raw vector. No proof, no replay, no audit. Drift or bribery can hide in a single decimal place.
- Leak Inference is billed in dollars, settlement in wei. Two meters, one budget spiral.
A classical chain must either replicate billions of FLOPs on every validator (and choke) or outsource them (and pray). As models inflate from GPT‑2’s millions to o3’s trillions of parameters, the fault line only widens.
OpenGradient adds native intelligence to the block — latency trimmed, proofs attached, cost paid in the same unit that secures value.
How It Works
What happens when you treat computation as a first‑class citizen of blockspace, instead of an awkward addon? You get OpenGradient’s architecture: a choreography of specialized nodes, cryptographic short‑cuts, and data rails that fuse AI genius to the same root of trust that moves ETH today.
- OpenGradient SDK — Your First Tool
Skip straight to code. The Python SDK lets any off‑chain script or backend hit the same verifiable inference pipeline your smart contract will use on-chain.
import opengradient as og
og.init(private_key="<hex>", email="you@example.com", password="hunter2")
# upload a model
og.create_model("my‑model", "demo", "/path/to/onnx")
# run inference
result = og.infer(
model_cid="<cid>",
model_inputs={"text": "hello world"},
inference_mode=og.InferenceMode.VANILLA,
)
print(result)Full docs live at docs.opengradient.ai — but this is enough to ship your first verified prediction.
- Constellation of Specialists — Node Roles
A ledger that thinks needs more than one kind of neuron. OpenGradient’s Hybrid AI Compute Architecture spins four roles into orbit:
- Full Node — The Judge
Runs the EVM state‑transition function, re‑executes every transaction, and verifies the ZK proofs or TEE attestations supplied by the other roles. Once its derived state root matches peers, the Judge gossips the header — any prediction that passes is as final as a token transfer. - Inference Node – The Sprinter
Stateless GPU/TPU worker. It streams weights from Librarians, performs the forward pass, and returns output + (ZK proof or TEE attestation). Add more Sprinters to scale throughput; Judges only process a 10 kB witness, never the gigabytes of raw math. - Storage Node — The Librarian
Maintains the decentralized filestore. It shards model checkpoints, serves them over Walrus, and keeps version history. Delta syncs mean even 100‑GB models arrive in minutes, not hours. - Data Node — The Scout
Boots inside an AWS Nitro (or Intel TDX) enclave, opens a TLS tunnel to external APIs, and signs the payload with an attestation that Judges can verify. Contracts get facts from the outside world without trusting a black‑box oracle.
Together these four roles write their own slice of the witness; Judges stitch the pieces into one immutable story before finality.
- PIPE — Parallelised Inference Pre-Execution Engine
Imagine Alice, a Solidity dev, submits a transaction that calls callModel(). The moment she clicks Send, the chain moves in five tight steps:
- Park. The sequencer funnels Alice’s transaction into a dedicated Inference Mempool, separate from ordinary gas bidding.
- Detect. A lightweight simulator scans the byte-code, pulling out each model request.
- Fan-out. Jobs shard by (modelID, promptHash) and fly to Bob and the other GPU operators. More shards, more parallelism.
- Race. Bob’s node and its peers compute forward passes, attach proofs, and broadcast results. The first valid bundle wins the fee; duplicates are discarded.
- Stitch. The sequencer recombines outputs with the original transaction, hands it to the block builder, and the chain seals without ever waiting on the slowest model.
Speculative duplicates spin up automatically if a job lingers, so a sluggish language-model call can’t jam block production. Alice’s contract state advances on schedule, Bob earns his reward, and block time stays feather-light.
- Proof & Attest — Certainty on a Slider
A single boolean in the call flips the lever.
But a lever is useful only if everyone can inspect the result — so the next piece is making those proofs travel with the block.
- Evidence That Travels — Inference DA
Every inference leaves a cryptographic breadcrumb baked into the block itself. ZK receipts, TEE attestations, even optimistic‑challenge hashes sit beside calldata—never on a side server. A light client on a phone can fetch one header, re‑run the verifier, and prove the model thought exactly what the chain claims it did. Once a block lands in consensus, the ledger safeguards both the coins and the calculus that moved them.
- The Neuro Stack — Many Chains, One Scalable Framework
Neuro Stack lets teams spin up rollups that keep their own tokens and rules yet tap OpenGradient’s AI engines as a service. An inference call leaves your chain, specialized nodes on the hub compute it, and a proof comes back inside the very block that advances your state.
Builder Wins — Five User‑Owned Blueprints
- MemSync — Portable Memory Vaults for Agents
Develop a platform for user-owned data and memory, where users are able to collect their own digital footprint across their use of different applications and utilize them to empower their own use of AI. - Prism — Private Learning Twin
A student’s wallet stores both her study notes and a fine‑tuned tutor model. Only her key can unlock or upgrade the model, and any third‑party app that queries it streams royalties straight back to her. - Pulse — Sovereign Health Agent
Wearables stream encrypted vitals to a model keyed to the user’s address. Alerts land in their inbox, anonymised insights can be sold to researchers, and the revenue lands where the heartbeat lives—on the user’s hardware wallet. - Mosaic — Crowd‑Curated Style Synth
Illustrators co‑mint a style model; every on-chain remix auto‑splits fees to the exact wallet that provided training art. Forks need creator signatures, not a platform’s blessing. - Chorus — Fan‑Powered Remix DAO
Supporters crowdfund a music model, vote on remix contests, then earn proportional royalties each time a track is pressed on-chain. Musicians, mixers, and fans share one revenue graph.
Quick Testnet Setup
- Install MetaMask or any other ETH wallet and create an ETH account.
- Add network manually → Settings > Networks > Add Network
- Network name: OpenGradient Testnet
- RPC URL: https://eth-devnet.opengradient.ai
- Chain ID: 10744
- Currency symbol: ETH
- Switch to OpenGradient Testnet (upper‑left network selector).
- Request test ETH at https://faucet.opengradient.ai/
- Deploy with Ethers.js — starter contracts with baked‑in inference live in our examples repo.
Horizon of Gradients — What Comes Next
Compute keeps racing forward; proof systems keep collapsing in size. That momentum points to a world where:
- An indie dev spins up an AI‑speaking rollup over a weekend,
- A village grid prices tomorrow’s sunlight with its own forecasting twin,
- A DAO of nurses ports a diagnostic agent from wristwatch to field clinic—without handing over the weights.
None of this needs permission, only blockspace that can think and the curiosity to push it. OpenGradient is that canvas.
If you’ve got a model, a dataset, or a half‑finished idea, drop into our Discord on the channel #💡 | model‑ideas.
Let’s see how far blockspace can evolve when intelligence itself is provable — and user-owned.
%20(1).jpg)
