IOI Vision & Economics Litepaper
The Web4 action-layer thesis for hiring verifiable workers, routing consequential labor, and pricing work at the verification boundary.
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.
- An unconstrained agent loop.
- A wallet bolted directly to an LLM.
- Process-level containment (the determinism boundary).
- Sovereign sidecar compatibility (Cursor, VS Code, Claude Code).
- Authority-scoped credentials via ephemeral leases.
- Verifiable receipts for every consequential action.
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, behavioral model alignment is the wrong layer to bet civilization on.
IOI shifts the alignment target from making the process of intelligence safe (trying to make the AI "think" safely) to making the consequences of intelligence governable. We implement process-level alignment: a low-level, deterministic sandbox that intercepts and bounds proposed actions before they cross into consequence.
Deterministic Execution Harness.
We neutralize model hallucinations at the operating system boundary. The local daemon utilizes AST-level sandbox syntax checking, mock clock overrides (__AWRP_STEP_TIMELINE), and PRNG hijacking to guarantee that even probabilistic model output compiles to a predictable, bounded state before execution.
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.
From lightweight background sidecars to native operator consoles. We separate the security engine from the developer interface, eliminating migration friction.
The conversational entry point. Users express fuzzy intent; the platform parses and routes the tasks. If the intent requires action, the request is escalated to the local daemon before crossing the determinism boundary.
The canonical operator workbench. An Electron-first shell featuring visual timeline views, active model-mounting controls, run registries, and the Graph Workflow Composer—providing total observability over execution.
The compatibility profile. A background daemon (marketed as Hypervisor Guard) that wraps third-party developer tools (Cursor, VS Code, Claude Code). Put agent actions behind a deterministic boundary without changing your IDE.
The outcome storefront. Standard components from aiagent.xyz are assembled into SLA-backed Service-as-a-Software outcome contracts. Enterprises buy verified results, completely secured by the local gateway.
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 internetofintelligence.com 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.