<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](https://docs.robinhood.com/chain/).
No account. No API key. No card. The wallet is the login — and the burn is the receipt.

[![License: MIT](https://img.shields.io/badge/License-MIT-c8f542?style=flat-square)](./LICENSE)
[![Node](https://img.shields.io/badge/node-%E2%89%A518-c8f542?style=flat-square)](https://nodejs.org)
[![Chain](https://img.shields.io/badge/Robinhood%20Chain-4663-c8f542?style=flat-square)](https://robinhoodchain.blockscout.com)
[![x402](https://img.shields.io/badge/x402-enabled-c8f542?style=flat-square)](https://www.x402.org)

</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 |

<sub>x402, by April 2026</sub>

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

## Install

```bash
npm install @terahood/agent
```

## 30 seconds

```js
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

```js
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

```mermaid
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 |
|---|---|---|
| `kimi-k3` | 0.50g | **Frontier** — 2.8T MoE, 1M context, open weights |
| `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>

```bash
# 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.

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

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

## API

```js
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

```bash
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`](https://robinhoodchain.blockscout.com/address/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](https://terahood.xyz)** · **[@terahood_xyz](https://x.com/terahood_xyz)** · **[Proof Ledger](https://terahood.xyz/ledger.html)**

*Compute, made tangible.*

</div>