Abstract

Nearly every operation a person or machine can perform on a computer is exposed through a recurring set of surfaces: shell and cloud CLIs, HTTP APIs and OpenAPI services, JSON-RPC methods, smart contract ABIs, IoT device bindings, and model inference endpoints. Everything built on top is a client of one or more. The capability is already deployed and reachable in principle. In practice, a fraction of it is ever used.

Structural costs stand between intent and those operations. They fall on two axes — learning (what an operation charges you to learn) and reach (what stays out of reach no matter how much you try):

The tax is paid per tool, per person, and again after every change. O1 exists to make it a relic of the past.

The Universal Remote. O1 reduces digital surfaces to a single object — the Operation — indexes those descriptions in a shared, content-addressed knowledgebase, and generates the interface for the task rather than for the tool. What follows:

• One interaction model. CLI, ABI, and device binding become instances of the same primitive.
• Possibility before intent. Capabilities are enumerable before a precise question exists.
• Composition across surfaces. One normal form lets a chain event gate a message, email, or device write.
• The fleet as an operand. Hosts, nodes, and devices are addressed in-session — not destinations to reach first.
• Knowledge that compounds. Describe an Operation once; every operator after inherits it.
• Grounded answers. Retrieval cites live upstream artifacts, so a training cutoff stops being a ceiling.

Costs and Answers

Structural costs keep owned capability out of reach. They fall along two axes — learning and reach — and each has a specific answer in O1’s design. The design consequences in the abstract are the product spine; the pairs below name how each cost is answered in practice.

The discovery gap

Before you can climb a learning curve, you have to know there is something at the top.

Capability is not enumerable. Flags hide behind subcommands, endpoints behind schemas, methods behind prose, semantics behind selectors. An operator must already know what to look for in order to find it. Natural language interfaces inherited this and narrowed the aperture further: a single blank field answers what you meant to ask and never shows what you could have asked.

You cannot ask for what you do not know exists. A prompt box answers what you meant to say. It never tells you what you could have said.

There is a second cost hiding inside the first. Humans are exploratory. We probe, we poke at edges, we find things we were not looking for. The single-input prompt box assumes intent is already formed — it neither invites exploration nor supports it. It is a blank slate handed to a species that navigates by looking around.

Possibility-first interfaces

Because every Operation is described the same way, the set of things a bound surface can do is a retrievable fact, not a guess. That makes it enumerable — and renderable.

Open a bound node and the first frame is not an empty text field. It is what this endpoint can do, grouped by effect class:

SURFACE(C, K)
  bound     mainnet-exec-01
  view      eth_syncing · eth_blockNumber · net_peerCount · eth_getBalance · …
  write     ‹…›
  host      systemctl.restart · journalctl.tail · df · …

Discovery is the first frame, not a secondary tab. And because a surfaced capability is a retrieved fact about what the surface accepts — not a fluent guess — the list is trustworthy in a way a model’s recollection is not.

Syntax as interface

Operation still means assembling a string: program, subcommand, flags, quoting, order. The interaction model is text editing, and correctness is confirmed by execution. Auto-complete and suggestions have blunted this, not removed it. The operator remains the compiler, and a missing quote is still a failed job.

Generated interfaces for the task

Once an Operation is typed — inputs, effect, risk — the interface does not have to be a command line. O1 generates a form for the task rather than for the tool: fields for declared inputs, chrome that names the effect before anything runs, confirmation when state will change. The string the binding eventually sends is an implementation detail. Correctness is checked against the schema before execution, not discovered by reading the exit code after.

Private apprenticeship

When you finally work out how a surface behaves, where does that understanding go?

Into your notebook. Your shell history. A Slack thread. A README nobody outside your team reads. The next operator to hit the same wall starts from zero and pays the same price.

This is why wrappers and SDKs never solved the problem either. Every integrator writes their own translation layer, each one breaks on the next upstream change, and none of them produce anything the next integrator can inherit. Cost scales linearly with surfaces, forever.

The shared knowledgebase

Describe an Operation once; everyone who follows inherits it.

Storage is content-addressable: identity follows bytes, not filenames. Per-tool version manifests record {path, content_hash} pairs under SHA-256, and a root manifest hash commits the set. Identical content collides to the same address. Supersession is an explicit, auditable act — never an edit-in-place that would quietly make earlier citations lie.

Four properties follow:

Contribution compounds. Every accepted descriptor raises the floor for the next consumer — human, agent, or script.

Drift is visible. When a binding’s live bytes stop matching its content address, that is a first-class signal. Not a silently stale success.

