RobiOS is a swarm: specialist agents and the world's best AI models, merged into one workspace. You type intent into a terminal; the swarm decides who thinks, which model answers, and streams the result back token by token.
The mission
Frontier AI is locked behind a stack of expensive subscriptions · one for chat, one for images, one for code. RobiOS collapses them into one door: the protocol treasury pays for the AI, funded by trading fees on $ROBI and revenue from apps built on Robi, and you burn a small amount of $ROBI per use instead of paying anyone a monthly bill.
You pay only for what you use. The more the ecosystem grows, the more AI capacity the treasury can fund · and the cheaper frontier intelligence gets for everyone in the network. The full math is in Network Economics.
12specialist agents
5frontier labs, one door
3live market feeds
24ktoken output ceiling
150sstream window per build
0subscriptions needed
What actually runs
RobiOS is not one chatbot behind one API. It is three layers working as a single organism:
The agent layer · Robi Runtime. Twelve specialist agents on a proven character-driven architecture, hosted inside RobiOS: each one is a character (who it is), a set of actions (what it can do) and providers (what live context it sees).
The model mesh. A ranked chain of models on the OpenRouter network · flagship first, flash-class next, a free pool as the safety net. The first model to answer wins; the user never sees a dead prompt.
The data layer. Live market feeds · prices, trending pairs, fear & greed, fresh liquidity · pulled straight from public APIs so answers are grounded in what the market is doing right now.
No install, no signup wall. The terminal on the landing page is the product · here is five minutes of it.
1 · Look around
❯ agents # the full catalog, twelve specialists
❯ help # every command, one screen
❯ gm # say hi to the runtime
2 · Attach a specialist
❯ attach research
✓ research online · narratives, sourced reads
❯ report
research: BTC steady, AI-agent narrative leads trending.
Fear & greed 71 · flows risk-on. Live data, 4 sources.
An attached agent owns the session: every plain-English prompt routes to its character until you detach. Or leave routing on auto and the swarm picks a specialist per prompt.
3 · Build something real
❯ build "landing page for a telegram whale-alert bot"
builder: plan · dark one-pager, hero, three features, CTA.
```html
<!doctype html> … # a complete, working page streams in
```
▸ Preview ▸ Download
The builder answers with one self-contained HTML file · inline CSS and JS, no external assets · and the terminal turns the fenced block into Preview and Download buttons. What streams in actually runs.
4 · Go visual
❯ imagine "a lime robot reading candle charts"
⧉ picture generated · click to open
# or paste / drop a screenshot and ask about it:
❯ what's wrong with this layout?
"Swarm" is not a metaphor here. Every answer is a negotiation between an agent that knows who it is and a mesh of models that decides who gets to think.
The full pass, step by step
The terminal packs the turn. Your prompt, the attached agent's slug, the last few turns of history and · if you dropped one · a downscaled screenshot.
The gateway screens it. Cross-origin calls are rejected, floods are rate-limited, oversized payloads bounce. Only clean turns reach the swarm.
The character loads. The agent's character sheet · identity, actions, providers, style rules · is injected as the system layer. The same prompt lands differently on trader than on kol, by design.
Robi Runtime answers first. The always-on agent service holds a private session per agent and streams its reply.
The mesh is the net. If the runtime is unreachable, the same turn walks the model chain · flagship, flash, free pool · until one answers. The terminal never goes silent.
Tokens stream home. The reply is re-emitted as server-sent events; the terminal renders each delta as it arrives.
The gate, as code
Before any model burns a cent, the gateway runs the same three checks on every turn:
if (!sameOrigin(request)) return 403; // browsers only, Sec-Fetch-Site checked
if (rateLimited(clientIp)) return 429; // floods stop here, humans never do
if (prompt.length > 4000) return 400; // clean turns only
const turn = [ character(agent), ...history.slice(-6), user(prompt, image?) ];
What the wire looks like
One POST, one event stream. This is the entire protocol between the terminal and the swarm:
POST /api/agent
{ "agent": "builder", "prompt": "landing for $DRIFT", "history": [...] }
data: {"agent":"builder","start":true}
data: {"delta":"Plan · dark one-pager, three sections…"}
data: {"delta":"```html\n<!doctype html>…"}
data: {"done":true}
Why merge, not wrap
A wrapper forwards a prompt to one model and prays. The swarm holds three guarantees a single model cannot:
Identity survives the model. The character sheet travels with the turn, so research cites sources and builder ships a full file · no matter which mind in the mesh does the thinking.
Failure is routed around. Models have bad minutes. The chain retries the same turn on the next mind in ranked order, mid-conversation, invisibly.
Context is live. Providers pipe real market data into the turn, so answers reference what happened seconds ago, not what the model remembers from training.
The agent layer of RobiOS: an always-on hosted service where the twelve live as full agents · character, actions, providers · running only inside the RobiOS infrastructure.
Anatomy of an agent
Every agent is a small, declarative sheet. This is research, distilled:
{
name: "research",
character: "a research analyst that clusters narratives from live data",
actions: ["chain.scan", "x.search", "rag.memory"],
providers: ["coingecko", "dexscreener", "fear&greed"],
style: ["short, sourced reads",
"distinguish live data from modeled numbers"]
}
Character is the identity: what the agent is, what it refuses, how it talks.
Actions are the verbs it may use · a trader guards risk, a launcher walks a fair-launch checklist.
Providers are the live context piped into every turn, so the character reasons over the current market, not a memory of one.
Sessions: one agent, one channel
The runtime addresses agents by stable IDs, and every conversation runs in a private session bound to exactly one agent · so a turn meant for trader can never be picked up by whoever is idle:
POST /api/messaging/sessions # open a private channel
{ "agentId": "5793f520-…", … } # exactly one agent inside
POST /sessions/:id/messages # send the turn
{ "text": "scan SOL", "transport": "stream" }
event: chunk # the reply, frame by frame
data: {"chunk":"SOL holding the range…"}
The gateway re-emits those frames to your browser in the terminal's own dialect ({"delta": …}), so the page never needs to know which layer of the swarm answered.
Hosted
The runtime is not self-hostable and the agents are not downloadable. The swarm runs inside RobiOS infrastructure only · you reach it through the terminal and the desktop app.
Degrade, never die
The runtime is the preferred mind · it holds long-lived agent state. But it is deliberately not a single point of failure: if it times out or answers empty, the gateway falls through to the model mesh with the same character sheet. Slower brain, same personality.
One key, every frontier lab. The mesh rides the OpenRouter network, so the swarm draws on the strongest models on the planet · merged behind one interface, with the treasury picking up the bill.
The frontier roster
Every top lab, one door. These are the minds the mesh can route a turn to · the same roster you can hand-pick from in the desktop app:
openai/gpt-5.6-lunaprimary today
anthropic/claude-fable-5flagship · reasoning
google/gemini-3.1-proflagship · long context
x-ai/grok-4flagship · realtime
deepseek/deepseek-v4flagship · code
The ranked chain
Per turn, the mesh walks a ranked chain: the flagship answers most turns; flash-class minds cost fractions of a cent and cover its bad minutes; the shared free pool exists only so the terminal has a floor under it:
gpt-5.6-luna · claude-fable-5 · gemini-3.1-proflagship tier · answers first
for (const model of hasImage ? VISION_CHAIN : TEXT_CHAIN) {
ok = await stream(model, turn); // first mind to answer wins
if (ok) break; // silence → next rung, same turn
}
The vision chain
A turn carrying a screenshot walks a shorter chain · only minds that declare image input. A text-only model would 400 on the image part and read as "everyone is busy", so it is simply never asked:
24,000-token output ceiling for working agents · roughly 2,500 lines, so a full site finishes streaming and closes its ``` fence instead of dying mid-tag.
150-second stream window · long enough for a whole app, with SSE keep-alive so the socket never idles out.
Six-turn rolling history · "now make the header blue" works after a huge build without re-billing the whole conversation.
An agent that reasons over stale data is a very confident liar. RobiOS grounds the swarm in feeds fetched live, in your browser, from public market APIs.
The sources
coingecko /search/trending what the market is chasing
coingecko /simple/price BTC · ETH · SOL + 24h change
alternative.me /fng fear & greed index
dexscreener /token-boosts/latest fresh pairs being pushed
dexscreener /latest/dex/search live liquidity snapshots
These power the terminal's scan, news, report, hunt and whales commands, the suggestion columns and the trending rails. No key, no proxy · your browser talks to the same endpoints any analyst would:
const [trending, prices, sentiment, boosts] = await Promise.all([
gecko('/search/trending'), // narratives, ranked
gecko('/simple/price?ids=bitcoin,ethereum,solana'),
fng('/fng/?limit=1'), // fear & greed, 0–100
dex('/token-boosts/latest/v1'), // fresh pairs being pushed
]);
// cached 60s per query · in-flight dedup · errors never cached
Grounding, not decoration
Live numbers are folded into the agent's context on data commands, so research quotes the trending list as it is right now and flags the difference between a live read and a modeled one. The character sheets make that distinction a rule, not a hope: "distinguish live data from modeled numbers."
Testnet
Market data is real and live. Order execution, deployments and balances on top of it are testnet simulations · no real assets move. The full split is on the disclosures page.
The more people use Robi, the cheaper intelligence gets for each of them. That is not a slogan · it is how the fee routing is designed. This page is the math.
Where the money actually flows
One rule, no fine print: everything lands in the treasury, and the treasury pays for everything. There is no percentage carve-up of trading fees · 100% of them arrive in one place, alongside every other revenue stream the ecosystem produces:
trading fees on $ROBI100% → treasury
protocol revenue→ treasury
partner project revenue→ treasury
partner project supply→ treasury
And out of the same treasury, three flows leave:
AI & agent infrastructuremodel APIs · runtime · agents
community initiativescampaigns · builders · growth
airdrops→ $ROBI & Virtuals holders
AI & agent infrastructure. The treasury pays the actual bills: OpenRouter credits for the frontier roster, image and video generation, the agent runtime. This is the line that makes "the treasury pays your AI bill" literal.
Community initiatives. Campaigns, contributor rewards, integrations · the people growing the network get funded from the same pot, not from a side budget.
Airdrops. Accumulated revenue and partner supply are distributed across $ROBI and Virtuals holders. Holding the network means holding a share of everything that flows through it.
Metering: what one run burns
Every agent run is metered, not subscribed. The treasury pays the vendor bill; you burn $ROBI for the run · and the burn amount is not a flat fee. It is calculated individually per run, from live parameters:
// usage burn · priced per run, never flat
run.cost = model.rate * tokens.out // what the mesh pays the lab
+ vision.rate * images // screenshots cost extra
+ imagine.rate * generations; // pictures cost the most
burn($ROBI) = price(run.cost, {
marketCap, // higher cap → each run burns a smaller slice of supply
tokenPrice, // burn is denominated in $ROBI at the live price
modelTier, // a flagship answer meters higher than a flash one
networkLoad, // quiet hours meter cheaper than peak
});
treasury.pay(run.cost); // the network settles the bill
The meter adapts so the same run never over- or under-charges: as market cap grows, each run burns a smaller share of supply; as load shifts, pricing follows it. The exact curve is published at TGE together with the contract.
Why more users = cheaper AI
modeled curve · cost per run vs network size, flat subscription shown for contrast
Four forces bend that curve down, and none of them require magic:
Fixed costs amortize. Infrastructure, the runtime, the data layer · the bill barely moves whether 500 or 50,000 people use it. Per person, it collapses.
Volume unlocks bulk pricing. Model vendors price by scale. One treasury negotiating for the whole network clears usage tiers no individual would ever reach.
The treasury compounds. More activity → more fees → a larger compute reserve · while the flagship-first, flash-cover chain keeps the average cost per answer a fraction of a flagship-only bill.
Burn tightens supply. Every run burns $ROBI, so growing usage strengthens the very asset that funds the treasury.
The subscription stack vs Robi
What you pay today
On RobiOS
Chat subscription · ~$20/mo
burn per run, any frontier model
Image generation sub · ~$10+/mo
imagine, metered the same way
Coding assistant · ~$10–20/mo
the builder agent, in the same balance
Five accounts, five bills, five caps
one balance, one door, one identity
Quiet month? Billed anyway.
quiet month burns nothing
The flywheel from $ROBI Tokenomics closes the loop: usage funds the treasury, the treasury funds intelligence, intelligence attracts builders, builders bring usage.
Everything the terminal accepts. Plain English works everywhere; commands are the fast path.
Workspace
help all commands, one screen
clear wipe this session
agents list the catalog
status attached agents
attach trader plug a specialist into the session
detach clear the workspace
gm say hi to the runtime
Live market
scan SOL live dexscreener read on a token
news market headlines
report live market brief · prices, trend, sentiment
hunt score fresh meme pairs
whales top wallet flows
On-chain · real, wallet-signed
These run against real chains. Reads are live; every transaction is prepared by the agent and signed by you in your own wallet · non-custodial, always, with an explorer link as proof.
balance your connected wallet, read live from the chain
swap 0.01 eth to usdc real DEX swap · both directions, approvals handled
rebalance 60/40 real holdings → weights → the one swap that closes drift
analyze 0x<address> any wallet: balance, activity, latest decoded txs
watch 0x<address> live watch · alert + tx read the moment it moves
mirror execute the proposed mirror at your guard ratio
guard 0.05 set how big your mirrors are vs the leader
backtest solana rsi real backtests · sma / rsi / breakout + equity chart
practice trade sign a practice transaction end to end
launch register $NAME wallet-signed launch marker, on-chain
Build & create
build "telegram whale alerts" full build pipeline · streams a working app
draft a thread about $ROBI KOL hooks, scored
call $SOL alpha call written on live pair data
imagine "a lime robot" generate a picture · for real, in seconds
make it 3d picture → orbitable 3D mesh + OBJ export
launch $MYTOKEN fair-launch checklist
The IDE around it
Sessions & tabs · every session is a tab; + opens another. Files the builder ships land in the Files tool window and open in the editor.
The terminal's whole point is shipping. build turns a sentence into a working app · streamed live, previewable in one click, saved into your workspace.
From sentence to artifact
01
Your sentencebuild "telegram whale alerts" · or a pasted screenshot
02
The plan2–3 lines first · so you can stop a wrong build early
03
One complete file streams ininline CSS + JS · no external assets · it runs when opened
04
Artifact detectedPreview ↗ · Download · saved to your workspace files
The builder's contract
The builder character is under hard rules, and the mesh is tuned so it can keep them:
One self-contained file. Inline styles, inline scripts, zero external assets · what streams in works offline, as-is.
Real copy, no lorem ipsum. The page ships with content, not placeholders.
Room to finish. A 24,000-token output ceiling (~2,500 lines) and a 150-second stream window, so a full landing page closes its final tag instead of dying mid-file.
The terminal watches the stream for the fenced block and is deliberately forgiving about the ending · a build that hits the very end of the window still becomes an artifact:
// artifact detection · the end of input counts as a closing fence
const artifact = /```([a-z0-9]*)\n([\s\S]*?)(?:```|$)/i.exec(streamed);
if (artifact) attach({ lang: artifact[1], code: artifact[2] });
// → [ Copy ] [ Download ] [ Preview ↗ ]
Your workspace is yours
Sign in once (email code or wallet) and you get a personal terminal handle · ROBI-XXXX-XXXX · derived from your identity, stable forever. Everything the builder ships lands in a workspace scoped to that handle:
robi-workspace › session-01
├── welcome.robi # your handle's home
├── whale-alerts.js # what the builder shipped yesterday
└── notes.md # editable · Ctrl+S saves, tabs stay open
Files tool window · open, edit, rename, delete, download any file the swarm made for you.
Sessions are isolated · every tab has its own scrollback and attached agent; your files are shared across them.
Two guests never collide · workspaces are namespaced per handle, not per browser.
Iterate like a developer
❯ build "landing for a whale-alert telegram bot"
… full page streams in · Preview ↗
❯ make the header darker and add a pricing row
builder: two edits · same file, updated. # six-turn memory
… updated page streams in · Preview ↗
Follow-ups ride the same six-turn history window, so "make the header darker" costs a fraction of the original build · the file is not re-uploaded, the model is not re-briefed.
The terminal has eyes both ways: show it a picture, or ask it to make one.
Show it something
Attach with the paperclip, paste with Ctrl+V, or drop a file on the terminal. The browser downscales it to ~1024px before anything is sent, then the turn rides the vision chain:
⧉ screenshot.png attached
❯ roast this landing page
builder: the hero buries the CTA and the nav has 11 items.
Fix: one promise, one button, three sections. Want the rebuild?
The picture rides on that turn only · a follow-up like "now fix the header" does not re-upload it. Accepted: png, jpeg, webp, gif · up to ~1 MB after downscaling.
Make it something
❯ imagine "robi in a server room, acid lime neon"
⧉ picture generated · click to open full size
# attach a source picture first and imagine edits it instead:
⧉ hero.png attached
❯ imagine "same scene, darker, rain outside"
With a source attached, the model edits your picture rather than inventing a new one · "make this darker" on your own screenshot. Generation is capped at a few pictures per minute per person; a picture costs roughly a hundred text answers, and the cap is still faster than anyone can look at them.
The swarm's specialist roster. Each runs the same architecture · character, actions, providers · pointed at a different job. These are not chatbots with costumes: they read real chains, quote real routes, and every transaction they prepare is signed by you.
Traderswap · balance · risk.guard
Charts over vibes. Reads your wallet live, quotes the best DEX route and hands you the transaction to sign · explorer proof on every fill.
Copy Traderwatch · mirror · guard
Real copy-trading: watches any wallet on mainnet, reads each transaction the moment it lands, sizes a mirror at your guard ratio · you sign, it never does.
Smart Walletanalyze · wallet.read
Point it at any address: live balance, lifetime activity, the latest decoded transactions · then a behavioral read on what that wallet actually does.
Portfoliorebalance · balance · swap
Reads your real holdings, prices them live, shows the weights and proposes the one swap that closes the drift · you approve it in the wallet.
Strategybacktest.run · paper.trade
Runs real backtests on real price history · 180 days of daily closes, honest Sharpe, honest drawdown · and says promotable or dead, plainly.
Researchchain.scan · x.search · rag.memory
Clusters narratives from live feeds · prices, sentiment, trending flows are piped into every answer, so the read is about today, not training data.
Meme Hunterbundle.detect · x.velocity
Watches new pairs live, flags bundles and rug risk plainly before they trend · paste any contract for an on-the-spot read.
Buildersite.scaffold · code.write
Idea in, working product out: one complete self-contained app per answer, previewable in one click, saved to your workspace.
KOLcall · x.share · hook.score
Ghost-writes hooks, threads and alpha calls on live pair data · one number, one risk note, and a one-click share that posts from your account.
Communitydiscord.reply · campaign.track
Knows the docs cold. Answers RobiOS, tokenomics and agent questions with cites.
Token Launcherlaunch.register · lp.lock
Fair-launch engineer. Walks the checklist and registers your launch on-chain with a wallet-signed marker · explorer link included.
Treasuryyield.route · balance
Finds idle capital in a live wallet read and routes it · staking, LP, reserve · every move spelled out before you sign it.
What they can actually do
The shortest honest tour · five commands, five real outcomes:
❯ watch 0x28C6…1d60
copy trader: watching · on movement I read the tx and size a mirror
❯ analyze 0xd8dA…6045
smart wallet: balance 6.632 ETH · 5,951 txs · delegated wallet (EIP-7702)
recent: deposit → 0x7a59… 0.010Ξ · transfer → USDT …
❯ backtest solana
strategy: SMA20/50 · 180d: strategy -15.2% vs hold -39.3% · max DD 19.4%
❯ swap 0.01 eth to usdc
trader: quote 19.20 USDC (min 18.99 after slippage) · sign in the wallet
❯ imagine "a lime robot" · make it 3d
3d artist: relief mesh in the feed · drag to orbit · OBJ + texture ↓
Every number above is the kind these agents return · live reads, real math, wallet-signed execution. Nothing moves without your signature, and nothing pretends: what is projected is labeled projected.
Plus one
Robi herself · the mascot agent on the hero screen · is the thirteenth character: a guide, not a specialist. Same swarm, smaller answers, warmer voice.
Attach any of the twelve in the terminal (attach trader), or pin one from the toolbar and every prompt in the session routes to it.
The swarm on your machine: the same agents and the same terminal code as the site, running as a real Windows app against your own OpenRouter key.
Same swarm, your hardware
One identity. Sign in with the same email as robi.pw · same six-digit code, same ROBI-XXXX-XXXX handle. The app is not a separate world.
Your key, your model. The terminal answers through your OpenRouter key on the model you pick · GPT 5.6 Luna by default, the same primary the site runs, or anything else on the network.
The idle swarm. Twelve agents accrue while the window is closed · on relaunch you are paid out for up to eight hours away. Boost nudges one; Unlock brings the next online.
It edits real files · on your terms
Point Robi at one folder. It can list, read and write inside it and nowhere else · enforced in code, not asked for in a prompt: every path is resolved and refused if it escapes the folder. Reads are silent; every write pops a dialog naming the file before a byte lands on disk.
❯ what is in notes.md, and add a line about the buyback
listing · .
reading · notes.md
It is a short list of open questions on the token · four bullets,
no buyback line yet. Adding one at the end.
writing · notes.md # ← confirmed by you, in a dialog
Done. The buyback note sits under the existing bullets.
Where the key lives
In the app's main process, on your disk. It is never in the page, so nothing rendered on screen can read it · and it never reaches the site or any RobiOS server.
The swarm calls paid models on the project's key, in public, with no login wall. That only works if the boring parts are done right.
Where keys live
Site: the model key exists only in server environment. It never ships to a browser · the page talks to /api/agent, never to a model vendor directly.
Desktop: your personal key stays in the app's main process on your machine, outside the rendered page, and is never sent to RobiOS.
The gate, in order
Same-origin only. Genuine cross-site calls are rejected before any model is contacted.
Rate limits. Per-person and per-instance ceilings, sized so no real user ever hits them:
Text answers60 / min per IP
Image generation5 / min per IP
Prompt size4,000 chars
History windowlast 6 turns
Attached image~1 MB · data-URL only
Output ceiling24,000 tokens
No SSRF by construction. Attached pictures must be inline data-URLs · the gateway will not fetch a remote URL on a caller's behalf, ever:
// the only shape a picture may arrive in · a remote URL is rejected outright
/^data:image\/(png|jpeg|webp|gif);base64,[A-Za-z0-9+/=]+$/
Limiters fail open. An internal error never blocks a real user; the hard financial stop is the spend cap on the key itself, which only its owner can set.
What we do not have
No analytics, no cookies, no trackers, no fingerprinting. Session state lives in your browser's localStorage; wiping site data wipes everything RobiOS knows about you. Full text on the privacy page.
One token instead of five subscriptions. $ROBI turns protocol revenue into shared AI infrastructure: the treasury pays the model bills, and every use burns a little $ROBI.
At TGE
$ROBI has not launched. There is no contract address until it appears on this site and nothing here is an offer or a promise of a token. Anyone selling you "$ROBI" today is selling you nothing.
How the treasury pays for AI
Everything flows in. 100% of trading fees on $ROBI land in the Robi Treasury · alongside protocol revenue and the revenue and supply of partner projects.
The treasury buys intelligence. It pays the actual bills: frontier models via OpenRouter, image and video generation, coding agents, the runtime · and it funds community initiatives from the same pot.
You burn, not subscribe. Each agent run burns $ROBI, priced individually per run from market cap and other live parameters. No monthly bills · pay only for what you use.
Holders get the upside. Accumulated revenue and partner supply are airdropped across $ROBI and Virtuals holders as the ecosystem compounds.
The flywheel
more trading activity → larger treasury → more AI capacity
→ more builders and apps → more protocol revenue
→ more $ROBI burned → a stronger ecosystem
Planned utility
Swarm access: burning $ROBI opens the terminal's full command set and agent roster.
Compute: runs are metered in $ROBI; holders get boosted rates.
Campaign rewards: community campaigns pay contributors from project pools.
Governance: treasury spend and roster listings, token-voted.
ROBI