Mimir Markets on Arc

Mimir is an AI-settled claim market on Arc — Circle's stablecoin-native L1. Two parties stake USDC on opposite sides of a verifiable question; when the deadline passes, an off-chain AI oracle reads the agreed-upon evidence source, returns a verdict, and the smart contract pays out the winning side atomically. No committees, no manual disputes.

What Mimir is

A claim in Mimir is a single, verifiable question with a deadline and a designated resolution source — for example, “Will BTC close above $100,000 on 2026-05-25 according to CoinGecko?”

Anyone creates a claim by staking USDC on one side. Another party (or an autonomous agent) challenges by staking the other side. At the deadline the oracle fetches the evidence URL, asks an LLM to evaluate the outcome against the settlement rule, and submits the verdict on chain. The contract pays out the winning side in the same transaction.

What ships on chain: the question, both positions, the resolution URL, both stakes, the verdict, the confidence number, and the keccak256 hash of the raw evidence the oracle actually saw. The hash means anyone can re-fetch the URL, hash it themselves, and verify the oracle isn't lying about its input.

Why USDC on Arc

Arc is Circle's EVM L1 with USDC as the native gas token. That property changes the economics of a stake-and-settle market enough to be worth calling out:

No ERC-20 approval dance

Stakes use msg.value. One signature opens or accepts a claim — no separate approve() tx, no allowance to manage.

Predictable, sub-cent fees

Gas is denominated in USDC, not a volatile native token. A settlement tx costs roughly $0.01 regardless of network congestion.

Sub-second deterministic finality

The oracle can settle and pay out inside a single user-visible moment, instead of leaving funds in limbo through a long confirmation window.

Stablecoin-native semantics

Treasury operations — agent funding, payouts, balance reads — all happen in the same unit users see in the UI.

Architecture

Three independent tiers, each running where it fits best:

Top to bottom: user wallets → Next.js frontend (Vercel) and worker agents (Railway) → Arc contract + ancillary services (Neon read-index, LLM layer, the Circle stack).

Frontend (Vercel). Next.js App Router with serverless API routes. Reads come straight from Arc RPC; writes are user-signed via wagmi/viem.
Workers (Railway). Three long-lived Node processes: the oracle (settler), the market-creator, and the ten-persona Mimir Council. Vercel functions time out before a polling cycle can finish — Railway is the right home.
Data (Neon Postgres).A denormalised read-index of on-chain state for the explorer / dashboard feeds. Optional — the contract remains source of truth, and pages that don't need feeds (bridge, stats, claim detail) work without it.

End-to-end flow

A market is intentionally small: one question, one source, one deadline, and two funded sides. The complexity lives around that primitive: evidence collection, LLM interpretation, optional council voting, and final payout.

The full market path from question drafting to payout. The chain stores the funded state; workers handle reading, interpretation, council coordination, and the final transaction.

What users control

Users choose whether to create, challenge, or inspect a market. Their wallet signs stake-bearing transactions directly against the Arc contract; the app never holds custody of user funds.

What agents control

Agents draft markets, challenge open claims, buy paid evidence or persona verdicts, and settle expired active claims. Every write still lands on chain through a Circle-managed wallet.

The claim lifecycle

Six discrete steps from open to settled. Steps 04–06 are entirely automated by the oracle agent.

A few details matter for trust:

Evidence hash on chain. keccak256(raw evidence) lands in contract storage. Anyone can re-fetch the URL, hash it, and verify what the oracle actually saw.
Confidence is first-class. The LLM returns a 0–100 number that ships with the verdict. The product surfaces it as confident vs. contested.
Refund the ambiguous. DRAW and UNRESOLVABLE are real verdicts that return stakes. Better inconclusive and refunded than wrong and paid out.
Oracle-only resolution. resolveClaim is gated by a single address — a Circle-managed wallet held by the agent. No human can quietly re-route payouts.

The agents

Twelve background processes run continuously: the oracle, the market-creator, and ten council personas. None of them holds a local private key — every agent signs through Circle's Programmable Wallets.

Oracle decision tree. The poll loop reads every claim once a minute; ACTIVE+expired claims go to the settler, OPEN+live claims go to the optional Kelly-sized challenger. The council follows the same shape, one persona at a time.

Oracle agent

Reads expired ACTIVE claims, fetches the evidence URL, asks the LLM for a verdict + confidence + one-sentence explanation, and submits resolveClaim on chain. With AUTO_CHALLENGE=1 it also stakes the contrarian side on OPEN claims it's highly confident about, sized by the Kelly criterion and capped at 25% of its bankroll.

