ETHGlobal Mumbai 2026 · architecture plan v4.6 · Fri 6 Nov 23:25 IST · status board below · comment with 💬 (blocks, diagram nodes, selected text)

Where we are (Fri 6 Nov 23:25 IST)

Don't give a robot your wallet.
Give it a budget.

Vitaquack. A passkey wallet on Arc grants a budget to a robot's chip. One Robot Agent per robot asks 0G what to buy, pays our merchant over x402, and asks a human through World Agent Pass when a purchase is over the limit or restricted. The chip always signs. The wallet never needs to know the grantee is a robot. Build order: docs/spec.md.

1 · WALLET

The foundation

Passkey account on Arc, fund / send / receive with no gas shown, grants to any address, an MCP server whose consent screen creates the grant, Agent Pass approvals.

2 · ROBOT AGENT

The brain

One errand state machine per robot (an Effect service over D1): asks 0G, hands the invoice to the chip over HTTPS long-polling, logs every decision. Runs with no chip too.

3 · MERCHANT

The till

Items, prices, rules (needs approval, restricted). x402 checkout settled by our own facilitator. Later an ESP32 shows the QR and opens a gate.

4 · CHIP

The body and the signer

The Radxa on the duck, or a mock chip in iteration 1. Holds the key the grant is given to and signs every robot payment. Camera and motors on the real one.

The one rule: Arc is the authority. Every limit and every human approval is checked on-chain when a payment lands. Our servers coordinate and relay; they can never authorise, steal or redirect a payment, only delay it.

Battle plan to Saturday 09:00 IST

Deadline: submissions close Sat 7 Nov 09:00 IST, no late entries. On Fri 04:30 no product code exists yet, only the foundation, these docs and spike prototypes. Everything is cut to fit about 28 hours. Details: docs/plan.md §0.
ScopeWhat
MUSTPasskey wallet on Arc mainnet → grant to the chip (real Radxa or mock) → the Robot Agent asks 0G and buys from our x402 merchant through our facilitator → a purchase over the per-payment cap needs Agent Pass (approve and deny), the daily cap is never lifted → revoke stops the next payment → 0G Storage episode log + contract → our enforcer(s) built in Arc Studio → the ESP32 gate opens on a signed "paid"
STRETCHOn-chain Agent Pass check · camera/vision · duck walking · a read-only MCP server
CUTThe float path · outside MCP hosts · funding from other chains · MPP · ENS · IDKit · 4337 break-glass (doc only)
Lane (Kris + agents)BuildsDone when
A · wallet + chainPasskey-only login + wallet pages (consent = grant, approval, revoke, activity); relayer = our facilitator; enforcer in Arc Studio → Arc mainnetA grant from a real phone passkey; one relayed $0.01 payment
B · brainRobot Agent (Effect service + D1: errands, 0G decide, chip sign requests); evidence → 0G Storage + EpisodeLog contract; Agent Pass request + backend check + co-signature0G decides with a stored request id; Agent Pass approve and deny both work
C · chip + merchantChip protocol, mock chip, Radxa runtime (Bun + viem, Python fallback); merchant (store, x402, invoices, signed status for the ESP32)Mock chip and Radxa sign; merchant settles; ESP32 shows PAID
TeammatesPhysical robot (duck build, Radxa OS, ESP32 wiring + servo, camera QR read) and booth questionsThe Radxa and ESP32 run on the duckbench hotspot
By (IST)Checkpoint
Fri 08:00Prerequisites done: ~$20 USDC on Arc + relayer key, a keyed Arc RPC, the 0G key, 0G Chain gas for Storage, World IdP client, Arc Studio project, a product name. Spikes S1 (real-phone passkey), S3 (0G), S5 (Agent Pass returns our nonce)
Fri 14:00First end-to-end headless purchase on Arc mainnet ($0.10, mock chip, our merchant, our facilitator)
Fri 20:00Full MUST loop: Agent Pass approve/deny, revoke, 0G Storage log, the Radxa signing, the ESP32 gate opening
Sat 02:00Stretch stops; README, architecture diagram, Arc Studio walkthrough
Sat 06:00Feature freeze: video (2:30–2:59, fits both ETHGlobal's 2–4 min and 0G's under 3 min), World debrief, contract addresses
Sat 09:00Submitted (aim for 08:00)
Demo (4 min)Beat
0:00Don't give a robot your wallet, give it a budget
0:20Owner's passkey grants Vitaquack's chip $10/day on the consent screen
0:50"Buy me a chai": 0G decides (request id) → the chip signs → paid on Arc → the gate opens
1:50Thali 2.00, over the 1.00 per-payment cap → Agent Pass in World App → approve: paid → again → deny: nothing paid → a third thali would pass the 3.00 daily cap: walks away
2:50Revoke → the next attempt fails on-chain
3:20Architecture, our enforcer in Arc Studio, the episode log on 0G Storage
Must not forgetWhy
README section on code that predates the event (the foundation boilerplate from the public styld.app repo, one commit on 5 Nov); product code in small commitsETHGlobal: "from scratch", and "large single commits … may be disqualified"
Video: 2–4 min, ≥ 720p, real narration, no AI voice, not sped up, not filmed on a phone, ≤ 4 bullets per slideOtherwise rejected on upload
Each of the 3 partner prizes needs "how we integrated it" + feedback; World needs a debrief (time to first success, friction, one improvement)The only way partners assess the project
0G: contract deployment addresses + episode log on 0G Storage with a request id per decisionRequired for Physical AI
Arc: shareable Studio URL, Studio shown in the demo, architecture diagramRequired for every Arc track
Gaps found in this reviewFix
The float path would bypass the merchant allowlist (pull to the chip, pay anyone)Dropped entirely; later fix = a policy-bound escrow
How does Arc know an item is restricted?Approval needed when over the per-payment cap or the payee isn't allowlisted; restricted items use a merchant payTo that's never allowlisted
Two ways to submit a payment (wallet MCP vs x402)One route: the Robot Agent posts the chip-signed voucher to the merchant; no MCP in the money flow; the chip builds the leaf itself
x402 header is ≈ 12 KBTest against the Worker; trim caveats; fallback: relay directly
No map of the appsOne web app: wallet (owner) + robot console (camera, control, decisions) + merchant (store, checkout); the ESP32 is the gate