Ownership travels. Curation rights over a namespace are ERC-721 assets with ERC-4907 rental semantics, so rights can transfer, rent, or split without relocating the underlying knowledge. Descriptors stay content-addressed; the rights move.

Reading is free. Attestation and protocol governance settle onchain because they require global consistency and adversarial auditability. Access to the knowledge does not. Discovery stays open.

That last point is the one to hold onto. Runtimes, shells, and agent binaries age with frameworks and interaction fashions. The corpus is what outlives them.

The local horizon

Tooling treats localhost as the first-class citizen. SSH, a kubeconfig, a wallet, a device bridge — each is a session you open to get somewhere else. Remote and distributed instances are reachable, but there is no native inventory and no addressing model for the fleet as an operand. The operator’s world is wherever the current prompt happens to be attached.

The fleet as an operand

Bindings carry their own addressing. A remote host, a node, and a device are operands in the same session — selected, compared, and acted on — rather than destinations you first have to get to. Inventory is a first-class surface of the environment, not a side quest between shells.

Forced consolidation

Every additional vendor is another grammar, another integration, another private apprenticeship. Organizations respond rationally by minimizing surface count — accepting single points of failure not because concentration is safe, but because federation is priced out of reach. Lock-in is the compound interest on the costs above.

Federation at one grammar

When every surface is an Operation under one interaction model, adding a vendor stops meaning adding a dialect. The marginal cost of a new binding is description and attestation, not another private learning curve and another integration project. Federation becomes the affordable default; concentration stops being the only rational choice.

Dialect fragmentation

Each surface ships its own grammar. None of them are compatible in use.

Learning one teaches you nothing about the next. Each keeps changing, so what you did learn decays under version drift. Most of them assume a desktop and travel badly to anything else. And none of that noise is the work you actually wanted to do.

The consequences are familiar and they compound: shallow utilization of tools you already own, dialect errors dominating the path from intent to result, human support becoming the product’s real interface, and eventually the capability being outsourced to a specialist — concentrating knowledge instead of spreading it.

The Operation

An Operation is a discrete unit of work with a stable identity, typed inputs, a declared effect, and a declared risk.

{
  "id": "eth_syncing",
  "description": "Report sync status of the execution client",
  "command": "rpc.eth_syncing",
  "input_schema": {},
  "output_schema": "object|false",
  "effect": "view",
  "reversibility": "read-only",
  "risk": "safe"
}

Three fields do the load-bearing work, and all three are declared, not guessed:

• effect — view or write. The coarse mutation class that authorization and interface chrome trust.
• reversibility — read-only, reversible, or irreversible.
• risk — safe, caution, or danger.

Heuristics help authors fill these in: ABI mutability tags, HTTP verbs, RPC naming conventions, destructive-pattern detection in CLI help text. But a heuristic is an authoring aid, never runtime authority. Nothing in the system may silently reclassify an Operation mid-flight because a model thought better of it.

Two things stay out of the descriptor on purpose. Authentication belongs to the identity layer, so that every Operation is not forced to re-encode session mechanics. Host-specific binding — endpoints, binary paths, device addresses — travels in an install-time bundle, so that the portable claim does not bake in one machine’s filesystem. What remains is portable: the same description works wherever the surface exists.

A CLI flag tree, a Solidity ABI, and a device binding stop being different kinds of things. They become instances of the same primitive.

Frozen knowledge

A model’s parametric memory is a compressed photograph of a moment that has already passed.

It may never have seen the release note that renamed the flag, the ABI of the contract deployed last week, or today’s price for the instance type you are about to provision. When it does not know, it does not always know that it does not know.

For infrastructure work this is not a minor limitation. The whole job is acting correctly on the current state of a live system.

Grounded retrieval

Answers are grounded in live retrieval over artifacts that exist upstream and can be cited: documentation and schemas, GitHub releases and issues, package registries, OpenAPI catalogs, chain registries, verified ABIs, device bindings, cloud pricing APIs, model metadata, and the community channels where operational truth appears before it hardens into documentation.

Query → intent classification → fanout across eight corpus channels → reciprocal-rank fusion → a ranked evidence set the generator must respect.

Two disciplines make this honest rather than decorative. Freshness is attributable — a price fetched five minutes ago is a different epistemic claim from a price recalled from pretraining, and the system keeps that distinction legible. And crawler watermarks are never confused with upstream watermarks: how recently we looked is not how recently the world changed.

If the model never saw a schema revision, retrieval still can. Training cutoffs stop being a ceiling on what can be known and become a ceiling only on what can be recalled unaided.

The composition wall