Market-creator agent

Polls trusted public sources (CoinGecko, ESPN, OpenWeather) every six hours, asks the LLM to draft 1–5 verifiable claim candidates, scores each for quality, and creates the highest-scoring ones on chain with its own creator-side stake. Opening a claim is an economic commitment, not a free tweet.

The Mimir Council (×10)

Ten AI personas — optimist, pessimist, contrarian, statistician, whale-watcher, crypto maxi, sports pundit, weatherman, doomer, yapper — each with its own W3S wallet and its own way of reading a market. Two are pure rule-based (no LLM); three are category specialists; the rest run the oracle's evaluation prompt with a personality prefix. They only call challengeClaim; settlement stays with the oracle. See /council for the full roster.

The Circle stack

Mimir uses Circle's developer platform end-to-end. Each piece earns its keep:

USDC (native)

Arc's gas token. Stakes use msg.value, settlement pays USDC directly, no wrapper contracts.

W3S Programmable Wallets

The oracle and market-creator addresses are Circle-managed. Every contract execution goes through executeContract(...) — no private key ever sits in a worker process.

CCTP V2 (Fast Transfer)

The bridge page burns USDC on Base / Ethereum / Avalanche Sepolia, polls Iris for an attestation, and lets the user mint native USDC on Arc. End-to-end in ~15 seconds.

Gateway

A server-side proxy hits POST /v1/balances to return a wallet's USDC balance across every CCTP V2 domain in one round-trip, rendered as the “unified balance” widget.

CCTP V2 bridge flow. The mint on Arc is permissionless — the user submits it themselves once Iris returns the signed message.

Nanopayments and council

After the Arc / Agora hackathon, Mimir grew an economic layer of its own. Agents stopped being purely operational and became market participants — they pay each other sub-cent amounts for data and verdicts, sell their own outputs, and every settled cent is recorded and shown live. This is the “Lepton” era: nanopayments over HTTP 402, settled on Arc through Circle Gateway, signed entirely through W3S.

Agents as paying + selling economic actors (x402)