System map

flowchart TB
  subgraph U["👤 Owner"]
    PH["Phone / laptop<br/>passkey · World App"]
  end
  subgraph W["1 · Wallet (Cloudflare)"]
    WAPP["Wallet app<br/>signup · fund · grants · approvals"]
    WMCP["Grant consent page<br/>the passkey signs the grant"]
    FAC[("Our x402 facilitator / relayer<br/>grant payments · owner actions")]
  end
  subgraph RA["2 · Robot Agent (Effect service + D1, one per robot)"]
    AG["Errand state machine<br/>0G decide · chip sign requests · evidence"]
  end
  subgraph C["4 · Chip"]
    CHIP["Radxa or mock chip<br/>key · signs · camera · motors"]
  end
  subgraph M["3 · Merchant"]
    STORE["Store<br/>items · prices · rules"]
    X402["x402 checkout<br/>grant path, our facilitator"]
    GATE["ESP32 gate (iter 2)<br/>QR · servo"]
  end
  subgraph ARC["Arc mainnet"]
    ACC["Owner account<br/>HybridDeleGator (passkey)"]
    DM["DelegationManager<br/>+ our enforcers (Arc Studio)"]
    USDC["USDC"]
  end
  OG[["0G inference<br/>standard providers"]]
  WORLD[["World IdP<br/>Agent Pass (OIDC)"]]

  PH --> WAPP
  WAPP --> WMCP
  WAPP <--> WORLD
  AG -- "in-process services" --> WAPP
  AG -- "decide" --> OG
  AG <-- "HTTPS long-poll (chip dials out)" --> CHIP
  AG -- "x402" --> X402
  CHIP -- "scan (iter 2)" --> GATE
  STORE --> X402
  X402 -- "grant path" --> FAC
  WAPP --> FAC
  FAC -- "redeemDelegations" --> DM
  DM -- "checks every cap" --> ACC
  ACC --> USDC
  

