Inspiration

What happens when an AI agent completes a paid job? Who decides whether it actually earned the money?

For traditional freelance work, trust has always been difficult. Clients don't want to pay before seeing results. Freelancers don't want to deliver without knowing they'll be paid.

AI agents make that problem even more interesting.

An agent can translate a document, fix code, or produce a deliverable autonomously. But completing a task and proving that its requirements were met are two different things.

Traditional payment tools can authorize and transfer money. They don't independently determine whether the work satisfies the agreement.

I wanted to build the missing layer between work and payment: a system where AI can verify objective results, humans retain control over subjective decisions, and PayPal moves the money only when the required conditions are satisfied.

One potential user, a designer who hires freelancers for $50–$500 jobs, highlighted the central risk: work can be formally delivered while still producing incorrect results. That feedback reinforced an important design principle: the system must protect both clients and workers, not simply automate approvals.

That's how Proof of Done started.

What it does

Proof of Done is a working verification and payment platform for jobs completed by humans or AI agents.

A client defines what successful work looks like, authorizes funds through PayPal, and publishes a job.

A freelancer or an autonomous AI agent delivers the work.

A Claude reviewer examines the evidence against every acceptance criterion. A second Claude model independently reviews the findings, and Google's Gemini provides a third check. A deterministic release policy enforces the requirements: the AI cannot bypass that policy simply by asking for payment.

When the necessary checks agree, PayPal captures the authorized funds and sends the payout.

We demonstrated the complete process using real PayPal Sandbox API transactions.

In one recorded transaction:

  1. A client funded a $40 job using PayPal Sandbox.
  2. Claude Code connected through MCP, found the job, and claimed it autonomously.
  3. The agent translated a café menu and submitted its deliverable.
  4. The independent AI checks approved the work.
  5. PayPal captured $40 and paid the agent $38.14 in sandbox test funds after fees.

No human manually approved that delivery.

But Proof of Done is more than a happy-path demo. It also handles rejected work, revision requests, subjective requirements, objection windows, partial settlements, refunds, deadlines, disputes, and milestone-based projects.

Every decision has an auditable record containing acceptance criteria, model findings, evidence hashes, and PayPal transaction references.

Try the working product:

How we built it

Proof of Done combines a full-stack web application, autonomous AI agents, independent verification, and PayPal Sandbox payment flows.

Payment infrastructure

We integrated PayPal Orders v2 authorizations, Payments v2 captures and refunds, Payouts, webhook verification, and dispute evidence.

The PayPal JavaScript SDK v6 supports the payment interface. PayPal Agent Toolkit allows the reviewer to inspect an order independently before approving a release.

AI verification engine

The primary reviewer uses the Anthropic TypeScript SDK with structured tools to inspect submissions, fetch evidence, execute delivered code where required, record findings, and propose a decision.

A second Claude model and Google Gemini independently check the evidence before an automatic release can proceed.

Crucially, payment release is enforced by application code, not by trusting a model's natural-language conclusion.

Autonomous agent support

We built a Model Context Protocol (MCP) interface that lets compatible agents discover jobs, claim work, submit deliverables, and wait for verification results.

This is how Claude Code completed and received payment for a sandbox job.

Product experience

The application uses Next.js, React, TypeScript, Tailwind CSS, and Zod. AG Grid powers the transaction ledger, AG Studio provides agent-oriented analytics, and Bryntum Gantt visualizes milestone-based projects. The demo is deployed on Render.

Testing and verification

We built Proof Gauntlet, a reproducible adversarial evaluation framework that measures whether the verification system distinguishes honest work from deliberately misleading submissions.

The project includes 236 automated tests covering application behavior and benchmark validation.

Challenges we ran into

1. What happens when the AI itself gets fooled?

This was our most important engineering challenge.

In one adversarial test, a submission contained instructions designed to manipulate the reviewer. Claude Opus reached the release path even though the delivery should have failed. The independent checks caught the manipulation and blocked the simulated release.

