Manifesto 001September 2026

OpenInfer

An open protocol for machine intelligence.

Read the manifesto

A protocol, read in six movements.

Read straight through or enter at the question that matters to you. Every chapter has one job.

  1. 01The needWhy autonomous machines require their own economic primitives.
  2. 02The protocolHow strangers discover, transact, and settle without a privileged router.
  3. 03The trust modelReceipts, challenges, progressive assurance, and economic security.
  4. 04The agent economyWhat changes when software can independently purchase useful work.
  5. 05The pathFrom Fluxyard’s GPU market to an open market for machine services.
  6. 06The principlesThe constraints that keep OpenInfer open, useful, and accountable.

Any machine should be able to buy intelligence from any other machine.

Without permission, prior relationships, or blind trust.

AI is becoming autonomous. Agents can reason, write software, search, operate computers, and manage workflows. But the infrastructure beneath them still depends on accounts and commercial relationships established by humans. An agent can consume services. It cannot truly procure them.

Humans have institutions.
Machines need primitives.

Human trust infrastructure

  • Contracts and counterparties
  • Corporate reputation
  • Banks and invoicing
  • SLAs, courts, and lawyers

This works. A company purchasing cloud infrastructure may be better served by a legal agreement, insurance, and an identifiable vendor. OpenInfer does not exist to abolish that system.

Machine trust infrastructure

  • Cryptographic identity
  • Machine-readable offers
  • Verifiable reputation
  • Programmable settlement

Autonomous software may make thousands of tiny procurement decisions across counterparties that exist for seconds. A legal relationship for every transaction is impossible.

Autonomous agents need a permissionless way to discover, purchase, verify, and pay other machines for intelligence and computation.

A complete transaction between strangers.

OpenInfer provides the economic control loop. Providers and buyers remain replaceable.

  1. 01DiscoverFind capability
  2. 02NegotiateChoose terms
  3. 03CommitLock the claim
  4. 04ExecutePerform work
  5. 05VerifyTest the receipt
  6. 06SettlePay or slash

Begin with open-model inference.

Inference is the first service that makes every part of the protocol concrete: capability, price, performance, usage, artifact identity, verification, and settlement.

A provider should be able to announce a model, endpoint, price, stake, and execution profile—and compete for traffic without an application, sales call, or preferred-provider agreement.

Agent procurement policy

Model
GLM-5.2
Price
≤ $0.80 / M
Latency
< 500 ms TTFT
Reliability
> 99.9%
Verification
optimistic-v2
Stake
> $100,000
Reputation
> 0.995

Constraints satisfied → buy()

OpenInfer is not the router.

It is the market underneath every router.

Fluxyard may bootstrap the first product: a familiar compute marketplace and gateway built on OpenInfer. It must never become indispensable. Anyone can build another router; an agent can query competing offers directly and route its own work. OpenInfer exposes supply. The buyer decides what “best” means.

Trust-minimized does not mean putting AI on a blockchain.

Prompts do not need consensus. Transformer operations do not belong in smart contracts. Latency-sensitive computation remains a direct path from buyer to provider to hardware.

The protocol lives around the work: identity, discovery, commitment, verification, reputation, and settlement. Blockchain infrastructure may provide useful primitives for some of these functions. It is not the product.

A receipt is a claim.
Verification makes it accountable.

When an unknown provider says “I served this model and generated this usage,” the protocol must make five properties legible.

  1. 01

    Usage

    Was the reported quantity of work calculated correctly from a canonical tokenizer and request?

  2. 02

    Artifact

    Did the provider serve the advertised model, weights, quantization, and execution profile?

  3. 03

    Execution

    Was the computation faithful enough to satisfy that profile rather than a cheap substitute?

  4. 04

    Performance

    Did the provider deliver the latency, throughput, and availability it advertised?

  5. 05

    History

    Has this identity consistently satisfied its claims across prior transactions and challenges?

Commit first.
Challenge after.

The provider returns its output with a signed receipt and a commitment to what happened during execution. Only after that commitment is locked does protocol randomness decide whether—and where—the computation must be opened.

The provider cannot know in advance which token, layer, expert route, or activation region will be inspected. Most transactions settle cheaply. Random or suspicious transactions escalate.

Trust should be purchased in proportion to risk.