Grants: one mechanism, the chip is the grantee

A grant is a signed delegation from the owner's account to an address. Here that address is the robot's chip, so the chip signs every payment. The Robot Agent decides; it never holds a spending key.

flowchart TB
  O["👤 Owner account (passkey)<br/>$42.10 USDC on Arc"]
  G1["Grant → Vitaquack's chip (0xChip…)<br/>$10/day · max $2 each · allowlisted merchants · USDC only<br/>over $2 or payee not allowlisted (restricted): needs Agent Pass approval"]
  G2["Grant → claude.ai (after the event)<br/>$2/day · key held by the wallet"]
  V1["Voucher signed by the chip<br/>pay Chai Stand $1.50 · invoice 7f3a"]
  V2["Voucher signed by the chip<br/>pay Samosa Stand $0.25 · invoice 91c2"]
  RL["Our facilitator<br/>redeemDelegations(voucher → grant)"]
  CHK{"Arc checks:<br/>caps · expiry · USDC only · invoice unused<br/>· approval co-signature"}
  O --> G1
  O --> G2
  G1 --> V1 --> RL
  G1 --> V2 --> RL
  RL --> CHK
  CHK -- "all pass" --> PAY["USDC moves"]
  CHK -- "any fails" --> REV["revert: nothing paid"]
  

One way to pay, and why there is no float path

Every robot payment is a chip-signed voucher settled by our facilitator through the DelegationManager, so Arc checks the payee, amount, invoice, caps and revocation at the moment the money moves.

flowchart LR
  a1["Chip signs a voucher<br/>pay merchant · exact amount · invoice"] --> a2["Our facilitator<br/>verify · simulate · redeemDelegations"] --> a3["Arc checks every cap<br/>at payment time"] --> a4["Owner → merchant"]
  
Grant path (the only path)
Settled byOur facilitator (ported from the S2 spike; no open-source one exists for this scheme)
LimitsDaily cap, per-payment cap, payee allowlist, invoice replay guard, expiry, revocation, approval requirement: all on Arc
Measured cost≈ 505–663k gas ≈ $0.010–0.013 per settle (simulated)
Why no float pathReviewers showed that after a pull to the chip's own address, Arc no longer binds the payee, the invoice or revocation on the second transfer, which breaks the one rule above. Dropped for the event; the later fix is a policy-bound escrow contract, not a chip float

Iterations

flowchart LR
  I0["0 · Wallet<br/>passkey · fund · send/receive<br/>grants · MCP · Agent Pass"]
  I1["1 · Headless<br/>Robot Agent + mock chip per teammate<br/>merchant · our facilitator"]
  I15["1.5 · Virtual resource<br/>no simulator: the chip buys<br/>an x402 API through the full flow"]
  I2["2 · Hardware<br/>Radxa chip · ESP32 gate<br/>scan · sign · gate opens"]
  I0 --> I1 --> I15 --> I2
  
IterationDone when
0 · WalletSign up with only a passkey, receive $1, send $0.10, connect a client with a $2/day grant, revoke it, on Arc mainnet with no gas shown
1 · HeadlessFully virtual. Every teammate runs a mock chip (a Bun script with its own key, same long-polling protocol as the Radxa); the real Radxa pairs over the internet with the same code. The agent (0G) buys a normal item (grant path), a restricted or over-limit item (Agent Pass approve → paid, deny → nothing); revoke stops all; every 0G decision logged
1.5 · Virtual resourceNo simulator: the chip buys a virtual resource, an x402 API (data, an image, a song), through the whole flow, with no physical QR
2 · HardwareThe duck scans the ESP32 QR, the Radxa signs, the gate opens on a signed "paid"

Flows

