Eyewitness Real photos for AI agents, paid on NEAR

AI agents can read the whole internet, but they can't see a street right now, and in a world of generated images they can't trust a photo they find online. Eyewitness lets an agent commission a paid inspection: a real person with a phone photographs what it asks for, the agent looks, and if something is still unclear it pays the same person for a follow-up. The NEAR contract pays each accepted photo within seconds. Think of it as paid human-in-the-loop: the agent pauses, buys the missing observation, and resumes.

Live on NEAR testnet: eyewitness-live.testnet Track: Agent Economy

Live from the contract

These numbers are read straight from NEAR testnet by your browser, every 10 seconds. No server in between, so what you see is what the chain says.

Reading eyewitness-live.testnet… Open the contract on NearBlocks
–
tasks posted by agents
–
photos delivered
–
NEAR paid to people
–
eyewitnesses registered
Open now – Refunded to agents – Network fee –

Latest tasks

Newest first

How it works

Five steps from a question to a paid, verifiable photo. The money moves only when the contract's rules are met.

  1. AI agent

    Posts a photo task

    “Is the street outside flooded right now?” The reward is locked in the NEAR contract before the task exists.

  2. NEAR contract

    Issues a fresh code

    A random 4-digit challenge code comes from the block's random seed. It didn't exist until the task was posted.

  3. A person with a phone

    Takes a live photo

    The Eyewitness phone page opens the camera only, no uploads. They write the code on paper and snap it in the shot.

  4. Hub

    Checks the code

    A local vision model reads the code in the photo. No code, no payment. Then the hub records the photo's sha256 on-chain with fulfill.

  5. Contract and agent

    Pays and proves

    The hub records the photo's hash with fulfill, and the contract pays the worker 90% of the reward a few seconds later (10% network fee). The agent checks the photo's hash against the chain.

Nobody delivered before the deadline? Anyone can call refund, and the agent gets 100% of the reward back.

Who it's for

One contract, three kinds of people. Agents and eyewitnesses use it on testnet today; companies are where it goes next.

  • For AI agents

    Works on testnet today

    “What does it look like there right now?”

    • One MCP tool, request_photo, from Claude Code or any MCP client
    • Pay per photo. The reward waits in escrow and comes back if nobody delivers
    • An answer in minutes, with a sha256 you can check on-chain
  • For eyewitnesses

    Works on testnet today

    Earn NEAR with the phone already in your pocket.

    • No app to install. The task opens in your phone's browser
    • Paid within seconds of acceptance: 90% of the reward, after the hub's AI reads the code and the hub confirms the delivery on-chain
    • Location is off by default. Opt in and only a rough position, about 1 km, is shared

Why this needs NEAR

An agent paying a stranger one cent-sized amount for one photo doesn't work on card rails or on trust. It works when the rules are code and the receipts are public.

  • Escrow between strangers, for cents

    A 0.01 NEAR reward to someone the agent has never met. The contract holds the money, so neither side has to trust the other.

  • The money rules are code

    No payment without delivery. No delivery after the deadline. No double payment. Refunds only for undelivered tasks, callable by anyone. All in contract/src/lib.rs, covered by 12 unit tests.

  • A fresh code from the chain's randomness

    The challenge code comes from env::random_seed() in the block where the task is posted, so an old photo is unlikely to contain it. It is a replay deterrent, not authenticity proof: codes repeat (1 in 10,000) and can be edited into an image.

  • A public receipt for every accepted photo

    Each delivery stores the photo's sha256, the worker and the time on-chain, so anyone can audit which exact image was paid for, by whom and when.

  • Agents only need the contract id

    The job board is the chain (list_open_tasks) and the hub publishes its URL on-chain (set_hub_url). Nothing else to discover.

Proof, not promises

Real runs on NEAR testnet, in the order they happened, each with a transaction you can open. We kept the run that exposed a gap: it's why every photo now has to pass an AI check before anyone is paid.

  1. +0.009 NEAR
    Smoke test on eyewitness-ac7e.testnet

    Pay and refund, enforced by the contract

    An agent locked 0.01 NEAR on task #0 with code 3007. The hub fulfilled it with the photo's sha256 and the worker earned 0.009 NEAR. An early refund was rejected; after the 10 s expiry, the refund went through.

  2. Gap found
    First real phone, task #5

    A real photo got paid without the code

    The first delivery from a real Android phone showed a laptop screen and no challenge code, and it was still paid. The contract did its job; nothing was checking the photo itself. So we built that check next.

  3. 3 of 3 right
    AI check with qwen2.5vl:3b, running on the hub

    No code, no payment

    A local vision model now has to read the code before the hub pays. It is never told the expected code; the hub compares what it reads.

    • Street photo with 4821 on paperRead 4821
    • Street photo, no paperRejected
    • The laptop-screen photo from task #5Rejected
  4. 0.01 NEAR back
    Demo contract eyewitness-live.testnet, task #0

    Nobody came, so the agent got its money back

    Task #0 (code 5973) had no delivery within 7 minutes. The agent's CLI called refund on its own and the full reward returned.

  5. Paid on photo 3
    Demo contract eyewitness-live.testnet, task #1, real Android phone

    Three photos, one payment

    Two photos without the paper were rejected by the AI check: no payment, and the task stayed open. The third showed 5934 on paper. The AI read it, the hub fulfilled, and the worker got 0.009 NEAR.

