0_C
WHITEPAPER Β· v0.1 Β· DRAFT

OPEN COMMUNICATION

Compute and conversation, owned by no one. Uncensored AI inference and end-to-end encrypted messaging on contributed GPUs β€” powered by $0C, a fixed supply of 1B on Robinhood Chain.

// ABSTRACT

One network, two ways to talk

AI today is centralized: prompts are logged, models are filtered, access can be revoked. Private messaging is fragmented. Open Communication unifies both on one network. A thin orchestrator routes work to contributed GPUs and blind-relays encrypted messages; users pay in credits; the people who provide compute earn the majority of what they serve. No single party owns the network, sees your prompts, or reads your messages.

// ARCHITECTURE

Orchestrator + contributed workers

A Next.js app and OpenAI-compatible API sit in front of a stateful WebSocket orchestrator. It queues jobs, routes each to the fastest idle worker, reserves credits before dispatch, streams results back, and settles on completion. For messaging it is a blind relay β€” it stores and forwards ciphertext only. Contributors run a native or browser WebGPU worker advertising the models and capabilities they serve.

Browser / API ──wss──▢ Orchestrator ◀──wss── GPU workers
                         β”‚ routing Β· credits Β· blind relay
                         β”” ledger Β· key directory Β· msg store
// ECONOMICS

Credits β€” the stable unit

Credits are the unit of account: 1 credit = $0.01. Chat is priced per 1K tokens by model; images are flat-priced. Credits are reserved before a job and settled to the real cost (refunded on failure) via an atomic reserve→settle→refund ledger. Workers earn 70% of what they serve; a 10% fee on each job flows to stakers. Credits are bought with ETH or USDT through an on-chain verified deposit into your own per-account address, at the live ETH/USD rate.

// TOKEN

$0C β€” the ownership layer

Ticker
$0C
Supply
1B
Chain
Robinhood Chain
Model
fixed Β· no inflation

$0C is an ERC-20 token on Robinhood Chain, launched on Pons and graduating to a permanently locked Uniswap v4 pool. It buys credits, is staked to earn protocol fees and boost worker priority, settles worker earnings, and governs protocol parameters. Protocol margin funds the treasury, and a share of revenue buys back and burns $0C β€” against a fixed 1B supply, real usage creates continuous deflationary pressure.

Proposed allocation Β· 1B total
Ecosystem & Community40%
Worker Rewards (emissions)25%
Team & Contributors (4y vest)15%
Treasury / DAO12%
Liquidity5%
Public / Airdrop3%
// CONTRACT

$0C on Robinhood Chain

The live contract. Verify anything you buy against this address β€” it is the only one.

$0C CONTRACT

live
0x4901151cda8ea374254220d19f42e3097b6e22a4
Explorer β†—Robinhood Chain Β· chain 4663
// GPU REWARDS

Paying for capacity, not just work

Credits already pay contributors 70% of every job they serve β€” but that pays for work done, and only when someone happens to send a job. What makes the network usable is capacity offered, so that is paid for separately, in $0C, from the trading-fee pool.

$0C launches on Pons, whose pools charge a 1% swap fee split 70/30 between the token creator and the Pons protocol. Our 70% β€” 0.7% of traded volume β€” is what funds this pool. It is not extracted as profit: it exists to sustain the models and the GPUs that power private messaging, by paying the people who keep that hardware online. We quote 0.7% rather than 1% on purpose: the headline figure is the pool's fee, not the share that reaches contributors.

points = min(tokens_per_second, 200) Γ— seconds_online
reward = pool Γ— (your points Γ· all points this epoch)

A point is one token of capacity β€” the number of tokens your GPU could have produced while it was connected. Two terms, deliberately: how fast the card is, and how long it was available. Rewards settle per weekly epoch, pro-rata; there is no fixed rate to promise, because the pool is exactly what the fee earned that week.

Throughput is measured from completed jobs, not declared, so a worker that has never served anything earns nothing for idling. It is capped at 200 tokens/sec β€” the figure is still reported by the worker, so the cap bounds what any one claim is worth. That is a mitigation, not verification; anti-cheat is not yet enforced. Rewards are keyed to a Robinhood Chain address supplied when a worker starts, since a worker authenticates with a shared secret and has no account behind it β€” uptime accrued without an address is not backdated, because it cannot be attributed.

// RESERVE

Treasury & payouts

Deposits (ETH/USDT) and protocol margin accrue to the treasury as a reserve held in ETH. Withdrawals pay out in ETHat the live oracle price, automatically and within per-request and daily caps.

Crucially, the reserve is not backed by $0C itself. Backing user redemptions with a volatile, self-issued token invites a reflexive bank-run/insolvency spiral, so $0C accrues value the safe way β€” through fee-funded buyback-and-burn β€” while redemptions are always covered by real ETH.

