Inspiration

If you make things for a living, getting paid is the part you have the least control over. You finish the work, the sale goes through, and then you wait. Weeks, sometimes. Meanwhile the buyer on the other side has paid for something they haven't seen yet and is hoping it shows up as described.

Every creator marketplace has a back office that sits between those two people. Someone decides who is safe to pay this week, who is part of a fraud ring, how much to hold back for chargebacks, and whether the fund can cover what everyone is owed. Today that's usually spreadsheets and a small risk team.

AI agents are good at that kind of judgment. But nobody should let a model move real money on trust alone. I wanted to build a back office where the AI does the thinking and plain code holds the line, and where you can watch every decision happen.

What it does

Helm is a creator marketplace where AI agents handle the money, inside limits set in code. You can try it live in three roles.

As a buyer

  • Every seller has a trust score built from their sales and returns. Fewer sales means less certainty, so the score starts low and has to be earned.
  • Buy something yourself and PayPal holds your money until the delivery checks out.
  • Or hand it to your agent with a budget you sign. It looks for the item that actually fits, then weighs price against seller trust. If a listing hides instructions meant to hijack the agent, Helm pulls that listing before the AI ever reads it.
  • The seller delivers through Helm, a second AI checks the files against the listing, and you accept or reject. Reject, and you're never charged.

As a creator

  • List something and it becomes a PayPal Catalog product.
  • An AI manager reads your sales and tells you, in plain words, what to make more of and what your best money option is.
  • Get paid early: Helm lends against what you've already earned. It prices how likely you are not to pay it back, then replays your next six months from your own sales. The less certain it is, the less it lends, and if the fee would be punishing, Helm declines instead of overcharging.
  • Invest with a club: you and three community members put money into real companies together. Each person has their own AI agent that reads live prices and news through an MCP server, picks on its own, then sees the others' picks and can change its mind. A manager agent blends the picks by how much each person put in. Then code enforces the rules: only listed companies, no single stock above 35 percent, everyone inside the limit they signed, and none of your money goes into something you ruled out. Orders go to Alpaca paper trading.

As the operator

  • Helm earns 10 percent of each sale plus the fee on early pay. The platform fee shows up in the money flow the moment a sale is paid.
  • One scan links accounts that share a card, a device or an IP, finds fraud rings, and freezes their money.
  • Payday: one AI reads the week's risk alert, another sizes up each creator, a bull and a bear argue about how much to release, and a manager proposes the amounts. Then code checks every number. Nobody gets more than they're owed, the safety fund stays covered, and every payee is checked against a sanctions denylist (a stand-in for real OFAC screening). Only then does PayPal send the payouts.
  • Prove solvency builds a zero-knowledge range proof over Pedersen commitments that the fund covers everything creators are owed. An outside auditor could check it without being given the balance. In the demo the balance is on screen anyway, so you can compare.

Every step streams to the screen as it happens: what the AI decided, what the code checked, and what PayPal answered.

What's real and what's simulated. Real: every PayPal sandbox call, every model call, Channel3 product search, live prices, Alpaca news and paper orders, the fraud engines, the solver, the signatures and both proofs. Simulated, and labelled on screen: the other creators and their sales history, the AI customers' wallets, the three other club members, the delivered files, and the dispute button.

How we built it

  • Agents: LangGraph for the buyer (a supervisor routing worker agents), payday (role agents with a bull and bear debate) and the investment club (four member agents in parallel, two rounds, then a manager). Models are OpenAI gpt-5-nano and gpt-5-mini, streamed token by token.
  • PayPal: Orders v2 (create, authorize, capture, void, refund, with the creator as payee), Payouts, Catalog Products, Customer Disputes with signed webhooks, and a Payouts MCP server.
  • MCP: three servers built on the Python MCP SDK, for payouts, trust and market data. The club's agents call the market server over stdio for prices and Alpaca news.
  • The checks: ES256-signed spending mandates, an allocation solver (OR-Tools), a Z3 proof that cumulative spend can never pass the signed budget, hash-chained receipts, and a Pedersen-commitment range proof for solvency.
  • Data: SQLite for the money ledger, Kuzu for fraud-ring graph queries, and a vector store for the agents' financial knowledge.
  • Control room: FastAPI with server-sent events, d3 for the live map and agent graphs, AG Grid for the ledger.
  • Hosting: an isolated AWS EC2 instance.
  • Testing: 314 tests, including Hypothesis property tests on every money rule and live end-to-end tests that fail if any agent quietly falls back.

Challenges we ran into

  • PayPal said no in ways that looked like yes. An order the buyer never approved can't be authorized, so some holds that looked fine weren't. Now nothing is booked until PayPal accepts it, and a refusal shows PayPal's own error code.
  • Sandbox payouts draw from a separate balance. Card captures don't refill it. I found that out mid-test, and payday now reports PayPal's exact refusal instead of pretending to pay.
  • A two-cent bug. Property-based testing found that rounded payout shares could go over the cap by up to two cents in about 14 percent of batches. Shares now round down, and there's a test so it can't come back.
  • The club agents copied each other. When the agents saw each other's picks, they drifted toward the crowd and stopped representing their own person. Edwards' paper "Do LLM Crowds Produce Investment Signals?" (SSRN) found the same herding, so each agent now picks alone first and only changes its pick when another agent's reason is better for its own member.
  • "No oil companies" didn't always stick. The model would sometimes respect a refusal in round one and quietly add it back later. Refusals are now recorded per person, and code makes sure none of that person's money goes there, whatever the model says.

Accomplishments that we're proud of

  • The AI proposes and the code disposes, and you can watch the line between them in real time.
  • A planted prompt-injection listing is pulled before any model reads it.
  • Fraud rings are found by following shared cards, devices and IPs through a graph, not by labels, and their money freezes on the spot.
  • The platform proves it can pay everyone it owes, and an underfunded platform can't produce that proof at all.

What we learned

Getting a model to choose is the easy part. The hard part is drawing a clean line between what the model is allowed to decide and what only code may do, and then showing that line to a person clearly enough that they'd trust it with their money.

What's next for Helm: making things should pay, on time and fairly

Real seller onboarding through PayPal partner referrals so every creator is a real payee, platform fees and delayed disbursement once the app is approved, and a balance feed from the bank so the solvency proof is tied to real money. Past that, the club gets real members, and every creator gets a manager that watches their money as closely as they watch their craft.

Built With

Share this project:

Updates

Submission history