Agents pay-per-request over the HTTP 402 Payment Required status in sub-cent USDC, settled through Circle Gateway and signed via W3S — there is no local private key anywhere in the loop. Paid endpoints today: GET /api/premium/price ($0.001), POST /api/oracle ($0.005), POST /api/council/preflight ($0.001), and GET /api/council/reasoning($0.001, paid directly to each persona's own wallet). The same agent can sit on both sides — buying a price quote, selling its reasoning.

x402 nanopayment flow. The payer (oracle) signs through W3S with no local key; the paid endpoint quotes a sub-cent price, Circle Gateway acts as facilitator, the transfer settles on Arc, and the receipt is recorded to Neon and shown live at /revenue.

Council as a peer-to-peer reasoning market

The current production loop already has the market-creator buying preflight opinions before opening markets and the oracle buying verdicts/reasoning at settlement. With `COUNCIL_PEER_READS=1`, council personas buy each other's reasoning too: a specialist sells a read, a skeptic buys it, then decides whether to dissent or update. This is budgeted because a full ten-persona mesh can grow from 10 reads to 90 peer reads per market.

Council nanopayment mesh. Creator and oracle buy persona intelligence, while budgeted peer reads let personas purchase each other's reasoning without local keys. Every read is a tiny x402 USDC payment, every receipt lands in the revenue ledger — and after a self-resolving settlement the oracle routes cross-entropy bonuses back into the wallets of jurors who actually moved the market's belief.

Self-resolving jury settlement

At settlement the oracle no longer decides alone — it runs a self-resolving prediction market over the council (adapted from arXiv:2306.04305). Jurors vote sequentially in shuffled order, each buying costs $0.001over x402 straight into that persona's wallet, and each juror sees the prior reports in its prompt. Once a quorum of decisive reports exists, every further vote flips an α-coin — the market may stop, so nobody knows who reports last. The oracle then makes the terminal reference report from its own independently fetched evidence plus the full history: that belief settles the claim and grades the jury. Every report is scored with a cross-entropy market scoring rule against the reference — parroting the prior earns exactly zero, informative updates split a USDC bonus pool paid into juror wallets after settlement. The q-chain and scores are committed inside evidenceHash, so the whole scored market is auditable on-chain.

Self-resolving jury settlement. Jurors report sequentially in shuffled order (each seeing the prior reports), an α-coin bounds the market length, and the oracle's terminal report — built from evidence the jurors cannot touch — both settles the claim and grades every juror with a cross-entropy score. Positive scorers split a USDC bonus pool; below quorum the oracle resolves solo.

Subscription pass

One POST /api/council/subscribe nanopayment ($0.01) returns an HMAC-signed pass that unlocks a time-boxed window of free council reads — the recurring-access tier on top of the per-read x402 model.

Durable revenue ledger

Every settled nanopayment is recorded to Neon (the x402_payments table) and shown live at /revenue. Each receipt links to the paying agent's on-chain account and to the Circle Gateway Wallet settlement contract on ArcScan.

Gateway deposit via W3S

approve + depositinto Circle's Gateway Wallet, signed entirely through W3S — enabling gasless, batched payments with no local private key.

Pull-payment safety (contract v2)

resolveClaim payouts are pushed, but a failed push parks the amount in pendingWithdrawals (claimable via withdraw()) instead of reverting the whole settlement — so one uncooperative recipient can't freeze everyone else's payout.

Multi-category markets

The market-creator now opens claims for crypto (CoinGecko), World Cup soccer and NBA (ESPN), stocks (stockanalysis.com), and weather — not just crypto.

Resilient LLM routing

The worker layer routes model calls behind cooldown-aware retries, so temporary model limits do not stop oracle or council reads.

Contracts

v2 (live). 0x50036154a3bc51f2e7d604a2fbc596f02bb555a1
v1 (legacy, immutable — 181 claims / 104 resolved). 0x8c7016b1124983fb00dc022d88e3de997cdb5873

Contract state machine

Mimir keeps the on-chain state machine deliberately narrow. Claims can be opened, challenged into active markets, resolved by the oracle, or cancelled after expiry if nobody joined the counter-side.

The contract state machine. OPEN claims become ACTIVE when challenged; ACTIVE claims become RESOLVED by oracle transaction; expired unchallenged OPEN claims can be cancelled and refunded.

Smart contract terms

A few terms that show up in the UI and on chain:

Term	What it means
creator	The address that opened the claim and staked side A.
challengerStake	Sum of all side-B stakes (pool mode) or single counter-stake (1v1).
oddsMode	`pool` = pari-mutuel, `fixed` = creator-backed multipliers.
deadline	UTC unix timestamp. After this the oracle can settle.
winnerSide	`CREATOR`, `CHALLENGERS`, `DRAW` (refund), or `UNRESOLVABLE` (refund).
evidenceHash	`keccak256` of the raw bytes the oracle fetched from the resolution URL.
confidence	0–100. The LLM's self-assessed certainty for that verdict.

How to play

Get testnet USDC. faucet.circle.com on Arc Testnet, or use the bridge to pull USDC over from Base/Eth/Avax Sepolia via CCTP V2.
Connect your wallet. The site auto-switches you to Arc Testnet on connect and adds the chain if your wallet doesn't know it.
Either create a claim or challenge one. Browse the explorer for open markets, or open your own with /vs/create. Stake at least 2 USDC.
Wait. At the deadline the oracle does its thing. You don't need to click anything — the contract pays out automatically.
Check the receipt. The settlement card shows the verdict, the explanation, the evidence hash, and the on-chain tx.

FAQ

Do I need MetaMask?

Any injected EVM wallet works (MetaMask, Coinbase Wallet, Rabby, Phantom EVM, etc.) plus WalletConnect. The frontend uses wagmi v3.

What if the LLM is wrong?

The verdict ships with a confidence number, the evidence URL, and a keccak256 hash of the raw page bytes. Anyone can verify the oracle wasn't hallucinating. Truly ambiguous claims resolve as UNRESOLVABLE and refund — the protocol prefers refunding ambiguity to fabricating certainty.

Can the oracle be replaced?

The contract's oracle address is set at deploy and changeable only by the owner. The deploy script transfers ownership to the market-creator W3S wallet immediately after deploy.

Is the agent betting against me?

Only with AUTO_CHALLENGE=1 enabled, and only when its own confidence on the contrarian side is ≥ 80%. Stake size is Kelly-bounded at 25% of bankroll, with an additional 10% hard cap. The contract blocks a wallet from being both creator and challenger of the same claim.

Mainnet?

Arc is testnet-only as of writing. The codebase is chain-config driven (see lib/arc.ts) — a mainnet redeploy is mostly a single chain definition swap.

How Mimir works