PactPal: AI that seals the deal

When a PayPal dispute hits, freelancers scramble for proof. PactPal builds it as they work: AI turns chats into agreements, PayPal bills each stage, and every step is sealed into one record.

Comment

Inspiration

When this hackathon opened, I didn't start with an idea. I started by listening. I went through Shopify forums, seller blogs and review sites, looking for where people struggle with PayPal, and one story kept coming back.

A freelancer delivers the work. Weeks later, the buyer opens a dispute. The seller has the proof somewhere, scattered across a WhatsApp chat, an email thread and a few screenshots, and still loses. Sometimes it's the other way round: a buyer says they were short-changed, and the case is decided on the seller's own records. "Despite providing all evidence, the dispute was closed in the customer's favor." Posts like that go back more than a decade, and 71% of freelancers struggle to get paid at least once.

That surprised me. I've paid freelancers through PayPal myself. It works in more than 200 markets and millions of people trust it with their income. How could this keep happening?

So I read PayPal's own Seller Protection rules, and there it was. For digital goods and services, proof of delivery means "a system of record showing the date the item was sent" and that it was received or accessed. PayPal has always been clear about what's needed. Most small sellers simply don't have it. The rule was right. The tool was missing.

That gap became PactPal: a system of record that builds itself while the deal happens, so when a dispute comes, the evidence is already there, for whichever side is telling the truth.

Every post, figure and source: problem evidence.

What it does

