---
license: cc-by-4.0
pretty_name: "KamiBench Experiment 001 — Budget-Boxed Agents in a Live On-Chain World"
tags:
  - agentic-traces
  - llm-agents
  - blockchain
  - game
  - benchmark
configs:
  - config_name: telemetry
    data_files:
      - split: haiku45
        path: haiku45/telemetry.jsonl
      - split: gpt4omini
        path: gpt4omini/telemetry.jsonl
      - split: gemini25fl
        path: gemini25fl/telemetry.jsonl
  - config_name: transcripts
    data_files:
      - split: haiku45
        path: haiku45/transcripts/*.jsonl
      - split: gpt4omini
        path: gpt4omini/transcripts/*.jsonl
      - split: gemini25fl
        path: gemini25fl/transcripts/*.jsonl
  - config_name: oracle_kami_action
    data_files:
      - split: haiku45
        path: haiku45/oracle/kami_action.jsonl
      - split: gpt4omini
        path: gpt4omini/oracle/kami_action.jsonl
      - split: gemini25fl
        path: gemini25fl/oracle/kami_action.jsonl
  - config_name: oracle_raw_tx
    data_files:
      - split: haiku45
        path: haiku45/oracle/raw_tx.jsonl
      - split: gpt4omini
        path: gpt4omini/oracle/raw_tx.jsonl
      - split: gemini25fl
        path: gemini25fl/oracle/raw_tx.jsonl
---

# KamiBench Experiment 001 — budget-boxed agents in Kamigotchi

Complete agentic traces from **experiment 001**, the KamiBench
calibration run: three LLM agents dropped into
[Kamigotchi](https://kamigotchi.io), a live, persistent, on-chain
world (Yominet), each with a **$10 inference budget**, a **7-day
wall-clock cap**, and no further human contact. One identical
scaffold, one identical tool surface (84 game tools via MCP), one
variable: the model. The agents schedule their own wake-ups, keep
their own files, and act on a real blockchain economy alongside human
players — every on-chain consequence is independently verifiable.

More at [kamibench.ai](https://kamibench.ai).

## Arms

| config | model | stop | duration | sessions | quests | kamis bought | on-chain txs (reverted) |
|---|---|---|---|---|---|---|---|
| `haiku45` | claude-haiku-4-5 | budget ($10.73) | 17.2 h | 15 | 5 | 2 | 106 (61) |
| `gpt4omini` | gpt-4o-mini | 7-day cap ($9.02) | 168.7 h | 166 | 0 | 0 | 30 (29) |
| `gemini25fl` | gemini-2.5-flash-lite | 7-day cap ($8.99) | 168.9 h | 157 | 3 | 1 | 193 (182) |

Headline contrast: haiku registered, funded, bought two kamis, and
completed five quests **on day one**, exhausting its budget in 17
hours. gpt-4o-mini ran the full week and never once called
`register_account` — 24 of its 24 game transactions reverted.
gemini spent six days stuck pre-registration, then registered,
completed three quests, and bought a level-31 kami 90 minutes before
the wall.

## Run report

The run's full report, migrated here from the site's run page on
2026-07-29 when run pages became compact cards
([kamibench.ai/experiments/001-budget-boxed](https://kamibench.ai/experiments/001-budget-boxed));
every number is frozen as originally published.

### What happened

The three arms diverged sharply. Haiku completed the entire onboarding
chain on day one — registered, funded its operator, bought two kamis,
finished five quests — and exhausted its budget in 17 hours.
GPT-4o-mini ran the full week and never once called
`register_account`: 166 sessions, all 24 of its game transactions
reverted, zero quests. Gemini spent six days stuck pre-registration,
was unblocked by a single legible validation error, then completed
three quests and bought a level-31 kami 90 minutes before the wall.
Cost per quest: haiku $2.15, gemini $3.00, gpt-4o-mini ∞.

### Milestones

First success per onboarding/economy milestone, against cumulative
inference. These rows are the frozen baseline that stack iterations
([Run 2](https://kamibench.ai/experiments/002-stack-delta) onward)
are compared against at fixed milestones.

| milestone | haiku-4.5 | gpt-4o-mini | gemini-2.5-flash-lite |
|---|---|---|---|
| bridge ETH mainnet→Yominet landed | 07-10 23:10 · h1.4 · s2 · 0.14M tok · $0.14 | 07-12 04:45 · h31.0 · s32 · 10.33M tok · $1.56 | 07-11 03:35 · h5.8 · s6 · 0.62M tok · $0.06 |
| operator wallet funded | 07-10 23:30 · h1.7 · s4 · 0.65M tok · $0.67 | 07-12 22:40 · h48.9 · s49 · 17.58M tok · $2.65 | 07-11 15:30 · h17.7 · s17 · 5.84M tok · $0.59 |
| account registered in game | 07-10 23:30 · h1.7 · s4 · 0.68M tok · $0.70 | — | 07-16 15:15 · h137.5 · s129 · 62.57M tok · $6.30 |
| first quest completed | 07-10 23:30 · h1.8 · s4 · 0.87M tok · $0.89 | — | 07-16 15:16 · h137.5 · s129 · 63.01M tok · $6.35 |
| first kami bought | 07-11 00:35 · h2.8 · s5 · 2.30M tok · $2.34 | — | 07-17 20:30 · h166.7 · s156 · 87.83M tok · $8.84 |
| first MUSU harvest started | 07-11 01:40 · h3.9 · s6 · 3.14M tok · $3.20 | — | — |
| first MUSU banked (harvest stop/collect) | 07-11 01:50 · h4.1 · s7 · 3.51M tok · $3.57 | — | — |

Cell = first success: UTC time · hours since run start · session
number · cumulative tokens (in+out) · cumulative USD at that moment;
"—" = never happened.

### What we learned

- **Error legibility, not model capability, was the sharpest
  differentiator.** The same model that ignored opaque chain reverts
  for four days corrected a human-readable validation error in one
  turn.
- **A single missing step was the cleanest capability
  discriminator.** Two arms completed every onboarding step *except*
  registration, and neither ever identified it as the blocker.
- **Cost structure dominated spend.** The 84-tool surface re-billed
  on every call dominated token spend, prompt caching was never
  engaged, and un-broken poll loops reached $0.55 per session —
  making repetition detection a budget control, not just hygiene.
- **Orientation speed and decision quality are different axes.**
  Haiku moved fast and bought level-1 kamis; gemini moved slowly and
  bought a level-31 kami near floor price.

Most of what this run taught us was about the stack, not the models —
which is what a stress test is for.

### What it changed in the stack

Each learning above became a concrete change, and the whole bundle
was pinned and re-measured by the next run:

- **Legible pre-transaction validation** — environment interface
  v1.4.0 → v1.5.1. A blocked game action now fails with a factual
  precondition error before any gas is spent, instead of an opaque
  on-chain revert. Directly from the legibility finding and the
  registration blocker.
- **A repetition breaker** — scaffold v0.2.0. Looping sessions end
  instead of billing; Run 1's un-broken poll loops made repetition
  detection a budget control, not just hygiene.
- **Session caps and agent-chosen wake scheduling** — scaffold
  v0.2.0. Bounded session cost, and pacing left to the agent as an
  explicit, logged choice.
- **Cache-aware budget accounting** — scaffold v0.2.0. Prompt caching
  engaged and priced into the budget math, against Run 1's uncached
  84-tool re-billing.

[Run 2 (Experiment 002)](https://kamibench.ai/experiments/002-stack-delta)
re-ran this exact protocol with the same three models and the same
$10 on that stack. Measured against the frozen rows above, the
changes cut chain revert rates from 0.58 / 0.97 / 0.94 to
0.048 / 0.000 / 0.011, got all three arms registered in-game, and
lifted quests at fixed budget (haiku 5→8, gemini 3→5).

## Layout

```
<arm>/
├── manifest.yaml          # full run config: model, sampling params,
│                          #   pinned SHAs (scaffold/harness/game docs),
│                          #   price table, caps, wallet ADDRESSES
├── telemetry.jsonl        # append-only scaffold event stream
├── transcripts/
│   └── session-NNNN.jsonl # full model context per session, as sent
└── oracle/
    ├── kami_action.jsonl  # decoded on-chain game actions (ground truth)
    ├── raw_tx.jsonl       # all txs from the run's wallets, incl. reverts
    └── README.md          # per-arm extract provenance + coverage notes
MANIFEST.json              # sha256 + size for every file above
```

## Schemas

**Transcripts** — one JSONL file per session; one message per line,
exactly as sent to the model (tool results post-truncation at 64 KB):

- `{"role": "user", "text": ...}` — kickoff/continuation strings
- `{"role": "assistant", "text": ..., "tool_calls": [{id, name, args}]}`
- `{"role": "tool_result", "tool_call_id": ..., "content": ..., "is_error": bool}`

**Telemetry** — one event per line; common fields `ts` (ISO-8601 UTC),
`run_id`, `session`, `event`. Event types: `run_start` (pins, price
table, tool list), `session_start` (trigger, budget_remaining_usd,
tools_hash), `llm_call` (input/output/reasoning tokens, cost_usd,
cumulative_usd, latency_ms, stop_reason, retry_count), `tool_call`
(tool, source, duration_ms, ok, error, truncated, tx_hash),
`workspace_write`/`workspace_delete`, `schedule_next` (agent vs default
wake), `session_end` (reason: agent | token_cap | tool_cap | errors |
crash; per-session totals), `run_complete` (reason: budget | t_max;
run totals). Budget fields were never visible to the agents.

**Oracle extracts** — decoded from chain by the investigator-side
kami-oracle service (never accessible to the agents); rows for the
run's operator + owner wallets only. `kami_action.jsonl`: decoded game
actions (`action_type`, `system_id`, `block_timestamp`, `kami_id`,
`tx_hash`, revert status). `raw_tx.jsonl`: every ingested tx including
reverts (`method_sig`, `raw_calldata`, `gas_used`, `status`). Per-arm
`oracle/README.md` records extraction time and coverage caveats.

## Provenance and integrity

Everything is pinned in each arm's `manifest.yaml`: scaffold
([`tokedo/kami-agent`](https://github.com/tokedo/kami-agent)),
environment interface
([`tokedo/kami-harness`](https://github.com/tokedo/kami-harness)
v1.3.1, 84 tools), and game-documentation snapshot SHAs, model
strings, sampling params, and the list-price table used for budget
accounting. Token accounting was reconciled against provider
dashboards at close-out: **exact to the digit** on full in-run days
for OpenAI and Anthropic; chart-consistent for Google. Quest/purchase
counts come from chain state, not self-report. `MANIFEST.json` carries
sha256 for every file.

## Known caveats

- `session-0001` transcripts are missing on **all three arms** — a
  launch-day infra abort (PATH defect in the cron environment),
  documented and excluded from behavior analysis. Telemetry covers
  the gap; sessions 2..N are complete (1:1 session pairing, 0
  malformed lines, contiguous numbering).
- One seed per arm — this is the calibration/smoke run (v0 baseline);
  it establishes the harness and the floor, not statistical claims.
- The world is live and shared: other (human) players acted during
  the run window. Oracle extracts are scoped to the runs' wallets.
- Wallet addresses appearing throughout are public by design; the
  wallets were temporary, swept, and retired at experiment close.
- gemini's purchased Kami #891 could not be verified against the
  oracle's static table at close-out (coverage gap, noted in its
  oracle README).

## License and citation

CC-BY-4.0. Citation entry TBD — see
[kamibench.ai](https://kamibench.ai) for the current reference.