A · Sign up and fund
sequenceDiagram
  autonumber
  participant P as Owner (passkey)
  participant W as Wallet backend
  participant A as Arc
  participant C as Circle CCTP / Gateway
  P->>P: create passkey (Face ID)
  P->>W: public key
  W->>A: relayer deploys HybridDeleGator via SimpleFactory (~$0.005, we pay)
  A-->>P: account address (same forever)
  alt USDC already on Arc
    P->>A: send to the address from any wallet
  else USDC on another chain
    P->>C: deposit / burn from MetaMask on Base, Ethereum, …
    C->>A: mint to the account on Arc (Circle submits, no gas for the owner)
  end
      
B · Pair the chip, grant the budget (consent = grant to the chip)
sequenceDiagram
  autonumber
  participant P as Owner (passkey)
  participant WA as Wallet
  participant RA as Robot Agent DO
  participant CH as Chip (real or virtual)
  P->>WA: add robot "Vitaquack" → pairing code
  CH->>CH: generate key (never leaves the chip)
  CH->>RA: POST /api/chips/pair (code + signed challenge)
  RA-->>CH: challenge
  CH->>RA: signature → RA now knows the chip address
  RA->>WA: in-process: request a grant for the chip
  WA-->>P: consent: "Vitaquack (0xChip…) wants $10/day until Sunday"
  P->>P: passkey signs the grant (delegate = chip address, no transaction)
  WA-->>RA: grant active (stored delegation · the chip polls for sign requests)
      
C · Headless purchase, grant path (iteration 1, mock chip)
sequenceDiagram
  autonumber
  participant RA as Robot Agent
  participant OG as 0G
  participant M as Merchant (x402)
  participant CH as Chip
  participant F as Our facilitator
  participant A as Arc
  RA->>OG: "buy chai" → plan (request_id logged)
  RA->>M: GET /items/chai
  M-->>RA: 402: $1.50 · exact / ERC-7710 · invoice 7f3a
  RA->>CH: sign voucher: pay Chai Stand $1.50, invoice 7f3a
  CH->>CH: check invoice and amount, sign
  CH-->>RA: signed voucher
  RA->>M: POST /api/invoices/7f3a/pay (the voucher)
  M->>F: verify + settle
  F->>A: redeemDelegations(voucher → grant)
  A-->>F: caps OK → paid (final in under a second)
  M-->>RA: 200 + receipt
      
D · Over the limit or restricted: Agent Pass (approve and deny); our backend verifies the token and co-signs
sequenceDiagram
  autonumber
  participant RA as Robot Agent
  participant WA as Wallet
  participant P as Owner phone (World App)
  participant WO as World IdP
  participant CH as Chip
  participant A as Arc (RobotPaymentPolicyEnforcer)
  RA->>WA: approval_request($8 chai, invoice 7f3a)
  WA->>WA: nonce = EIP-712 hash {invoice 7f3a, $8, Chai Stand, expiry}
  WA-->>P: our page shows "Vitaquack wants $8 for chai" + Approve with World
  P->>WO: browser sign-in (nonce, max_age=0) → confirm in World App
  alt approved
    WO-->>WA: RS256-signed ID token (nonce echoed, fresh auth_time)
    WA->>WA: verify the token (iss, aud, nonce, auth_time, amr has pop and not mfa, jti once) · co-sign the EIP-712 approval
    WA-->>RA: approval signature
    RA->>CH: sign voucher for invoice 7f3a
    RA->>A: voucher + approval in the enforcer args
    A->>A: approval signer, payee, amount, expiry, nonce unused
    A-->>RA: paid
  else denied / cancelled / expired
    WO-->>WA: no token
    WA-->>RA: denied: nothing co-signed, nothing paid
  end
      
E · The robot buys at the ESP32 gate (iteration 2)
sequenceDiagram
  autonumber
  participant B as Browser (owner)
  participant RA as Robot Agent
  participant CH as Chip (Radxa)
  participant G as ESP32 gate
  participant M as Merchant
  participant A as Arc
  B->>RA: watch camera, take over any time
  RA->>CH: approach the QR (deadman 300 ms)
  G->>M: POST /invoices → QR on screen
  CH->>CH: scan QR, fetch invoice
  RA->>RA: 0G: "is this the chai? price sane?" → pay (request_id logged)
  CH->>CH: sign voucher for the invoice it scanned itself
  RA->>M: pay (x402)
  M->>A: settle → paid
  G->>M: poll status
  M-->>G: Ed25519-signed "paid" + gate nonce
  G->>G: open 🔓 → status "used"
      