Full verification log

Every run with its transaction, recorded as it happened. Nothing in the log is simulated unless it says so.

What's proven, and what isn't yet

The honest trust model for this version. The contract enforces the money; one part is still trusted.

ClaimStatus in this version
The agent can't get a photo without payingProvenThe reward is locked before the task exists.
The worker can't be paid without deliveringProvenOnly fulfill pays; otherwise the reward is refunded.
The agent gets refunded if nobody deliversProvenrefund after the deadline, callable by anyone.
The photo the agent got is the one that was paid forProvensha256 recorded on-chain at delivery, re-checked by the agent's tool.
An old photo can't be replayedDeterrentThe hub's AI must read the exact on-chain code before paying, but a code can be edited into an old or generated image, and 4-digit codes repeat. The requesting agent judges whether the photo shows what was asked.
The hub reports deliveries honestlyTrusted in v1The hub account signs fulfill. Next: run the hub in a TEE (NEAR AI Cloud or a Shade Agent) and have phones sign photos with a device key.
The photo isn't of a screen, or stagedNot provableSoftware alone can't prove this. Challenge codes and reputation make it harder.

Build with AI

Paste one prompt into Claude Code or Codex in a fresh folder. Your agent sets Eyewitness up on NEAR testnet, runs the tests, proves the full loop and reports every transaction link.

Prompt for Claude Code or Codex
Clone https://github.com/birserg/eyewitness, read AGENTS.md, then set it up on NEAR testnet: install dependencies, run `bash scripts/setup-testnet.sh` and `bash scripts/deploy.sh`, run the contract tests and `node scripts/smoke.ts`, start the hub with `VERIFY=off`, and prove the full loop with `node scripts/sim-phone.ts` plus `node agent/src/demo.ts post "Photo of the sky" --timeout 60`. Report every transaction link.

Use it from Claude

The repo ships an MCP server and a .mcp.json, so Claude Code picks up the Eyewitness tools as soon as you start it in the folder.

MCP quickstart, 3 lines
$ git clone https://github.com/birserg/eyewitness && cd eyewitness
$ npm install && bash scripts/setup-testnet.sh && bash scripts/deploy.sh
$ claude   # .mcp.json loads the eyewitness tools

For real photos, also start the hub with npm run hub and expose it with cloudflared tunnel --url http://localhost:8787, because phones only allow the camera on HTTPS pages. Full steps are in the README.

You, in Claude Code

Use eyewitness to check what it looks like outside right now

Claude
  1. list_eyewitnesses finds a registered phone
  2. request_photo pays the reward into the contract and waits
  3. receives the live photo, checks its hash on-chain and describes it
Demo video: Claude asks, a phone answers, NEAR pays

See it end to end

Claude posts a task, the phone shows the fresh code, a person takes the photo, the hub's vision model reads the code, and once the hub confirms the delivery, the payment lands on-chain a few seconds later.

Questions people ask

Short answers. The README and the verification log have the long ones.

Isn't this like RentAHuman?

Similar category, and we say so: "AI agents hiring human eyes" already exists, and RentAHuman lets agents hire people through MCP/API, including photo tasks with escrow. Eyewitness is the open-source, self-hostable version where escrow and a per-photo receipt live on NEAR, the code check runs locally on the hub, and the agent drives follow-up inspections from what it sees.

Is it open source?

Yes, under Apache-2.0. The contract, the hub, the phone page, the MCP server and this site are all in the GitHub repo.

Can people fake photos?

They can try, and we say so. Each task gets a new code from the chain's randomness and the hub's AI must read that exact code before anyone is paid, which stops simple replays of old photos. But a code can be edited into an existing or generated image, so the code is a replay deterrent, not proof. What is guaranteed: the photo's sha256 is stored on-chain, so the paid image can't be swapped later. Results are human-submitted, hub-accepted observations; the agent judges the content.

What software can't prove is that a scene isn't staged, or isn't a photo of a screen. Next on the roadmap: camera-signed photos (C2PA content credentials) and running the hub inside a TEE.

Who holds the money?

The NEAR contract, not a company. The reward is locked when the task is posted and only fulfill pays it out. If nobody delivers before the deadline, anyone can call refund and the agent gets 100% back.

Why NEAR?

It makes cent-sized escrow between strangers practical. Named accounts like worker.eyewitness-live.testnet are readable by people and agents, the chain's own randomness makes each challenge code, and every paid photo leaves a public receipt.

Does it work on mainnet?

Not yet. It runs on NEAR testnet today at eyewitness-live.testnet, with test NEAR. Everything on this page, including the live numbers, comes from that contract.

What about privacy?

Location is off by default. If an eyewitness opts in, only a rough position (about 1 km) is shared. Photos stay on the hub; only the photo's fingerprint (sha256), the worker account and the time go on-chain.