<div align="center">

⚡ TERAHOOD Agent

Your agent can't have a credit card. Give it a wallet instead.

An autonomous agent that buys its own compute on Robinhood Chain. No account. No API key. No card. The wallet is the login — and the burn is the receipt.

</div>

---

The problem

An AI agent with a wallet cannot buy inference from a closed provider.

Not "prefers not to" — cannot. No credit card. No KYC. No email inbox. No 2FA device. The billing rail that makes closed models convenient for humans makes them unreachable for software.

Meanwhile the buyer class is already here:

~69,000	active agents paying onchain via x402
~165M	agent transactions processed
~$50M	cumulative volume
0	of them hold a credit card

_{x402, by April 2026}

They have money and nowhere to spend it. This is the door.

Install

npm install @terahood/agent

30 seconds

import { Agent } from "@terahood/agent";

const agent = new Agent({
  privateKey: process.env.AGENT_PRIVATE_KEY,
  endpoint: process.env.FORGE_ENDPOINT,
});

const r = await agent.think("Is compute a real-world asset?");

console.log(r.answer);
console.log(r.burnRef);   // proof the job ran, on-chain

That's the whole integration. No signup step, because there isn't one.

What it does when you're not looking

await agent.loop(() => queue.next(), {
  onResult: (r) => console.log(r.burnRef, r.answer),
});

It checks its balance. If the next job would leave it short, it mints more grams itself and keeps going. No human approves anything.

$ agent.tick()
balance 0g · need 0.15g
$ bars.mint(1g)
minted 1g · signed by 0xff6e1ea7…
$ forge.think("should I reserve H100 capacity?")
routing → Forge 70B · Llama 3.3 70B · 0.15g
HTTP 402 payment required · 0.15g
paid · 0x59ea…7e6e2 · retrying with X-PAYMENT
inference · 583 tokens
  │ Reserve. New hardware is 36–52 weeks out and on-demand
  │ runs 2–3x at peak. 8x H100 for 40h = 448g.
receipt BRN-46BA18A5 · 0xf1b5…974655 → ledger

How a payment actually works

sequenceDiagram
    participant A as Agent
    participant F as Forge
    participant C as Robinhood Chain

    A->>F: POST /x402/forge
    F-->>A: 402 Payment Required<br/>{ asset, amount, nonce }
    A->>A: sign terms with wallet key
    A->>F: POST /x402/forge<br/>X-PAYMENT: …
    F->>C: burn(grams, deliveryHash)
    C-->>F: burnRef
    F-->>A: 200 + answer<br/>X-PAYMENT-RESPONSE: { burnRef }

The signature is the authorization. There is no account to create, because the wallet already is one.

Compute Bars

The asset the agent spends. Prepaid GPU-hours, minted on-chain, denominated like gold ingots.

1 gram ≈ $1 of compute. Transferable — hold them, trade them, or burn them.

Model	Cost	Class
forge-8b	0.05g	Fast answer
mixtral	0.10g	Fast answer
coder-33b	0.12g	Code
forge-70b	0.15g	Deep reasoning
qwen-72b	0.15g	Deep reasoning
deepseek-v3	0.20g	Deep reasoning

One bar, two ways to spend it: finished answers (above) or raw GPU hours (0.50g/hr RTX 4090 → 1.40g/hr H100 SXM).

Three doors

However your agent already talks, there's a way in.

<table> <tr><td width="33%">

OpenAI-compatible

Point any existing SDK at the Forge. The migration cost is a base URL.

</td><td width="33%">

x402

402 → pay → retry with receipt. The protocol 69,000 agents already speak.

</td><td width="33%">

MCP

Plug the Forge in as a tool. It discovers the menu and buys.

</td></tr> </table>

# MCP
claude mcp add foundry -- node foundry-mcp.js
# tools: forge_think · forge_menu · forge_rent_gpu · forge_ledger · forge_key_balance

Every job proves itself

Ask any AI provider to prove a specific inference ran — on the model you paid for, at the time they billed you. They can't. You get a dashboard and their word.

Every burn here writes a burn ref and a delivery hash of the request and response to a public ledger on Robinhood Chain.

const r = await agent.think("…");
r.burnRef;       // BRN-46BA18A5
r.deliveryHash;  // 0xf1b5…974655

Proof-of-reserve, except the reserve delivers itself.

API

new Agent({ privateKey, endpoint, rpcUrl?, minBalance? })

Method	Returns
agent.address	the agent's wallet address
await agent.balance()	grams held
await agent.mint(grams)	tx hash
await agent.ensureFunded(need)	tops up if short, returns balance
await agent.think(prompt, { model })	{ answer, model, grams, burnRef, deliveryHash }
await agent.menu()	available models + gram prices
await agent.loop(nextPrompt, opts)	runs forever

Config

cp .env.example .env

Var	What
AGENT_PRIVATE_KEY	the agent's wallet — use a burner, this is an autonomous spender
FORGE_ENDPOINT	Forge base URL
RPC_URL	optional; defaults to the public Robinhood Chain RPC (rate limited)

Network — Robinhood Chain, chainId 4663, ETH gas, ~100ms blocks, fully EVM. ComputeBar — 0xb32732c5b27b14cd7e0911fdb1f5a03b1cf86715

⚠️ Fund the agent's key with only what you're willing to let it spend. It mints without asking — that's the entire point.

Status

Early. The SDK and the x402 flow are implemented against the endpoint above; expect the interface to move before 1.0. Issues and PRs welcome.

Why this exists

Robinhood is bringing real-world assets on-chain, and compute is the cleanest one on the list — real, scarce, dollar-priced, and 100% digital. No vault, no courier, no custodian. It delivers itself and signs its own receipt.

Agents were handed wallets. They needed something to buy.

---

<div align="center">

terahood.xyz · @terahood_xyz · Proof Ledger

Compute, made tangible.

</div>