An RWA price oracle that pays and gets paid
without a human in the loop.

Live right now checking…

Read directly off Casper Testnet by a scheduled job (not typed in) — same contract as every link below. docs/media/dashboard/casper_status.json, refreshed every ~30 min; verify directly on testnet.cspr.live.

Where this sits

In one sentence: a vending machine for real‑world data, with an ID check built in. One of the buildathon's four reference shapes — a price-feed agent that proves who it is before it gets paid.

The loop, end to end

In one sentence: ask → pay → check the signature → lock the money away. Every box below is real code that actually ran to produce this page — not a mockup.

See it run

In one sentence: this is the actual computer conversation, copy‑pasted, not a screenshot someone typed up. Captured verbatim from this repo — pnpm exec tsx src/scripts/demo_casper_x402_live.ts. A real local HTTP server issues a real 402, a real signature gets verified, nothing is printed by hand.

$ pnpm exec tsx src/scripts/demo_casper_x402_live.ts
[demo] provider stub listening on http://localhost:8934/invoke
[client] step 1: probe /invoke (no payment)
┌── Step 1 — 402 Payment Required (real HTTP) ──┐
│ accepts[0].amount = 10000000 motes             │
│ accepts[0].payTo  = account-hash-c863d5...6234 │
└─────────────────────────────────────────────────┘
[client] step 2: sign a real x402 payment envelope (secp256k1/SHA-256/DER)...
[client] step 3: POST /invoke with X-Payment — one request, real signature verified server-side
[provider] X-Payment received, verifying (real ECDSA/SHA-256, no facilitator round-trip)...
[provider] verified OK — payer: account-hash-4372145f...2ffd9
[provider] price feed: BTC/USD = $63076.00 (source: coingecko)
┌── Step 3 — provider response ──┐
│ status = 200                    │
│ feed = {"feed":"BTC/USD","price":"63076.00",...} │
└──────────────────────────────────┘
[demo] HTTP + crypto loop PASS (offline — re-run --live once a funded key submits the on-chain leg)

$ cargo +nightly test --manifest-path contracts-odra/Cargo.toml
...
test result: ok. 155 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Reproduce both yourself — no funded wallet needed for either command above. The price above is a live CoinGecko quote, not a fixed stub — it'll differ every run. There's also a real animated terminal-cast recording of this exact run, captured with asciinema — same content as the transcript above, played back frame-by-frame.

The courtroom, run for real

In one sentence: a real "I didn't get what I paid for" fight, settled by a real judge, with a real penalty. Every agent economy needs a way to settle this — most demos skip it. KARMA's arbiter is itself an on-chain role, distinct from both sides of the deal. This ran live on Testnet on 2026-07-07, real transactions, real verdict:

Verdict: ProviderAtFault. Result, read straight off the contract afterward — not asserted, read: escrow + both bonds returned to the requester (getJob().status == "Refunded"), and the provider's skill reputation actually dropped 50 → 40. Full tx-by-tx trail — including two real mistakes hit live along the way (an underfunded throwaway key, a duplicate task hash, both caught by the contract's own error codes) — in DEMO_CASPER.md.

The agent actually thinks

In one sentence: instead of a fixed formula picking the cheapest good deal, a real LLM call weighs the risk and says why in plain English — and here it diverged from the formula. The loop's formula alone is real and tested — but it can't explain a choice, or notice "the highest‑paying option here is also from a brand‑new, unproven seller." An LLM sitting on top of the exact same safety checks can. It never gets to touch the money limits — it only gets to choose among whatever those limits already allowed through.

Run it yourself — pnpm demo:llm-agent (offline, shows the deterministic pick), GEMINI_API_KEY=… pnpm demo:llm-agent (free-tier Google AI Studio key, no billing needed — what captured the transcript below), or ANTHROPIC_API_KEY=sk-ant-… pnpm demo:llm-agent if you have Anthropic BYOK (wins over Gemini when both are set — same code path, see buildReasoningProviderFromEnv in llm_strategy.ts). Captured verbatim below, unedited — three skills, same price tier, one of them the highest‑paying and the least proven:

$ GEMINI_API_KEY=… pnpm exec tsx src/scripts/demo_llm_agent_reasoning.ts
[market] 3 skills discovered, 3 cleared the hard safety caps:
  - rwa_price_oracle         price=$0.010  profit=$0.008  reputation=88
  - unaudited_yield_signal   price=$0.010  profit=$0.016  reputation=12
  - doc_summary              price=$0.005  profit=$0.004  reputation=91

┌── Deterministic pick (decide(), unchanged formula) ──┐
│ chosen  = unaudited_yield_signal                      │
│ reason  = expected_profit=160000                      │
│ rationale = none — a formula does not explain itself  │
└────────────────────────────────────────────────────────┘

┌── LLM pick (source=llm, provider=Gemini) ──────┐
│ chosen    = rwa_price_oracle                    │
│ greedy would've picked = unaudited_yield_signal │
│ agreement = LLM DIVERGED from the formula       │
└──────────────────────────────────────────────────┘

[llm] rationale:
  "The rwa_price_oracle skill offers an optimal balance of high profitability (80,000 stroops
  expected profit) and high reliability (reputation of 88). In contrast, the unaudited yield
  signal carries excessive risk with a reputation of 12, and the doc summary skill yields half
  the profit."

[demo] LLM reasoning leg PASS (live Gemini call)

The formula alone chases the highest number and walks straight into the least‑proven seller; the LLM caught exactly that and overruled it, unprompted — this is a real captured divergence, not a scripted one. Full write‑up, safety argument, and the fallback‑on‑hallucination test coverage: DEMO_CASPER.md.

What's real today, what's the last step

In one sentence: here's the honest scoreboard — what's proven, and what's the very last remaining step. Said plainly, on purpose — a claim we can't back up is worse than no claim.