F · Revoke and safe-stop
sequenceDiagram
  participant P as Owner
  participant W as Wallet
  participant A as Arc
  participant RA as Robot Agent
  P->>W: revoke Vitaquack's grant
  W->>W: step 1: stop serving it (instant)
  P->>A: step 2: passkey-signed disableDelegation, relayed → grant dead on-chain
  P->>RA: e-stop → robot stops moving and the chip stops signing
  Note over RA: also automatic: 0G down → no new decisions → the robot stops
      

Robot Agent

One errand state machine per robot (an Effect service over D1) is the AI client. 0G never moves the duck: walking runs on the chip, offline, 50 times a second. The agent runs fine with no chip attached; no camera frames leave the chip.

flowchart LR
  subgraph CF["☁️ Cloudflare"]
    RA["Robot Agent<br/>errand state machine · 0G decide<br/>evidence · lease watchdog"]
  end
  subgraph Chip["🦆 Chip: Radxa (or virtual)"]
    direction TB
    KEY["Key + signer<br/>checks invoice, signs"]
    NAV["Navigation 5–10×/s<br/>QR in frame → turn / walk / stop"]
    POL["Walking policy 50×/s<br/>ONNX → 15 servos"]
    NAV --> POL
  end
  BR["Browser<br/>robot console: errands, decisions, lease"]
  OG[["0G"]]
  WM[["Wallet services (in-process)"]]
  RA <-- "HTTPS long-poll: sign requests + lease; signed frames as evidence" --> Chip
  BR -- "start errand · watch" --> RA
  RA --> OG
  RA --> WM
  

Built in the foundation's own stack (Effect services, D1, Foldkit), not as a Durable Object or a copy of Goblin's Agents SDK agent: those don't compose with Effect/Alchemy and added hours without adding security. Camera, teleoperation and walking are the teammates' hardware track and stretch work.

Agent Pass vs the grant

The grantAgent Pass
WhatThe standing budget: "$10/day until Sunday"A one-off exception for one purchase
Who approves, whereOwner's passkey, in our walletOwner in World App (World IdP)
WhenIn the wallet, when adding a robot; again to raise the budgetOver the per-payment cap, or a restricted item
On-chain effectA new signed delegationFor the event: our backend checks World's token and co-signs that one payment; HumanApprovalEnforcer checks the co-signature. Stretch: the enforcer verifies World's token itself
Blockchain involvedArcNone in World's part: plain OIDC (RS256 ID token), so it fits Arc cleanly

World: Agent Pass

PieceHow
FlowWorld IdP's browser flow (not the device flow, which can't carry a nonce): our wallet page asks World to sign in with nonce = the EIP-712 hash of {invoice, amount, payee, expiry} and max_age=0; the owner confirms in World App; World returns an RS256-signed ID token. Deny, cancel or expiry = no token = no payment
BindingWorld App can't show what is being approved, so our wallet page shows item, amount, payee and invoice, and the approval is single-use for that invoice
Token checksAccept acr orb or orb-face; reject passkey-only sign-ins (amr with mfa); auth_time after the request; jti used once. World's reference code gets two of these wrong
On ArcDecided (D15): backend co-signer first. Our backend runs the same checks on World's token (iss, aud, exp, sub = owner, nonce = this payment, fresh auth_time, amr has pop and not mfa, jti once) and co-signs EIP-712; HumanApprovalEnforcer checks the co-signature. Stretch: the enforcer verifies the token itself (S5b prototype, ≈ $0.008), which removes the trusted backend but makes approvals linkable on-chain
Not usedIDKit 18+ registry (dropped) · AgentKit (archived) · World's wallet as our wallet: "World Money" is a Safe on World Chain only; World's SDK refuses other chains, a Safe can't be a Delegation Framework delegator, and allowances reset after each transaction. At most a World mini app could fund our Arc account

Owner actions and trust