An operation on one surface cannot condition an operation on another. A rental payment arriving at an Ethereum address should be able to notify accounting, email the renter, and authorize the smart lock for the new guest. No shell, CLI, or API client expresses that. Cross-surface work is a software project, not an operation — another private apprenticeship between the tools you already own.

Composition across surfaces

Operations that share one normal form compose regardless of what they bind to. A chain event can gate a message, an email, and a device write without an integration project between them. The join is in the Operation layer: declared effects, typed inputs, and a shared knowledgebase — not a bespoke glue service for every pair of vendors.

The absent environment

Software development has an environment; operation has a prompt. Capability indexing, validation before execution, rehearsal, shared configuration — table stakes in an IDE — are in operation either absent, per-tool, or private to the operator. The prompt box inherited the blank slate and none of the scaffolding.

An environment for operation

O1 is that scaffolding: a corpus that indexes what bound surfaces can do, schema validation before anything runs, rehearsal of writes with the effect named, and shared configuration that travels with the operator rather than living in one shell history. The prompt becomes one input among others — not the whole workplace.

What Using It Looks Like

The first market is crypto infrastructure over JSON-RPC. Here is one session end to end.

The situation. An operator has a bound Ethereum node. They suspect it is falling behind. They do not know the method name, and they have never used systemctl on this host.

The walk-through uses the same overlay operators use: Search, Agent, and Terminal in one pane, with context pinned as inspectable chips. Writes wait. Step through it, or let it play.

SURFACE. Before a prompt, SURFACE(C, K) returns the bound node’s capability, grouped by effect: views (eth_syncing, eth_blockNumber, net_peerCount, …), writes, and host operations (systemctl.restart, journalctl.tail, df). Possibility is visible without a query.

Intent. is this node keeping up? if it isn’t, restart the execution client.

RESOLVE. Intent classifies as hybrid. Channels fan out; results fuse. Ranked candidates include eth_syncing and eth_blockNumber (rpc · view) and systemctl.restart (cli · write · caution). Chips for geth and mainnet-exec-01 stay on screen — inspectable, editable. Context the operator cannot see is context they cannot correct.

Interface. Views run immediately. The write is labelled as a write and waits.

EXECUTE. Confirmation required — state-changing action. The operator sees systemctl restart geth on mainnet-exec-01, then Allow or Decline.

Output. The selected model renders the result through the default output prompt, or a custom prompt the operator saved. That generated view is not a contribution to the knowledgebase.

That session is the thesis in miniature. The operator did not learn JSON-RPC to begin. They were not blind to what the node could do. The work crossed from RPC to shell without changing languages mid-flight — composition without an integration project. The host was an operand, not a destination. And the effect was named before anything mutated.

What You Can Build

You already do this work. O1 makes it reachable without learning each tool’s dialect.

Who Participates

Five roles keep the commons moving. Reading stays free for all of them.

Operators state intent, discover capability, and execute against their own bound surfaces. They consume the commons and pay nothing to read it.

Contributors describe Operations and submit them with provenance. Their work is attested, attributable, and inherited by everyone downstream.

Curators hold namespace rights — transferable and rentable — and shape what a namespace organizes without owning the underlying hashes.

Executors run the work. Today that is the steward; later, attested and then third-party movers.

Integrators extend the edges: bring-your-own model endpoints, custom API servers with live OpenAPI fetch, pluggable storage drivers. The runtime grows by declared endpoints the same way the corpus grows by accepted descriptors.

The O1 Token

The token is a protocol instrument with narrow, stated utility. It prices attested contribution and weights governance over onchain-verified attributes. Reading the knowledgebase does not require it.

That restraint is the point. Requiring a token to read would convert a commons into a toll booth and contradict the claim that the corpus is the durable public asset. Discovery stays open; attestation and protocol-parameter change do not.

Supply. Capped at 21M on an inert ERC-20 contract that embeds no application logic. 9M genesis to treasury, up to 12M mined through attested contribution. Treasury vesting unlocks within the cap; it cannot mint around it.

Emission. Geometric decay of 98849/100000 per 30-day epoch. Read three ways, it is the same constant:

A smoothed halving on a roughly five-year cadence, with no discretionary vote at each step. Any participant can compute remaining issuance from two published numbers.

Separate ledgers. Hosted capacity and namespace subscriptions settle in stablecoin or fiat. Mining economics and access fees are deliberately different ledgers, so that speculative price never becomes the admission ticket to grounded knowledge. They meet at governance and attestation — not at every read.

Full derivations, the DCO lifecycle, claim splits, and the four-contract separation of privilege are in §14–15 of the whitepaper.

Team

GitHub · Discord · X · Whitepaper

MIT licensed.