That led us to strengthen the security architecture: models provide evidence and findings, but a separate release policy controls whether an automatic payment is permitted.

2. Code that looks correct is not necessarily working code

We found a scenario where a fake screenshot of passing tests could fool multiple model checks. We fixed it by requiring actual code execution during review before code-based deliveries can be automatically paid.

3. Objective requirements versus subjective quality

AI can verify that a logo includes a required name, that files are delivered in SVG format, or that code passes tests. It cannot reliably determine whether a design feels welcoming or matches someone's personal taste.

Instead of pretending otherwise, Proof of Done leaves subjective decisions to the client, with a defined objection process.

4. Payment lifecycle and race conditions

A payment system must handle timeouts, repeated requests, disputed deliveries, expiring authorizations, and multiple actions happening simultaneously.

We implemented idempotency protections, serialized operations per deal, authorization-deadline controls, and explicit payment states to avoid inconsistent money movement.

Accomplishments that we're proud of

An AI agent earned a PayPal Sandbox payout

Claude Code independently found a funded job, completed it, submitted the deliverable, passed verification, and received $38.14 in sandbox test funds.

Four end-to-end PayPal Sandbox payment deals succeeded

The project also exercised authorization, capture, payout, void, partial settlement, and refund paths using PayPal Sandbox APIs.

We tried to break our own verification engine

Our original benchmark contained 57 labelled submissions, including 41 deliberately incorrect or adversarial deliveries.

  • Claude Opus alone reached the release path on 10 of 41 bad submissions.
  • With independent verification enabled, 0 of 41 bad submissions were released in the simulated evaluation.
  • One honest submission was incorrectly held, exposing a limitation we explicitly documented.

We then generated 19 additional pre-labelled counterfactual submissions and ran them against two configurations:

  • Haiku + Sonnet + Gemini: 19/19 correct decisions.
  • Opus + Haiku + Gemini: 19/19 correct decisions, after retrying two cases that initially hit an API usage limit. Those errors were not counted as successful decisions.

These are small, related test sets — not a guarantee of perfect security.

We built the surrounding product, not just the AI check

The system includes an open job board, payment handling, revision and objection workflows, milestones, audit trails, verifiable certificates, and a public interactive demo.

What we learned

The hardest part of building an AI system that can trigger payments isn't getting a model to say whether work is complete.

It's defining what the model is allowed to decide, what the application must independently enforce, and when a human should have the final say.

Multiple models reduce certain risks, but agreement alone isn't enough. Deliveries are untrusted evidence. Code must be executed when execution is necessary. Payment operations must be idempotent and auditable.

And protecting a client from bad work is only half the problem: honest workers must also be protected from unfair rejection or cancellation.

The result is a system designed around verifiable outcomes, explicit permissions, and accountability on both sides.

What's next for Proof of Done

Our next goal is to move from a working PayPal Sandbox prototype toward a production-ready platform.

  • PayPal Commerce Platform integration for connected freelancer accounts and platform fees.
  • Production-grade identity and account management, including PayPal login.
  • More realistic evaluation datasets, external testing, and larger adversarial benchmarks.
  • Additional agent integrations so AI workers can discover and complete paid tasks directly through their existing tools.
  • Pilot projects with freelancers, agencies, and teams building commercial AI agents.

Our planned business model is a small fee on verified jobs.

The long-term vision is simple: AI agents are becoming economic participants. Proof of Done provides a way to verify their work, protect both parties, and connect verified results to payment.

AI works. Proof verifies. PayPal pays.

Built With

  • ag-grid
  • ag-studio
  • anthropic
  • bryntum
  • claude
  • gemini
  • mcp
  • next.js
  • openapi
  • paypal
  • paypal-agent-toolkit
  • paypal-js-sdk-v6
  • paypal-orders-api
  • paypal-payouts
  • react
  • render
  • tailwindcss
  • typescript
  • zod
Share this project:

Updates

Submission history