PactPal is a deal space for one seller and one buyer. AI turns the conversation into an agreement, PayPal moves the money, and every step is sealed into a tamper-evident record.

  • From any chat to a clear agreement. Paste a chat, forward an email, drop a screenshot, share a product link, or just talk in PactPal's live chat. Five AI models each draft the agreement, with every term quoting the exact chat line it came from. They rank each other's drafts without knowing who wrote them, and the seller makes the final call. Anything the chat never said is flagged, never invented.
  • A timeline, not just a document. The council also builds the deal's timeline: what the buyer must provide first, the sketch to approve, each payment stage, each delivery, in order, with what depends on what. PactPal reminds whoever the next step is waiting for, and shows it all on a Gantt chart.
  • Signed and paid through PayPal. The buyer needs no account. They read every term on one page, ask questions (answered only from the agreement, with the line quoted) and sign. Each stage becomes a PayPal invoice sent from the seller's own PayPal account, and a signed PayPal webhook marks it paid.
  • Scope creep, caught kindly. When a buyer asks for "just one more thing", AI recognises it as in scope, an extra revision or new work, and turns it into a priced change the buyer can accept or decline, on the record.
  • Deliveries that prove themselves. Before files go out, PactPal checks them against the agreement; it caught a background that should have been transparent. Every download and approval is logged.
  • Disputes answered from the record. PactPal finds the PayPal dispute, compares each part of the buyer's claim with the agreement and the log, drafts a neutral summary and builds an evidence packet with a fingerprint for every file. The seller sends it from their own PayPal account.
  • Evidence you can actually see. Every deal carries an evidence score out of 100: how complete its record is (signed, paid, delivered, downloaded, approved) and what's still missing, so a seller can close the gaps before anything goes wrong. When a dispute comes, the evidence packet is a ready-to-send PDF: the buyer's claim set against the record, the timeline from the log, every file's SHA-256 fingerprint and the record's seal. And one click on Check this log proves no entry has been changed since it was written.
  • Honest, even when it hurts. If the record shows the seller is wrong, PactPal says so: it suggests a refund and, if PayPal decides for the buyer, tells the seller plainly there's nothing new to appeal with. It's on the record's side, not the seller's. (How a dispute is answered)
  • Your AI agent can do the work. Through PactPal's own MCP server, a seller's assistant (Claude Code, Cursor or any MCP client) can find deals, draft new ones from a message, prepare evidence and ask to send invoices. Anything that moves money to PayPal waits for the seller's tap and a one-time code, and every action is logged with the agent's key. (How an agent's request is approved, more in the README)
  • Everything else a seller needs: a dashboard, "Needs you", one chat per buyer, deadlines, reminders, Insights and branded emails.

📄 The one thing my video didn't show, and it's the heart of PactPal. Three minutes ran out before I could show the evidence itself. Please take a look:

  • The evidence packet PDF: sign in as Daniel → Deals → "Rosa's Corner Bakery website" → Disputes tab → open the dispute → Evidence packet → packet PDF.
  • The evidence score and the log check: sign in as Maya → Deals → "Wren, the lantern-keeper" → Evidence log → Check this log.
  • Or as still images: the project gallery above, image 4 (evidence score and log check), image 6 (the evidence packet PDF) and image 7 (the emails).

In the demo: a $1,500 bakery website ends in a PayPal dispute: "the blog was never built". The record shows the buyer declined the blog in writing, and PayPal decides for the seller. In another deal, a retoucher delivered 4 of 6 photos and went silent. PactPal tells her so, and PayPal decides for the buyer. Same record, honest both ways.

The whole journey in one picture: from chat to paid.

How I built it

  • PayPal, the money and the verdict:
    • Log in with PayPal (OpenID Connect);
    • Invoicing v2: one invoice per stage, carrying the agreement's fingerprint;
    • Webhooks, signature-verified;
    • Disputes v1: read; send evidence, offers, acceptance, messages and appeals;
    • seller-owned apps: each seller links their own PayPal app, with secrets encrypted at rest;
    • PayPal's MCP server, tried first, with automatic REST fallback.
    • Every PayPal capability and the code behind it: PayPal integration.
  • The AI council:
    • five models from five families: Google Gemini, Alibaba Qwen, OpenAI GPT-OSS, Mistral and NVIDIA Nemotron;
    • each drafts alone and must cite a source line for every term, and code throws out any draft that cites a line that isn't there;
    • the rest are ranked blind, with self-votes ignored, and a Borda count picks one whole draft;
    • low agreement flags the draft for a closer look;
    • lines in a chat that try to give the AI orders are hidden from the models and shown to the seller.
    • How the council picks one draft (interactive diagram) · the AI in depth.
  • The record: an append-only evidence log, each entry chained to the one before it with SHA-256. Anyone can check it from the deal page with one click. (How the log stays honest)
  • The stack: TypeScript end to end, React, Fastify, Postgres and an MCP server of its own. There are 2,091 tests with at least 90% coverage, all run in CI on every push. (Architecture · the whole system)
  • Sponsor tools:
    • Render: one Blueprint for everything; every AI model call runs as its own Workflow task, so a slow model never holds up the rest; a Cron Job watches PayPal for disputes; plus Postgres, Key Value and static sites; see the Render services diagram and Running on Render;
    • AG Grid and AG Studio: the deals table and the Insights dashboard;
    • Bryntum: timelines and deadlines;
    • Channel3: reads a product page so the agreement says exactly what's being sold.
    • What each sponsor tool does in PactPal, with screenshots: Sponsor tools.

Challenges I ran into

  • Keeping AI from inventing evidence. A dispute tool that makes things up is worse than none. So every term must cite a real line, and code, not a model, checks every citation before the seller ever sees a draft.
  • Seeing every dispute. I first assumed one platform app could hear about all sellers' disputes through webhooks. In testing, a dispute on a payment the platform app wasn't part of stayed invisible to it. So each seller links their own PayPal app, which does see their disputes, and a check every 5 minutes reads each seller's dispute list, so nothing slips through.
  • Acting for many sellers. I asked on PayPal's Discord whether partner invoicing could be enabled. The team answered quickly: it's for select partners, and in the sandbox, sellers' own app keys are the way. That became one of PactPal's best features: every invoice really comes from the seller's own PayPal account.
  • The MCP server. PayPal's hosted MCP server lists its tools, but its calls failed for weeks in my tests, and it doesn't yet have tools for evidence, offers or appeals. I built MCP-first with an automatic REST fallback, so nothing breaks and MCP takes over as it matures.

A big thank you to the PayPal team and every sponsor team for answering questions on Discord so quickly. It made a real difference.

Accomplishments that I'm proud of

  • Real disputes, decided by PayPal. Four disputes ran end to end in the PayPal sandbox: found, compared with the record, answered with evidence and decided by PayPal. Nothing is mocked.
  • The record is honest both ways. It won a case for an honest seller, and told a seller who was wrong that she was wrong.
  • The council beats a single model. On 11 chats with known right answers, its pick scored 0.97 against 0.92 for a single model's draft. In 14 prompt-injection attacks, not one got through. (Full eval results)
  • A complete product, not a prototype:
    • 5 sellers and 8 buyers with real sandbox accounts and real deals, open for judges to explore;
    • a buyer experience with no sign-up;
    • a 20-page help site with interactive diagrams;
    • branded emails;
    • an MCP server for agents.
  • Money tied to the agreement. Every PayPal invoice carries the agreement's fingerprint, so the payment, the terms and the proof point at each other.

What I learned

  • Trust needs more than one voice. A single model is a single point of failure: it can be wrong, biased or manipulated. Five models checking each other blind are much harder to fool.
  • The best time to collect evidence is before anyone needs it. Once proof is collected as a side effect of doing the work, disputes stop being a scramble.
  • Agents are ready for real commerce when the record is shared. The same log that protects a seller lets an AI agent draft deals, prepare evidence and request payments, and stay accountable for every action it takes.

What's next for PactPal

Next steps

  • More dispute types and more marketplaces.
  • Live PayPal accounts beyond the sandbox.
  • Larger deliveries through object storage.

The vision: a freelancer platform with the record at its heart. Portfolios, discovery, conversations and deals in one place, paid and protected through PayPal, like a marketplace where trust is built in rather than promised. One day, something PayPal could offer every seller and buyer who works this way.

🚀 Try PactPal yourself

▶️ Watch the 2:56 demo · 🌐 Open the live app · 🧭 Judges' guide

The judges' guide has every demo seller and buyer, what's in each account, five things to open, scenarios to paste, and how to use your own PayPal sandbox accounts.

🔑 One password opens every demo account and the shared inbox. It's in this submission's testing instructions.

📖 README · 🗺️ Interactive diagrams · ❓ Help site

🧭 Where to start: sign in as Daniel → Deals → "Rosa's Corner Bakery website" → Disputes tab, or as Maya → "Wren, the lantern-keeper" → Evidence log.

📄 Not in the video, please don't miss it: the evidence packet PDF (on Daniel's bakery dispute) and the evidence score with its one-click log check (on Maya's Wren deal). Stills are in the gallery: images 4, 6 and 7.

Built With

Share this project:

Updates

Submission history