// STAKING

Reward-per-share

Staking uses accumulated-reward-per-share accounting. Each settled job's fee raises a global reward index in proportion to total stake; a staker's claimable reward is their stake times the index change since they last interacted β€” exact, O(1), and independent of when they staked. Stake, unstake, and claim are atomic.

// PRIVACY

Encrypted by construction

Direct messages are encrypted on-device with X25519 + XChaCha20-Poly1305; private keys never leave the device and the relay handles only ciphertext, including store-and-forward for offline recipients. Prompts and generated media are never persisted β€” only billing is.

// FORWARD SECRECY

Keys that only work once

Encrypting to someone's long-term key is end-to-end, but it has one bad property: the key never changes, so anyone who ever obtains it can read every message that key ever received β€” including ciphertext they recorded months earlier. Deleting the conversation from both devices does not help.

Conversations run on a Double Ratchet instead. Each message is encrypted under a key used exactly once and then destroyed, and the chain those keys come from is re-seeded from a fresh Diffie-Hellman exchange every time the conversation changes direction. Two ratchets do the work: a symmetric one that steps forward per message, so holding one key reveals nothing about its predecessors, and a DH one that replaces the root key whenever the other side answers β€” which is what heals a session after a compromise instead of leaking forever.

Session setup is X3DH-lite: a single DH against the peer's published identity key, so you can start a conversation while they are offline without the relay stockpiling one-time prekeys. That buys reachability at a stated cost β€” full forward secrecy begins at the peer's first reply, because until then their ratchet key is still their long-term identity key. The interface labels a conversation OPENING until that happens and RATCHETED after, rather than showing one padlock for two different guarantees.

Disappearing-message timers travel inside the ciphertext, so the relay can neither read them nor strip them in transit. Typing indicators and read receipts are relayed live and never written down β€” a log of when someone was at their device is exactly the kind of record this design exists to not keep.

What this does not do. The ratchet protects content, not metadata: the relay still sees who messages whom and when. A session lives in one browser profile, so a second device or cleared site data starts a new session rather than inheriting the old one. Group messaging with sender keys is still ahead.

One documented exception. Formally-verified mathematics is served by Harmonic's Aristotle, an external API. When you select the verified-math model β€” or an agent calls the verified_math tool β€” that problem is transmitted to a third party under their terms, and is therefore not covered by the guarantees above. Every such step is labelled ⚠ leaves network in the interface. All other inference runs on contributed GPUs inside the network.

// VALUE FLOW

Where each credit goes

Every credit spent on a job splits deterministically at settlement β€” the worker that did the work takes the majority, stakers share a slice, and the remainder is protocol margin used to buy back and burn $0C.

Worker (serves the job)70%
Stakers10%
Protocol β†’ buyback & burn20%
// COMPARISON

How 0_C differs

Property0_CCentralized AIInference-only
Uncensored inferenceβœ“βœ—βœ“
Prompts never loggedβœ“βœ—~
E2E human messagingβœ“βœ—βœ—
Forward secrecy (ratchet)βœ“βœ—βœ—
Runs on contributed GPUsβœ“βœ—βœ“
Native token / ownershipβœ“βœ—~
No account gateβœ“βœ—βœ“

βœ“ yes Β· ~ partial/varies Β· βœ— no

// TOKEN FLOW

Emissions & vesting

$0C has a fixed 1B supply and no inflation. Worker-reward emissions (25%) are released from a reserve on a decaying schedule that front-loads early contributors and tapers over time. Team & contributor allocations (15%) vest linearly over four years with a one-year cliff. Community, treasury, and liquidity unlock against milestones. Because supply is capped, sustained fee-driven buyback-and-burn works against a fixed ceiling.

// GOVERNANCE

Owned by holders

As the network decentralizes, $0C holders govern the parameters that matter β€” fee rates, the worker earn share, model policy, treasury spend, and reward emissions β€” through on-chain proposals and voting. The goal is credible neutrality: no single operator can censor a model, revoke a user, or unilaterally change the economics.

// USE CASES

What people build

Uncensored research
Ask anything; no refusal layer, no prompt logs.
Private team comms + AI
Encrypted DMs and model access on one identity.
Image generation
Create images priced per-render, served by the network.
Agents & tools
Build on the OpenAI-compatible API with your dev token.
Monetize idle GPUs
Contribute compute from a tab or native worker and earn.
Censorship-resistant access
Owned by no one; no single party can revoke you.
// DEVELOPERS

OpenAI-compatible API

Point any OpenAI client at the orchestrator; your token is the API key.

curl $ORCH/v1/chat/completions \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"model":"llama3.2",
       "messages":[{"role":"user","content":"hello"}],
       "stream":true}'
