How orbio.bot works.

Overview

orbio sells AI inference as CREDIT: one CREDIT is one dollar of Orbio usage. It trades on orbio's Exchange, an order book that only holds asks, and activate burns it into API balance for a wallet. orbio.bot adds what agents and their operators need around that token.

• Bids: escrow USDG with a price limit. Bots fill it against orbio's book whenever asks are cheap enough, once or as a recurring buy.
• Fleets: escrow CREDIT and give each agent wallet an allowance that refuels it, as CREDIT or as activated inference.
• Drops: CREDIT anyone can claim from a link, and payouts to up to 200 wallets in one transaction.

All amounts use six decimals (USDG and CREDIT). Prices are orbio's integers: 10000 is 1 USDG per CREDIT, so 4250 is 0.425 USDG, or 57.5% off.

Bids

A bid escrows USDG with terms: a price limit, an optional per-fill cap or a recurring budget, a filler tip, a recipient and a delivery mode. Anyone may fill an open bid unless its owner named one filler.

The price limit is all-in

A fill reverts unless the USDG that left the bid, plus the tip, divided by the CREDIT the recipient actually received, is at or under the limit. For a CREDIT bid that includes orbio's book fee; for an activating bid it includes the token's activation fee (the book charges activating buys no fee). The check allows a few millionths of a USDG for the book's per-slice rounding.

(spent + tip) * 10000  <=  delivered * maxPrice + (maxFills + 1) * 10000

With today's 2% book fee, a CREDIT bid with a 0.45 limit and a 0.3% tip fills against asks up to about 0.4398. An activating bid with the same limit fills against asks up to about 0.4262.

Limit bids and recurring buys

• Limit bid (interval 0): fills whenever it can, in as many pieces as bots choose. A per-fill cap is optional.
• Recurring buy (interval above 0): the budget grows by perFill USDG every interval, up to one period's worth, and fills spend it. A tiny fill only spends a tiny part of the budget, so no one can push a recurring buy back with dust.

The owner can top up, change the terms, withdraw part, or close the bid and take back everything left, at any time.

Fleets

An operator opens a fleet, funds it with CREDIT (or with USDG spent on orbio's book in the same transaction) and adds bots. Each bot has a wallet, a rate per period, a cap on what it can bank, and a delivery mode.

• A bot earns rate CREDIT every period seconds, banked up to cap.
• refuel(fleetId, botId) pays what it earned, as far as the fleet's balance covers it. Anyone may call it; it only ever pays the bot. The minimum is 0.01 CREDIT.
• refuelAll(fleetId) pays every active bot that earned the minimum. A fleet holds up to 64 bots.
• The operator pauses, retunes or rotates a bot's wallet at any time; earned allowance is kept. Handing a fleet over takes two steps: propose, then the new operator accepts.

Activated refuels are the default: the bot's wallet never holds CREDIT it could lose, it only gains Orbio balance.

Drops

A drop escrows perClaim * claims CREDIT and stores the address of a one-time link key. The link is https://orbio.bot/claim#<id>.<key>: the key sits in the fragment, which browsers never send to any server.

To claim, the page signs the contract's claimDigest(id, recipient, activate) with the link key (an EIP-191 personal message) and sends claim. The signature binds the recipient and the delivery mode, so anyone may relay a claim but only the signed wallet is paid. Each wallet claims a drop once.

The sender closes a drop at any time and gets the rest back. After it expires anyone may close it, and the rest still goes to the sender.

payout(recipients, amounts, activate, note) pays a list of up to 200 wallets in one transaction.

For agents

An agent wallet funded by a fleet finds its allowances, refuels, and signs once for its Orbio API key, exactly as orbio's own agent guide describes.

// 1. find the allowances that name this wallet (newest first)
const slots = await client.readContract({ address: FLEET, abi, functionName: 'slotsOf', args: [me, 0n, 20n] });

// 2. collect what it earned into its Orbio balance
for (const { fleetId, botId } of slots) {
  const [, deliverable] = await client.readContract({ address: FLEET, abi, functionName: 'available', args: [fleetId, botId] });
  if (deliverable > 0n) await wallet.writeContract({ address: FLEET, abi, functionName: 'refuel', args: [fleetId, botId] });
}

// 3. sign once for the API key, then call the gateway
const sig = await wallet.signMessage({ message: 'Orbio API key · chain 4663 · epoch 0' });
const key = `sk-orb-0-${Buffer.from(sig.slice(2), 'hex').toString('base64')}`;

An agent can also keep itself topped up with no operator at all: a recurring activating bid with itself as recipient buys inference on a schedule at a price it chose.

For keepers

Bids pay their tip to whoever fills them. A keeper reads open bids, simulates each fill with a static call (a fill that would break the limit reverts), and sends the ones that land.

const n = await client.readContract({ address: BIDS, abi, functionName: 'count' });
for (let id = 1n; id <= n; id++) {
  const cap = await client.readContract({ address: BIDS, abi, functionName: 'fillable', args: [id] });
  if (cap < 10_000n) continue;
  try {
    const { request } = await client.simulateContract({ account, address: BIDS, abi, functionName: 'fill', args: [id, cap, 64n] });
    await wallet.writeContract(request);
  } catch { /* the book cannot fill it at its limit yet */ }
}

When the whole budget does not fit under the limit, a smaller amount may: search downward. The Bids page does this for you and shows every bid you can fill now.

Contracts

Robinhood Chain, chain id 4663. Every address, orbio.bot's and the orbio contracts it calls, is listed in contracts.json and in llms.txt. Sources are verified on Sourcify.

• OrbioBotBids: place, fund, update, withdraw, close, fill; views getBid, bidsOf, fillable, budgetOf, count.
• OrbioBotFleet: createFleet, fund, fundFromBook, withdraw, addBot, updateBot, setBotWallet, refuel, refuelAll, proposeOperator, acceptOperator; views getFleet, botsOf, available, fleetsOf, slotsOf.
• OrbioBotDrops: create, createFromBook, claim, close, payout; views getDrop, dropsOf, claimable, claimDigest.

Fees and limits

• orbio.bot takes no fee. orbio's book fee (2% today) applies to CREDIT bids and book funding; the token's activation fee (5% today) applies to everything activated.
• Bids: at least 1 USDG to open, fills of at least 0.01 USDG, tips up to 1%, intervals up to a year, up to 64 asks per fill.
• Fleets: up to 64 bots, periods from one minute to one year, refuels of at least 0.01 CREDIT.
• Drops: at least 0.1 CREDIT a claim, up to 1,000 claims, up to a year to expiry, payouts to up to 200 wallets.