A factory for the decision layers AI is missing
The mega-labs are building one layer of the AI stack: the models. The layers that decide which model to call, which tool to use, which context to retrieve, which prompt strategy fits — those sit in internal scripts or get absorbed into lab margin. Hokusai is the protocol for building them as shared infrastructure instead, owned by the engineers who improve them.
Rework Risk and Model Match come first. The same primitives apply to every other decision where outcomes from many Integrators can train one shared model.
How it works
An Integrator routes decisions through a Hokusai model.
Every decision call pays a small per-decision fee in USDC. For Model Match, that's a fee per coding task routed. Integrators get a smarter decision than they'd make with hardcoded rules, and the fees flow into the model's bonding curve.
Outcomes feed back to the model.
What actually happened afterward: whether the task succeeded, what it cost, how long it took, and whether the work later needed fixing. Outcomes are attributed on-chain to the Contributor who supplied them. The model gets better.
Contributors earn a position in the fee stream.
When outcome data produces a measurable improvement — a DeltaOne — the protocol mints tokens to the Contributor who supplied it. The token is a position in the model's fees, not a speculative asset. Hold it, or redeem for USDC anytime.
Two roles, often the same person
Integrators
Integrators route tasks through a Hokusai model. They pay the per-decision fees and they get a better decision than they'd make alone. Commercial Integrators can keep the resulting token flow as a new revenue line. OSS Integrators can pass it through to their users as an ownership feature.
Contributors
Contributors supply outcome data — what happened after a task ran or a change merged — that makes the model better. In practice, most Contributors are also Integrators: the same agent system that consults a model generates its outcomes. The token rewards flow to whoever the Integrator configures at integration time.
What backs the token
Each Hokusai model has its own token and its own bonding curve. The curve fills with USDC from two sources: per-decision fees paid by Integrators, and direct USDC contributions when a buyer wants a position in the model.
DeltaOne mints tokens to Contributors when their data lifts the model's measured performance. Those tokens redeem against the USDC in the curve, which is funded by real per-decision fees from the Integrators who use the model.
The token is a position in a real fee stream, not a position in a metric. The metric — DeltaOne — is just how the protocol decides who earned what.
DeltaOne and bonding curves, under the hood
For Integrators and Contributors who want the mechanics: how DeltaOne maps to tokens, how fees enter the curve, and how redemption works.
Each Hokusai model has a performance metric and a fee-backed economic loop matched to the decision layer it serves. Under the hood, the protocol creates a token for that model, and the token represents a position in that model's fees.
Hokusai uses DeltaOne as a unit of measurement for performance improvement. For example, improving Model Match's cost-adjusted task success from 42% to 45% would represent 3 DeltaOne units.
Each DeltaOne unit mints a predetermined amount of tokens, creating a direct link between measurable model lift and Contributor rewards.
Each model also has a bonding curve funded by Integrator fees and direct USDC contributions. The amount a Contributor earns for a DeltaOne improvement depends on the USDC already in that curve and the model's mint schedule.
This creates strong incentives for Contributors to supply high-quality outcome data and for Integrators to route more decisions through the shared model. Tokens can be converted to USDC at any time if crypto gives you the ick.
Core protocol properties
Automated attribution
Every outcome is attributed on-chain to the Contributor who supplied it. No judging committee, no off-chain bookkeeping.
Earned ownership
Tokens are minted in proportion to a Contributor's measured impact on the model — not for showing up, not for staking, not for governance theater.
Fee-backed value
Every Hokusai model is funded by the per-decision fees Integrators pay to use it. Tokens redeem against that fee stream, not against a promise.
Privacy by scope
Your data only ever trains the specific model you contribute to. Hokusai does not share, resell, or use contributions to train anything else.
Agentic coding decision layers
Hokusai starts with decision points inside agentic coding systems and code harnesses. Rework Risk is in early access and Model Match is live; the next layers are the operating policies every harness currently reinvents in private.
Outcome Prediction / Code Changes
Rework Risk
Predicts which pull requests will need corrective rework within 30 days of merge, learned from what actually happened across many codebases.
See how it works →Model Selection / Multi-Model Coding
Model Match
A model router for multi-model coding harnesses: recommends a model from your pool for each task, learned from real routing outcomes.
View model details →Tool Use / MCP Selection
Tool Match
A shared policy for deciding which tool or MCP server to call, in what order, and when to retry based on real harness outcomes.
See roadmap →Context / Memory
Context Match
A decision layer for choosing which memories, files, and context windows are worth loading before an agent spends tokens.
See roadmap →Review / Quality
Reviewer Match
Selects the reviewer model or ensemble most likely to catch the bug classes present in a diff.
See roadmap →Build on the protocol
Got a decision layer worth sharing?
If you've identified a routing, selection, or optimization problem that today gets solved in scripts or captured by labs, Hokusai's primitives DeltaOne measurement, bonding-curve incentives, on-chain attribution give you a path to build it as a shared, owned model. We provide protocol access, support, and may take a token position alongside you.