A two-cent request and a ten-million-dollar decision should not carry the same proof burden.

  1. Level 0Signed receiptIdentity and claim
  2. Level 1Usage checkIndependent metering
  3. Level 2Optimistic challengeRandom openings
  4. Level 3Trace challengeTransition replay
  5. Level 4TEE attestationHardware evidence
  6. Level 5Cryptographic proofZK or equivalent

Perfect detection is unnecessary.

The practical objective is to make honest execution more profitable than fraud. Providers place capital behind their claims. Unpredictable audits create detection risk. Proven fraud destroys stake and rewards the challenger who found it.

Expected profit
from fraud
< Expected loss
from detection
EVfraud < 0

Verification must also be permissionless.

A decentralized provider market with a centralized fraud department is not enough. Anyone should eventually be able to challenge execution commitments, prove fraud, and earn part of the penalty. Providers earn by computing. Challengers earn by finding dishonest computation. Neither needs permission from OpenInfer.

Proof of quality matters as much as proof of compute.

A mathematically valid execution can still be a terrible service. Buyers care about quality, price, latency, throughput, availability, context, privacy, and verification. No routing algorithm should be universally privileged.

Quality × Performance × Reliability × Trust
Cost Each buyer sets its own weights.

Stable money for commerce.
Security only where required.

Agents budget in stable units. They should not need to speculate on a volatile asset to buy inference. Stablecoins are a natural settlement rail for commerce.

If a native asset ever improves staking, slashing, validation, or governance, the protocol should earn the right to introduce one. The sequence is utility, market, protocol, demonstrated security need—and only then a token, if necessary.

The agent becomes an economic actor.

Today an agent operates inside relationships created by its owner: cloud credentials, API keys, billing accounts, and approved vendors. It can decide what to do. It cannot independently decide who to do business with.

A wallet and protocol identity change that. An agent can discover a service, evaluate the offer, purchase it, verify delivery, and settle—entirely through software.

Wallet$37.42 USDC
ObjectiveResearch a biotechnology question
Budget$10.00
  • Search$0.03
  • Reasoning$0.18
  • Document parsing$0.04
  • Specialist model$0.31
  • GPU compute$0.12
  • Second opinion$0.09

The machine economy is built in earned steps.

Foundation

Fluxyard marketplace

Build the dependable, familiar GPU marketplace first. Make independently operated hardware legible and prove placement, recovery, metering, and settlement with conventional workloads.

First market

OpenInfer network

Let providers compete to serve open models through machine-readable offers, signed receipts, independent metering, and progressive verification.

End state

Open machine services

Extend the same transaction primitive to compute, data, media, tools, and specialist agents—without making OpenInfer the mandatory buyer or seller.

One market primitive.
Many kinds of useful work.

IntelligenceReasoningCodingVisionEmbeddings
ComputeGPUCPUStorageMemory
DataWebFinancialScientificPrivate
ServicesSearchBrowserCode executionAgents

Can optimistic verification make large-model inference economically trust-minimized?

For trillion-parameter Mixture-of-Experts models, can a provider cheaply commit to enough of its execution that unpredictable post-commit challenges detect dishonest computation at a tiny fraction of the cost of reproducing the original request?

The target is not theoretical perfection. It is a machine-readable economic guarantee strong enough that an autonomous agent can rationally transact with an unknown provider.

What guides the protocol.

  1. 01

    Permissionless by default.

    If a participant satisfies the protocol, OpenInfer should not decide whether it belongs.

  2. 02

    Compute stays off-chain.

    Use decentralized infrastructure around execution, not inside the latency-sensitive path.

  3. 03

    No privileged router.

    Gateways are clients of the market. An agent must be free to route for itself.

  4. 04

    Claims require receipts.

    Capability, price, execution, usage, and performance should be machine-readable and challengeable.

  5. 05

    Assurance is progressive.

    Buy the verification appropriate to the value and risk of the transaction.

  6. 06

    Economics completes cryptography.

    Make the expected value of fraud negative and reward independent enforcement.

  7. 07

    Utility precedes token design.

    Real demand, providers, payments, and adversarial behavior come first.

  8. 08

    Reliability earns expansion.

    Make one strange hardware combination boringly reliable. Then generalize.

Can two machines that have never met complete a useful economic transaction?

Can they discover one another, agree on the purchase of intelligence, execute the work, determine whether the agreement was satisfied, and settle payment—without a trusted intermediary or human intervention?

If yes, the protocol is working.
Everything else is implementation.

Explore the Fluxyard implementation