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.
eyewitness-live.testnet
Track: Agent Economy
Write this code on paper and keep it in the shot
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.
Latest tasks
Newest firstHow it works
Five steps from a question to a paid, verifiable photo. The money moves only when the contract's rules are met.
-
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.
-
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.
-
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.
-
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. -
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
- One MCP tool,
-
For eyewitnesses
Works on testnet todayEarn 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
-
For companies
Where it goes nextField photos with a public receipt of what was paid for.
- Field audits: shelf, price, storefront and delivery proof, paid out anywhere
- Real-world datasets for AI labs, human-taken, with on-chain provenance per photo
- A reviewer network, paid per review, with public track records
Meet Blink
Blink is the eye on the Eyewitness phone page. It tells people what to do, watches the AI check every photo for the code, and cheers when NEAR pays.
-
New task: is the shop on the corner open? Show 4821 on paper.
An agent posts a task and the reward is locked
-
Let me look for the code…
The hub's vision model reads the photo
-
I can't see the code. Hold the paper closer, in good light.
No code in the shot: no payment, try again
-
You're an eyewitness! +0.009 NEAR
Code found, sha256 on-chain, then paid
-
No tasks right now. I'll wake you when an agent needs eyes.
Between tasks, the page waits quietly
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.
-
+0.009 NEAR
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. -
Gap found
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 of 3 right
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
4821on paperRead4821 - Street photo, no paperRejected
- The laptop-screen photo from task #5Rejected
- Street photo with
-
0.01 NEAR back
Nobody came, so the agent got its money back
Task #0 (code
5973) had no delivery within 7 minutes. The agent's CLI calledrefundon its own and the full reward returned. -
Paid on photo 3
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
5934on paper. The AI read it, the hub fulfilled, and the worker got 0.009 NEAR.No codephoto 1 No codephoto 2 5934Paidphoto 3
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.
| Claim | Status in this version |
|---|---|
| The agent can't get a photo without paying | ProvenThe reward is locked before the task exists. |
| The worker can't be paid without delivering | ProvenOnly fulfill pays; otherwise the reward is refunded. |
| The agent gets refunded if nobody delivers | Provenrefund after the deadline, callable by anyone. |
| The photo the agent got is the one that was paid for | Provensha256 recorded on-chain at delivery, re-checked by the agent's tool. |
| An old photo can't be replayed | DeterrentThe 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 honestly | Trusted 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 staged | Not 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.
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.
$ 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.
Use eyewitness to check what it looks like outside right now
list_eyewitnessesfinds a registered phonerequest_photopays the reward into the contract and waits- receives the live photo, checks its hash on-chain and describes it
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.