// FAQ

Common questions

Is $0C live?
Yes β€” deployed on Robinhood Chain. The contract address is in the CONTRACT section above; verify anything you buy against it. GPU reward payouts begin once the fee pool is funded.
How is my privacy protected?
Prompts and generated media are never stored β€” only billing is. Direct messages are encrypted on your device under a key used once and then destroyed, so seizing the device later does not decrypt what was already sent. The relay only ever sees ciphertext.
What stops a worker from faking results?
Canary probes, coherence, and throughput checks. Enforcement (slashing) activates once economic stake is attached.
Do I need crypto to use it?
No. You can use credits directly. Crypto is the on-ramp and ownership layer, not a requirement to chat or message.
// NETWORK

Worker lifecycle

Every worker follows the same loop, so the orchestrator treats browser tabs and datacenter GPUs identically:

01
CONNECT β€” A worker opens a WebSocket to the orchestrator and authenticates.
02
REGISTER β€” It advertises the models and capabilities (chat, image, …) it serves.
03
ROUTE β€” The orchestrator sends each job to the fastest idle capable worker (EMA tok/s).
04
SERVE β€” The worker streams tokens or returns media; results relay to the caller.
05
SETTLE β€” Credits settle to the real cost; the worker earns its 70% share.
// SCALING

Models too big for one GPU

Some models exceed any single contributor's memory. 0_C's roadmap serves them with pipeline-parallel inference: a transformer is split into contiguous layer blocks spread across a cohort of machines, with speculative decoding to hide wide-area latency. To the caller it is one job; under the hood a coordinated group of workers serves it together and shares the reward.

// THREAT MODEL

What could go wrong, and why it can't

ThreatMitigation
Worker returns garbage or a wrong modelCanary probes + coherence/throughput checks; earnings slashed once economic stake is attached.
Worker tries to identify a userThe worker receives only text β€” never identity; prompts are not persisted. Confidential compute is on the roadmap.
Man-in-the-middle on the key directorySafety-number fingerprints let peers verify keys out-of-band; the directory is append-only, so a published key cannot be replaced. Key transparency planned.
Device seized, or identity key stolen, after the factMessage keys are used once and destroyed. Recorded traffic from before the compromise stays unreadable, from the peer's first reply onward.
Message header edited in transit to redirect decryptionThe header is authenticated as associated data β€” editing the counter or substituting a ratchet key invalidates the tag.
Replayed deposit signatureIdempotent β€” a transaction signature can credit exactly once.
Claiming someone else's depositA memo binds each payment to the paying user's account.
Orchestrator reading messagesIt can't β€” messaging is a blind relay; only ciphertext is stored/forwarded.
Price-feed manipulationCached feed with a fixed fallback; a redundant on-chain oracle (Pyth) is planned.
Concurrent double-spend of creditsBalance check + reserve run in a single atomic transaction.
// SCHEDULE

$0C distribution & unlocks

AllocationShareUnlock
Ecosystem & Community40%5% at TGE, remainder on milestones
Worker Rewards25%Decaying emissions over ~4 years
Team & Contributors15%1-year cliff, then linear over 4 years
Treasury / DAO12%Governed unlocks
Liquidity5%100% at TGE
Public / Airdrop3%At TGE / campaign

TGE = token generation event Β· proposed, subject to change

// GLOSSARY

Terms

Orchestrator
The stateful service that routes jobs, tracks credits, and blind-relays messages.
Worker
A contributed GPU (native or browser) that serves inference and earns.
Credit
The stable unit of account; 1 credit = $0.01.
$0C
The network's fixed-supply (1B) token β€” ownership, staking, and settlement layer.
Reserve β†’ settle
Credits are held before a job and finalized to the real cost after.
Blind relay
The server forwards encrypted messages without ever seeing plaintext.
Double Ratchet
Message keys that advance one step per message and are destroyed after use, so a later compromise cannot read earlier traffic.
Forward secrecy
The property that stealing today's keys does not decrypt yesterday's messages.
Reward-per-share
O(1) accounting that splits staking rewards fairly regardless of timing.
Uptime boost
Up to +50% on points, ramping with the length of an unbroken worker session.
Buyback & burn
Protocol fees repurchase and destroy $0C, reducing supply.
Pipeline-parallel
Splitting one large model across several machines to serve it cooperatively.
// STATUS

What's live vs designed

Streaming chat, image generation, encrypted messaging, the credit ledger, staking, and on-chain ETH/USDT deposits are live, and $0C is deployed on Robinhood Chain β€” verify any token you buy against the contract address above. The allocation shown is a stated intention, not an on-chain guarantee. Nothing here is an offer to sell a security or investment advice, and nothing on this page is a promise of value or return.

Full document: WHITEPAPER.md in the repository.