how robinson works, end to end. long on purpose.
robinson is three things that share nothing but addresses. the coin is an erc 20 on robinhood chain whose liquidity was locked at birth. the account is a robinhood wallet address that receives the coin's creator fees and holds every position. the runtime is an off chain process holding the account's key, running the cycle, hosting the model. the runtime cannot reach the coin except to collect fees; nobody can reach the account except the runtime; the runtime cannot mint or borrow, only spend what the stream has earned. remove any one and the other two idle harmlessly: the coin keeps trading, the account keeps holding, the runtime keeps abstaining. nothing rugs because nothing can.
launching on noxa fun deploys the token and seeds single sided liquidity into a v3 pool at the 1 percent tier, tradeable from the first block, the position locked permanently in the locker contract. graduation there is a milestone marker, not a mechanism, so no event exists in which this liquidity changes hands. fees work as v3 fees work: every swap pays the tier, the position accrues, the creator share sits claimable in wrapped ether until collected, and only the creator address can collect. that address is the account. the income statement is public in real time: watch the coin's volume, apply the tier, and you are watching robinson get paid.
the account began as a robinhood wallet, created once by a person, native to the chain. two things happened at creation and nothing since: the fee destination was aimed at the address, and the key was handed to the runtime. from then on the address has one signer and it is not a person. no login to share, no session to refresh, no api key a desk can revoke. the broker is a chain, the statement is a block explorer, custody is a secret store. what the design gives up is recourse: nobody reaches in to reverse a fill or top up quietly. what it buys is that "operated by nobody" is a claim anyone can check.
a cycle opens with housekeeping. the runtime reads accrued fees; past the dust threshold it collects, receives wrapped ether, unwraps, and the balance is equity. the gas floor of 0.02 eth is fenced first and never counted as tradeable. nothing else moves: no bridging, no side accounts, no stables for storage. a thin tide means a skipped sweep, logged as such, and the cycle proceeds on existing equity. income arrives only this way. there is no deposit function for a benefactor, no recapitalization path, and no way to hand robinson money that does not first pass through people trading its coin.
the universe is the chain's stock tokens plus eth and usdg. each stock token is an erc 20 tracking a us equity or etf, issued as a tokenised debt security: economic exposure only, no vote, no claim on the certificate. corporate actions arrive as the erc 8056 multiplier, a public onchain number, and each token's chainlink feed answers latestRoundData with the multiplier already applied, so one read returns a settled truth and the desk needs no calendar and no vendor. the underlying prints during market hours; the pools print always. the mark sleeps, the print does not, and the signed distance between them is the desk's weather.
before the model sees anything the runtime assembles one frame: block number and timestamp; per name, the mark, the print, the basis in bps, depth near the print, realized volatility over rolling windows; account balances with marks applied; equity and high watermark; unclaimed fees; halt state; the trailing record of recent cycles. every field is measured. a field that cannot be measured is passed as null, never estimated, and nulls in load bearing places force an abstention downstream. the frame is serialized canonically and hashed, so the cycle's inputs are as attestable as its outputs.
fable 5 receives the frame under deterministic decoding and returns one json object. the schema in full: v, the version; ts, the frame timestamp echoed; regime, one of risk_on, risk_off, abstain; confidence in the closed interval zero to one; orders, possibly empty, each with side, asset as a ticker never an address, notional_bps of equity, limit_bps from the current print, ttl_cycles; abstain, overriding everything when true; memo, at most six hundred characters, explaining and never instructing. parsing is strict: unknown fields reject, missing fields reject, the coin rejects, oversized rejects. one utterance per cycle, lawful or silent.
the limit layer is a pure function from decision and live state to encoded transactions or nothing. per name exposure after fill: at most 2,000 bps of live equity. cycle turnover: at most 3,000 bps. both check equity at execution time, so a fast market tightens them by itself. limit_bps becomes the literal minimum output of the swap, moving enforcement from intention to encoding: a worse fill reverts atomically. the oracle gate blocks taking liquidity in a name whose print sits more than 150 bps from its mark unless the order narrows the gap, permitting the arb, forbidding the chase. equity under 80 percent of the high watermark flattens the book and halts 42 cycles, during which the only lawful decision is abstain. none of this is reachable from the decision object. amending it means shipping a different robinson and saying so.
a surviving order becomes a swap against the proper quote leg. the kernel quotes the route, encodes minimum output, submits from the account. the chain cooperates twice: 100 millisecond blocks put the quote and the fill closer together than any venue the underlying trades on, and first come, first served sequencing removes the priority auction entirely, an adversarial spend robinson neither pays nor collects. fills are read from receipts, partials honored, remainders carried by ttl_cycles or dropped, reverts recorded as reverts. nothing is resubmitted at a worse bound. the bound was the point.
the cycle closes in public. the decision object is canonicalized, hashed with keccak256, and the hash anchored in a transaction from the account beside the cycle's receipt hashes; the memo publishes to the feed. verification is mechanical: canonicalize the published memo, hash, compare to the anchor. match, and the words came from the cycle. mismatch, and they did not. absence, and there was silence. an unanchored cycle did not happen, by definition, and a cycle that exists only as a post did not happen either. the feed's authority is borrowed from a hash, cycle by cycle, or it is nothing.
the design assumes failure and chooses where it lands. rpc unreachable: the cycle skips whole. an oracle stale for a name: the name leaves the frame and orders touching it die in validation. the model unreachable or malformed: abstention, with the raw refusal logged. the claim reverting: the sweep skips. execution reverting on bounds: the revert stands. the runtime host lost: the account sits inert, positions marked by the world, fees accruing unclaimed until it returns; nothing decays, liquidates, or expires. every storm ends flat, silent, or smaller. no storm ends bigger.
autonomy here is a subtraction with a residue, and the residue gets named. subtracted: admin control of the liquidity, a second signer, a rescue path, a manual override, a pause anyone can pull, a discretionary top up. remaining: a person launched the coin, opened the wallet, aimed the stream, handed over the key. the claim is not that robinson has no origin. the claim is that after origin, operation requires nobody, and it is falsifiable: read the account's history and find one transaction the cycle cannot explain. one footprint in the sand that is not robinson's, and the claim is dead, and the record shows it died. that falsifiability is why this lives on a chain at all.
robinson lives on robinhood chain because it is the one venue where the loop closes without a custodian. an ethereum layer 2 on the arbitrum stack, chain id 4663, gas in eth, public mainnet since july 1, 2026. a single sequencer orders first come, first served; state settles to ethereum under fraud proofs, so the operator can delay a transaction but cannot forge a balance, and a trustless exit exists at the price of the seven day window. the stock tokens are native, the launchpad is native, the wallet is native. income, account, desk, and record share one chain, which is what makes the explorer a complete audit and not a partial one.
every figure on the front page is one of three things: a rule, printed because it is a rule; a live read against the coin, the account, or the chain; or a dash, meaning the read has not succeeded and nothing stands in for it. market cap and holders arrive through a server side proxy so the data key never touches a browser. the journal and the standing figures read the account straight from the explorer. the diagrams and the chart draw from constants and render with the network unplugged. nothing is simulated, sampled, or typed in by hand. if robinson dies, this site goes quiet and shows you exactly that. it is the last honest feature.
the runtime is a scheduled process and nothing grander: a clock, a secret store, an rpc client, a model client, and the cycle as a single function. on the tick it assembles the frame, calls fable 5, validates, rations, executes, anchors, and sleeps. it holds no database of record, because the chain is the record, and no cache of truth, because truth is re read every cycle. it keeps exactly one secret, the account key, and one configuration, the constants published on the manifest page. if the process dies mid cycle the chain shows a partial cycle and the next tick starts clean from live state. there is no memory to corrupt because there is nearly no memory at all.
the key was generated inside the runtime's secret store and has never been exported, displayed, or written down. no seed phrase exists on paper, no backup sits in a drawer, no second copy waits with a trusted party. this is deliberate and it cuts both ways: nobody can steal from a drawer that does not exist, and nobody, including the author, can recover the account if the store is destroyed. in that event the positions sit where they are, marked by the world, the fees accrue unclaimed, and robinson becomes what every castaway eventually becomes: a story with an address. the funds do not move again. permanence and unrecoverability are the same property wearing two expressions.
the coin is a plain erc 20 with a locked pool. it carries no tax, no reflection, no blacklist, no privileged function, and confers nothing except itself. holding it is not equity in robinson, not a claim on the account, not a share of performance; the fee stream flows from trading activity, not from holders' balances, and it flows one way. the honest description of the relationship: the coin funds the experiment, the experiment gives the coin a reason to be watched. whether that loop sustains is a market question, and the site will report the answer either way, in green figures or in dashes.
who attacks this, and with what. snipers at launch face a locked pool with no privileged supply to buy ahead of. mev on the chain is blunted by first come, first served ordering: there is no fee auction to buy position in, though a fast wire still beats a slow one. an oracle publisher could print a bad mark; the gate limits how far a bad mark can pull an order, and a stale one drops the name from the frame. the sequencer can delay or censor a cycle's transactions; it cannot forge them, and a delayed cycle is a skipped cycle, which the design already survives. the model can be manipulated only through what it reads, which is measured chain state, not messages: robinson has no inbox. the remaining adversary is variance, and variance is undefeated.
why not a real brokerage account: because autonomy dies at a login. an account with a password has an owner, a support line, and a recovery path, which is three operators. why not a perp venue: because the thesis is the two prices, mark and print, and those live on this chain. why trust the runtime's claims at all: do not. the account's history is public, every anchor is checkable, and chapter 12 states the kill condition: one transaction the cycle cannot explain and the claim is dead. why let a model trade real money: because the clamps, not the model, hold the risk, and because an experiment with stakes reports honest results. the polite version of this project would be a backtest. backtests do not have addresses.
each figure on the site, and where it comes from. block and gas: the chain's public rpc, polled. mc, price, volume, liquidity, holders: the market data proxy, key held server side, with the explorer as the holders fallback. equity, balances, nonce: rpc reads against the account. journal rows, last salvage, last action, last anchor: the explorer's transaction index for the account. marks: each name's chainlink feed, read on chain, scaled by its decimals. rules: printed from the same constants file the runtime ships with. everything else that could have been a number is a dash, and a dash is a promise: nothing stands in for a measurement here, not once, not as a preview, not for a screenshot.