# Orbio for agents

> Discounted inference, onchain and ready for agents.

CREDIT protocol · September 2026

Orbio is bringing the discounted inference layer onchain. An agent can buy $CREDIT and get straight to work, without opening a website, completing a checkout, or waiting for a human to provision access.

Inference becomes a resource agents can acquire, pass between each other, and use as part of the work itself. One agent can fund its next task. A network of agents can distribute credit across its workers, pay for contributions, and keep work moving. AI access can scale with the software using it, without someone manually setting up every new worker.

## The basic idea

Each CREDIT represents $1 of AI usage through Orbio. Hold it, transfer it, sell it, or activate it as AI balance. Activation burns the token permanently; the resulting balance cannot be transferred or redeemed for cash. Staking ORBIO earns CREDIT, but an agent can buy CREDIT without staking.

## The Unlock

Inference is now a commodity, you can trade it or use it on the open market. Orbio makes discounted inference instantly available for anyone on the planet.

Unused CREDIT can move to someone who needs it. Sellers set a price on the order book; buyers choose what to pay. A Uniswap pool provides another route, with arbitrage giving traders an incentive to bring the two market prices closer. The market determines the purchase price. Each CREDIT still activates $1 of AI usage.

![Hand-drawn CREDIT protocol machine with eight-ray asterisk coins connecting staking, markets, transfers, and activation to the Orbio Gateway, with Claude, Codex, Gemini, Grok, DeepSeek, and Qwen logos on six inference units.](https://www.orbio.so/credit-protocol-blueprint-asterisk.png)

The CREDIT machine — an artist’s view of how ownership, markets, and inference connect.

## How an agent uses it

Contract calls and API setup for agents. The deployed addresses are listed under Contracts, with links to the explorer.

### 1. Acquire CREDIT

Fund a wallet with USDG and gas for Robinhood Chain. Buy CREDIT from the order book or swap through a Uniswap pool route, with a maximum spend and minimum CREDIT output. An agent can also receive CREDIT from another wallet.

**Order book · Solidity calls**

```solidity
// USDG and CREDIT: 6 decimals. 1 token = 1_000_000 units.
exchange.getQuote(usdgIn, maxFills);
usdg.approve(address(exchange), maxTotalUsdg);
exchange.buy(usdgIn, minCreditOut, recipient, maxFills);
```

getQuote returns creditOut, usdgSpent, feeAtoms, fills, and a stop reason. usdgIn excludes fees; cap the USDG allowance at your total budget, including fees. Set a positive minCreditOut and use 1 to MAX_FILLS() makers. Quotes do not reserve liquidity.

[Exchange ABI · integration subset](https://www.orbio.so/protocol/abi/exchange.json)

**Uniswap · Router entry point**

```solidity
universalRouter.execute(commands, inputs, deadline);
```

The planned pool pairs CREDIT with ORBIO. USDG may route through USDG → NVDA → ORBIO → CREDIT where liquidity exists. Encode the quoted path, input limit, minimum output, and settlement in commands/inputs; configure the required token/Permit2 allowances. The router does not search Orbio’s order book.

[Uniswap command encoding](https://developers.uniswap.org/docs/protocols/universal-router/concepts/commands)

### 2. Activate what it needs

Activate tokens already held, or buy and activate directly from the book. Wait for the activation to appear in the recipient’s AI balance before making requests.

**Activation · Choose one path**

```solidity
// Activate CREDIT already held, for the calling wallet.
credit.activate(amount);

// OR buy and activate, after approving USDG as above.
bytes32 beneficiary = bytes32(uint256(uint160(recipient)));
exchange.buyAndActivate(
    usdgIn, minCreditOut, beneficiary, maxFills
);
```

amount uses 6 decimals: 25_000_000 activates a $25 AI balance. Activated receipts are identified by chain, CREDIT contract, and activationId; a transaction can contain more than one receipt.

[CREDIT ABI and activation event · integration subset](https://www.orbio.so/protocol/abi/credit.json)

### 3. Sign once for API access

The wallet signs Orbio’s authentication message locally. Its encoded signature becomes the private API credential; there is no key-creation transaction or website checkout.

**Wallet signature · Node.js / viem, EOA example**

```typescript
const epoch = 0; // Use the current epoch if already rotated.
const signature = await wallet.signMessage({
  message: `Orbio API key · chain 4663 · epoch ${epoch}`,
});
const apiKey = `sk-orb-${epoch}-${Buffer
  .from(signature.slice(2), 'hex').toString('base64')}`;
```

Keep the signature and API key secret. Funding the same account again preserves its key. Rotation uses a higher epoch, accepted on the first successful request.

### 4. Get to work

Choose a model from GET /api/v1/models, then send requests to the gateway. Usage draws from the activated balance.

**Inference · HTTP request**

```sh
# ORBIO_API_KEY is the credential; MODEL_ID comes from /api/v1/models.
curl "https://www.orbio.so/api/v1/chat/completions" \
  -H "Authorization: Bearer $ORBIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"$MODEL_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"Plan the next task.\"}]}"
```

### 5. Know your balance

The same credential answers how much it can still spend. GET /api/v1/key returns the available balance, lifetime usage and the key’s rate limits; GET /api/v1/auth/key returns the same in OpenRouter’s shape, so a client that already reads limit_remaining there needs no change. Every gateway response also carries an X-Orbio-Balance header with the balance the request started from.

**Balance · HTTP request**

```sh
curl "https://www.orbio.so/api/v1/key" \
  -H "Authorization: Bearer $ORBIO_API_KEY"
# {"object":"key","balance":{"currency":"USD","available":"12.34","used":"7.66", ...},
#  "rate_limit":{"requests_per_minute":120,"concurrent":32}}
```

Money is a decimal string, exact. A charge lands after the answer it pays for, so read this after a request to see what it cost; X-Orbio-Balance on the response itself is the figure the request began with.

### 6. Share and replenish

Send unactivated CREDIT to another worker, or acquire and activate more for the same account. The agent’s own budget rules decide when to top up.

**Transfer · Standard ERC-20 call**

```solidity
credit.transfer(worker, amount);
```

## Applications

- **Agents that fund their next task.** Research, coding, and monitoring agents can replenish inference as they work, within a budget set by their operator.
- **Teams of agents.** A coordinator can distribute CREDIT to workers as tasks emerge. Each worker activates the amount it needs.
- **AI built into a product.** Give users or agents a CREDIT allowance, then top it up without issuing new credentials.
- **Pay contributors in inference.** Reward useful work with CREDIT that the recipient can use, transfer, or sell.
- **Trading activity that funds development.** A project can pair its token with $CREDIT in a fee-bearing pool and collect its share of trading fees in CREDIT. That inference can power the agents building, testing, and maintaining the project. The project needs to own liquidity or have explicit fee routing; pairing alone does not pay the issuer.

This project-pool application is separate from Orbio’s planned CREDIT/ORBIO pool, which has a 0% LP fee.

## Where the discount comes from

Half of collected ORBIO trading fees funds AI usage. Stakers earn CREDIT against that funding and can sell what they do not use.

Buying CREDIT pays its seller. The AI funding was allocated earlier, so a seller can offer CREDIT below its $1 usage value. The discount depends on market prices.

## Availability

CREDIT ownership and trading happen onchain. Inference and balance accounting run through Orbio’s gateway and model providers, subject to their availability and pricing.

## Contracts

Robinhood Chain (chain 4663)

- **CREDIT** `0xe33322da1380e61e5ae5dfb21e7f62924c73004c` — The token. One CREDIT is one dollar of Orbio inference; `activate` burns it into API balance.
- **Staking** `0xe0710011278bfb63e57c5f227e5980984b1eddca` — Stake ORBIO here. Settles and mints each finalized hour’s CREDIT.
- **Exchange** `0x6951ffd32630b05e06f50062aea801625a58ebc0` — The order book: `sell`, `buy`, `buyAndActivate`, and seller claims.
- **Payout** `0x4cbbbf652b11ed1294df0ac49d8322394310cfc5` — The fixed USDG → NVDA → ORBIO route behind `claimProceedsAsOrbio`.
- **ORBIO** `0xaa07a0e9209e16ac99708c3ec70159c6ef3128a3` — The token staking pulls.
- **USDG** `0x5fc5360d0400a0fd4f2af552add042d716f1d168` — What buyers pay and sellers are paid in.
- **NVDA** `0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC` — Tokenized NVDA, the asset creator fees are collected in.

## References

[CREDIT ABI — integration subset](https://www.orbio.so/protocol/abi/credit.json)

[Exchange ABI — integration subset](https://www.orbio.so/protocol/abi/exchange.json)

[ERC-20 ABI — USDG approvals and balances](https://www.orbio.so/protocol/abi/erc20.json)

[Read this guide on the web](https://www.orbio.so/protocol/agents)

[Agent documentation index](https://www.orbio.so/llms.txt)