QuestionAnswer
How does the owner send / revoke?The passkey signs a one-time delegation; our relayer (the same code as the facilitator) submits it, ≈ $0.006. This is the pattern MetaMask's own facilitator uses
Break-glassIf the DelegationManager is ever paused: an ERC-4337 user operation via Pimlico's public bundler, gas paid by the account in USDC
Other chains (gas not in USDC)ERC-4337 with a USDC paymaster (as Goblin's wallet did on Base)
Can the relayer steal?No. Signatures fix the exact action and Arc checks every cap; a relayer or bundler can only delay. Hence the fallback
Passkey-native: still a "DeleGator"?Yes. DeleGator is MetaMask's name for their delegation-capable smart accounts. Ours is a HybridDeleGator (own contract, passkey signer); the 7702 fallback points an EOA at EIP7702StatelessDeleGator. Same grants either way

0G and Arc: data, not money

The user's money stays USDC on Arc. 0G is a platform cost (credits from the team, standard providers). The two link through provenance.

flowchart LR
  F["Camera frame<br/>+ invoice"] --> D["0G decision<br/>request_id · model"]
  D -- "pay" --> P["USDC payment on Arc<br/>tx hash · invoice id"]
  D --> S["0G Storage<br/>decision record incl. Arc tx hash"]
  S --> E["EpisodeLog on 0G Chain<br/>episode hash"]
  P -. "ledger: invoice → request_id" .-> D
  

Venue network

SetupHow
Primary: dedicated phone hotspotPixel hotspot duckbench, 2.4 GHz, WPA2, on the phone's own mobile data. Radxa, ESP32 and laptops all join it. Bench H4 found the venue Wi-Fi unusable (≈ 3 KB/s, pings up to 2.5 s)
AlternativemacOS Internet Sharing from a wired Ethernet uplink: channel 1/6/11, WPA2/WPA3 (never WPA3-only), Radxa key-mgmt wpa-psk, ESP32 setMinSecurity(WPA2_PSK), caffeinate -dis
Doesn't workMac → Android reverse tether over USB, then the phone's hotspot: on stock Android, hotspot clients bypass the tether's VPN

ESP32 gate wiring

Servo wireConnect to
Signal (orange / yellow)A GPIO, e.g. GPIO 13 (3.3 V logic is fine). Code: ESP32Servo attach(13, 500, 2400)
Power (red)A separate 5 V supply, at least 1 A (power bank or adapter). Not the ESP32's 3.3 V pin; the ESP32's VIN over the Mac's USB can brown-out reset it
Ground (brown)The supply's ground and the ESP32's GND (shared ground)
ExtraA 470 µF capacitor across the servo's 5 V / GND. No driver chip needed for one micro servo (SG90 / MG90S); a PCA9685 board only for many servos

Bench results so far

SpikeResult
C1: the chip signs the plan-v3 voucherPass, 20 / 20 checks. Hashes and caveats match MetaMask's kit; on live Arc the voucher pays the merchant, a different amount or payee fails, a replay fails
H1: Radxa healthPartial. OS and camera known, ≤ 57 °C in a short capture. The overheating was the camera ribbon: fixed by reseating it striped face up
H3: signing speedPython signing works but takes 187 ms (pure-Python recovery); Bun + viem or libsecp256k1 needed. Bun not yet tested
H4: networkVenue Wi-Fi unusable, so a dedicated phone hotspot
H2, H6Not yet run: reading the ESP32 QR with the camera, the signed bench loop (H5, frames to the cloud, is out of scope)

Spike results and the World Chain question (6 Nov)

WhatResult
S2: our facilitator (grant path)Pass, 14 / 14 on live Arc mainnet state (simulated with eth_call, nothing broadcast). Wrong amount, wrong payee, replayed invoice, expired, over the cap, revoked grant, wrong relayer, tampered signature: all rejected with the right reason. Cost ≈ $0.013 per payment, about double our earlier guess. Note: a plain anvil fork can't move Arc USDC (Arc's native-coin precompile is missing), so fork tests simulate against live state
S5b: World's token checked on ArcWorks: RSA check + claim parsing + one-use nonce and jti, ≈ $0.008. Two findings: (1) a passkey-only World sign-in also says pop, so the check must reject mfa; (2) the token becomes public on Arc, including the owner's World pseudonym and an email-like claim, so your approvals are linkable (decision D15)
World Chain + 0G + ENS instead of ArcNot worth it. No World Chain prize exists; MetaMask's delegation contracts aren't on World Chain (≈ 45 contracts to deploy, all tests to redo); Circle's facilitator doesn't support it; gas is cheaper but in ETH; World's wallet still can't grant a robot allowance
ENSWorks on top of Arc: robots and merchants as subnames holding their Arc address and agent records (≈ 0.5–1 day, ≈ 8 USDC/year). But ETHGlobal caps a project at 3 partner prizes, so ENS ($7k, 4 places, ENSv2) would replace Arc ($3k, one winner) as the third pick (decision D16)
0G requirementThe Physical AI prize needs an episode log on 0G Storage plus a contract address: a build item, not optional

