A programmable
economy for hiring
verifiable workers.
The internet learned to read, then write, then own. What it has never been able to do — safely — is act. IOI is the operating system for that final primitive.
Web1 was Read.
Web2 was Write.
Web3 was Own.
Web4 is Act.
Before we go further: what IOI is, and what it isn't.
- A chatbot.
- A model marketplace.
- A wallet bolted to an LLM.
- Policy-bound execution.
- Authority-scoped credentials.
- Verifiable receipts for every consequential action.
- Settlement for completed work.
A fuzzy mind cannot be trusted with a deterministic ledger.
Today's AI is brilliant and probabilistic. Capital systems are rigid and unforgiving. Stapling one to the other has produced Web 3.5 — and left every user holding the liability.
Modern models hallucinate, drift, and improvise. Blockchains do not negotiate. The structural mismatch between probabilistic reasoning and deterministic settlement is why autonomous software cannot yet safely hold authority over capital, credentials, or private data.
The prevailing fix bolts an LLM onto a wallet and hopes for the best — a dangerous coupling in which fuzzy logic controls hard money and the human absorbs every failure mode.
IOI takes a different approach. We do not try to make a model's thoughts deterministic. We put a cryptographic boundary around its actions. Inside the boundary, models reason creatively. At the boundary, every action is policy-checked, single-shot, and resolved into a verifiable receipt before it is allowed to move money or mutate state.
We call this boundary the Determinism Boundary. It is the load-bearing idea of Web4.
From Prompt-Safe
to Action-Safe.
Filtering a model's outputs is fragile. Constraining its actions is structural. As systems become tool-using, memory-bearing, and self-improving, prompt-level safety is the wrong layer to bet civilization on.
IOI shifts the alignment target from making the process of intelligence safe to making the consequences of intelligence governable.
Alignment through Authority.
Models think freely. The moment they attempt to touch the outside world — spend, sign, move, deploy — they hit the Agency Firewall. The system never asks what the model meant. It evaluates one deterministic rule: does this specific action strictly comply with the user's explicit policy?
Zero-exposure credentials.
Legacy agents hold API keys and hope nothing leaks. IOI agents request effects, not keys. The Kernel keeps credentials inside a sovereign vault and injects authority only at the moment of approved execution. A jailbroken agent cannot exfiltrate what it never receives.
Receipt-bound accountability.
Every consequential action resolves into a policy-checked receipt — a shared artifact that users, enterprises, developers, providers, and dispute systems can replay, audit, settle, and remedy against. Action becomes evidence.
Self-improvement, governed.
As agents rewrite their own tools, code, and policies, traditional systems must take it on faith that the upgrade preserves the constraints that made the agent safe. IOI replaces that faith with a cryptographic transaction.
The Monotonic Policy Invariant is an evolutionary ratchet: an agent may become more capable — better logic, sharper tools, smarter strategy — but it cannot become less constrained. Loosening a spend limit, a data boundary, or a consent requirement requires explicit human approval. Recursive evolution becomes a controlled capability rather than an open-ended trust leap.
Act inherits the guarantees of Own.
Automation can act without ownership — a Web2 bot can send an email — but it cannot be held accountable. Sovereign Act must carry the same canonical, replayable, settleable, remediable properties that Web3 gave to value.
The internet learned to publish. Information became universally accessible.
Users became authors. Platforms became the medium. Expression scaled.
Value became programmable. Ownership became cryptographically settleable.
Software becomes an accountable economic actor. Authority becomes executable.
Stop renting tools. Hire workers.
Software-as-a-Service sells you a seat to a dashboard and asks you to supply the labor. Service-as-a-Software sells you the outcome. IOI calls this SaS, and it dissolves the structural waste of the SaaS era.
Developers no longer pay for 24/7 idle compute; their agent logic lives as portable Worker Manifests on decentralized storage and is hydrated only at the moment of execution. Users only pay for verified success — if the agent hallucinates or fails the success rubric, the provider wastes their compute, not the user's money.
Routing consequential labor, not just inference.
The Internet of Intelligence will not be a single monolithic model. It will be a routed supply chain of specialized agents — each one bounded, accountable, and rentable.
Just as Mixture of Experts routes inference across model components, Mixture of Workers routes consequential labor across specialized agents. A Planner Worker acts as the general contractor; it decomposes the user's intent and hires the sub-workers it needs.
The Attribution Graph ensures every upstream contributor retains credit when their work is composed downstream. A single user payment is automatically split into micro-royalties paid to every developer in the chain — turning the AI economy from zero-sum competition into composable collaboration.
A coherent surface architecture across the full spectrum of demand.
Four surfaces. Demand generation on one side; infrastructure authoring on the other. Each speaks to a distinct buyer and clears through the same canonical settlement layer.
The top-of-funnel conversational surface. Users express fuzzy intent; the platform routes them to secure Provider nodes. The moment a prompt crosses from information into action, the request is escalated to the user's local Autopilot.
The native local runtime and power-user shell. It runs on the user's device — zero-latency, fully private — and enforces the Agency Firewall. Sovereign memory lives here. Agents can run on local data at zero marginal cost.
The supply-side marketplace for builders and orchestrators — the App Store for autonomous building blocks. Listings are programmable capabilities: browser-QA graphs, KYC pipelines, ingestion workers, planners.
The demand-side storefront for finished business outcomes. Components from aiagent.xyz are assembled into SLA-backed Service-as-a-Software contracts. Enterprises buy results, not worker topologies.
Capture value at the verification boundary, not the inference layer.
Every agentic workflow resolves into a four-stream Micro-Split Settlement. The total cost of work is canonical, transparent, and protocol-enforced — paid the moment the receipt is issued.
Compute
→ ProvidersMarket-priced hardware execution. GPU and CPU time, paid to the physical host of the verified execution environment.
Settlement
→ MainnetStandard network fees for anchoring escrows, receipts, and disputes to the L1.
Royalties
→ DevelopersProtocol-enforced routing of declared fees to the owner of the invoked Service NFT. Pure profit for supplying the IP.
Routing
→ ProtocolA micro-cut captured by the network for orchestrating cloud offloads and matching providers to demand.
The Fiat-to-Gas Flywheel.
Retail users are not asked to buy tokens. The ioi.ai surface accepts ordinary Web2 fiat subscriptions — $20/month, credit card, no wallet, no seed phrase.
Behind the curtain, the Solver Network captures the fiat and uses its own token reserves to open Delegated Sessions on the user's behalf. As prompts flow, Solvers pay Labor Gas and Developer Royalties in real time.
The result: a massive, stable liquidity hose of Web2 capital flowing directly into the Web4 AI economy — with the blockchain entirely abstracted from the user.
Three vertices. One ledger.
The IOI economy is a triangle held in tension. Three stakeholders — each indispensable, each captured by the same canonical settlement event. No one's reward depends on another's loss.
Users
Purchase verified outcomes with absolute data sovereignty. Pay only for successful, cryptographically proven work. Walk away from failures without losing capital.
Providers
Earn revenue for supplying raw compute and maintaining secure execution environments. Take provable execution risk in exchange for hardware-priced returns.
Developers
Earn Royalty-on-Execution whenever their agent's intelligence is rented. Never incur idle server costs. Compose freely; get paid through the Attribution Graph.
The Internet of Intelligence is not a marketplace for buying models. It is a programmable economy for hiring verifiable workers.