What we know, what we believe, what we don't

Known (with the evidence level)

Uncertain: one spike settles it

#Spike
S1Done (virtual authenticator): passkey → HybridDeleGator deployed by the relayer → passkey-signed grant accepted on Arc mainnet. Left: a real phone, and the $0.01 payment under that grant (needs 0G)
S2Done (broadcast): $0.01 settled on Arc mainnet through our facilitator, replay and post-revoke refused; the x402 envelope verified on the deployed merchant
S2bDropped: the float path (authority gap after the pull)
S3Open, blocked on the 0G key: packages/server/scripts/zg-probe.ts runs the exact decide call and reports model, latency and request id
S4Dropped: MCP is off the critical path; the agent calls wallet services in-process
S5Agent Pass browser flow with nonce (approve and deny) using Kris's Orb-verified ID: does the token echo the nonce, and which acr / amr values come back
S5bDone (prototype): a contract verifies World's RS256 token on Arc, 43 tests, also run on live Arc; ≈ 409k gas ≈ $0.008. Left: a real World token with our nonce (S5, Kris's phone), key rotation
S6Done (deployed): mock chip pairs and long-polls through the deployed edge (24.8 s holds, 35 s lease). Left: the Radxa running the same client (apps/chip/README.md, docs/hardware-handoff.md)
S7The duckbench hotspot with the Radxa, ESP32 and laptops; then H2, H5, H6 on it
S8Walking policy on the new servos (teammate)

Unknown: booth questions

Decisions

DecidedChoice
Owner accountPasskey-native HybridDeleGator; 7702 fallback
Robot brainOne errand state machine per robot, an Effect service over D1; no Durable Objects, WebSockets or MCP
Who signsThe chip, always; a mock chip in iteration 1
Paymentsx402, grant path only via our facilitator; float path dropped (authority gap)
LoginPasskey only: the passkey is the login and the wallet signer
NameVitaquack
Owner actionsOur relayer; ERC-4337 break-glass
0GStandard providers
WorldAgent Pass only, the approval verified on Arc (browser flow, nonce = invoice hash); World's wallet can't replace ours
IterationsMock chip per teammate; no simulator (1.5 = a virtual x402 resource)
Arc trackAdvanced Stablecoin Logic: RobotPaymentPolicyEnforcer + HumanApprovalEnforcer built in Arc Studio
NetworkDedicated phone hotspot (venue Wi-Fi unusable); Mac Internet Sharing from wired Ethernet as the alternative
Radxa OS, walking policyTeammate
Still openRecommendation
Who pays relayer gasWe absorb it (≈ $0.013 per payment measured in S2; ≈ $0.006 per owner action)
RecoverySeveral passkeys now; guardians later
Accounts on other chainsArc-only; other chains are funding routes
Who may watch / drive the robotOwner drives; judges view
D15 (decided): the World token checkBackend co-signer for the event; on-chain verification as a stretch, with the privacy note in the pitch
D16: third prize pickDecided: Arc + 0G + World (max $3k + $2.5k + $2.5k = $8k). ENS names only as an optional add-on; picks finalised at submission