Skip to main content

Money that files itself.

Not a dashboard you reconcile. A ledger that was never wrong.

A payment arrives through PayPal and posts itself — debited, credited, balanced, once. Agents propose what should happen next; a rule engine, not a model, decides whether it happens at all.

PayPal AI Hackathon 2026 · Sandbox · Built in the open

It arrives, and it arrives once.

Orders v2

The payer approves an order and PayPal confirms it twice — once to the browser, once by webhook. Both land in the same place, and the second one changes nothing. The amounts are never taken from the message: they are read back from PayPal before a single entry is written.

Proposed by a model. Decided by a rule.

Guardian

An agent writes down what it wants: who is paid, how much, out of which pot. A deterministic engine accepts or refuses it against limits you set, and an approval is bound to the hash of what was approved. Change one digit afterwards and the approval dies with it.

The table

Twelve seats. Twelve already working.

12 seats · 12 live

The members that move money are plain code, and they are running today. The ones that think are still being built. Keep scrolling to go round the table.

  1. Teller, Takes the payment: Opens a PayPal order for exactly what is still due on an invoice, then captures it when the payer approves. The order id is kept, so a capture always finds its way back to one invoice.
  2. Courier, Carries the news: Picks up what PayPal's webhook left behind and reads the capture back from PayPal before anything is believed. Claims its work with a row lock, retries with a growing delay, and parks a job that keeps failing instead of looping on it.
  3. Ledger, Keeps the books: Posts every movement as double entry in integer minor units. A transaction that does not balance is refused before the database is touched, and a transaction id can only be posted once — so a replay writes nothing at all.
  4. Herald, Tells your server: Posts a signed event to your endpoint the moment an invoice turns paid, retries when your server is having a bad minute, and keeps a delivery log you can read.
  5. Scribe, Writes the invoices: Issues the next invoice of a recurring series and reminds a client who is late. Two runs at once cannot issue the same invoice twice; the row is claimed, not merely read.
  6. Guardian, Refuses what breaks a rule: Checks every proposal against limits you set: per payment, per day, who may be paid at all, whether a price is strange for its category. An approval is bound to the hash of the proposal it approved, so changing a digit afterwards voids it.
  7. Allocator, Proposes the split: Suggests how money that just landed should be divided: the platform's cut, tax set aside, what is yours to spend. It writes a proposal and nothing more.
  8. Payer, Pays what is due: Watches what falls due and proposes paying it from the right pot. Short in one place, it proposes a move from another — and that move is a proposal too.
  9. Reporter, Writes the day down: Turns the day's rows into a few sentences: what came in, what was set aside, what is still owed to you, what was refused and why.
  10. Builder, Builds the storefront: Turns a conversation into a storefront: products, prices, a page at your own address. It writes the page as blocks — the same ones you would have used — so every line of it is yours to edit afterwards. It will change a page you already have, and put right the things this app can check; it cannot write markup, and it cannot write an address, only name one of yours.
  11. Collector, Chases the overdue: Drafts the follow-up for an invoice that has gone quiet, in your voice. Whether to write at all is not its decision: that is settled in code before it is asked, and it stops after three letters.
  12. Advisor, Answers from the books: Answers a question about your money — including the ones that end in bad news. It does not write the query: it picks one of six we wrote, we run it scoped to you, and the rows it read are shown under the answer.

Four ways to be paid.

01 · Link

A page at your own name.

payus.app/@you/coffee. Set the price, or let them choose it. Share it anywhere a link goes.

02 · Invoice

Numbered, dated, repeating.

It issues the next one on schedule and reminds a client who is late, without you opening the app.

03 · Shop

A page with things on it.

Items, prices, one block of prose. Buying one writes an invoice first, so a sale settles down the path everything else takes.

04 · Checkout

One POST from your server.

Create a checkout with an API key, drop in the widget, and take a signed webhook the moment it is paid.

What a payment writes

Nothing here is a mock-up. One sandbox capture of $150.00, with PayPal keeping $5.00, posts these three lines and no others. The debits equal the credits, or the write never happens.

capture:5O190127TN · payment.captured

paypal_cash
145.00
—
psp_fee
5.00
—
in_flight:acme
—
150.00

Debit 150.00Credit 150.00

Then it divides, and it can undivide.

Money that arrives is split by rules you wrote: a share for tax, a fee, a pot of your own, and whatever is left is yours. Percentages are taken from the whole amount rather than the running remainder, and the percentage group is settled by largest remainder — so no cent is lost and none is invented. The one invariant every test checks before anything else: the allocations add up to exactly what came in.

And when it goes back

A refund comes out of the pots the capture went into — read back from that settlement's own ledger entries, not recomputed from today's rules, which may have changed since. Each share is the difference between two whole-amount allocations, so three refunds of a third add up to the capture exactly instead of drifting a cent apiece.

Read the third column and you can see the decision behind it. Tax set aside on a sale that was undone is not tax, so it comes back. A fixed platform fee does not, because the fee was for the sale, not for the amount — and the shortfall lands on the merchant line, where it honestly belongs.

settle 150.00 · refund 50.00

account
settled
returned
tax_reserve
30.00
10.00
platform_fee
2.00
0.00
merchant_payable
118.00
40.00

Settled 150.00Returned 50.00

Bring the file you already have.

A CSV from your bank, an .xlsx of last year's invoices, a contract as a PDF. PDF and .docx are unpacked in your browser and never reach the server — they are container formats with a long history of parser bugs, and there is no reason for a server to meet one. Only the text is sent.

01 · Ask

A question about your file.

The rows come out of the spreadsheet instead of the ledger, and the same check runs over the answer: a figure that was not in the rows throws the answer away.

02 · Reconcile

Your statement against the books.

No model anywhere near it. Matching a line to a posting is arithmetic and dates, and the two “only in” lists are the whole point of doing it.

03 · Import

A sheet of invoices, read first.

Read, shown, then created. The commit re-reads the file rather than trusting the browser, and every row goes through the same schema a typed invoice does.

The one that is not checked

Prose has no rows. An answer read out of a contract is the single place here where nothing can verify the figures, so the screen says so on every document answer, and the warning is stored with the answer rather than shown once and lost on reload. Saying which of the three a reply came from is the honest version of the feature; leaving it out would have been the impressive one.

01

No model touches money.

An agent's entire power is to write down what it would like to happen. Carrying it out is a separate, boring program that checks the request against your limits first.

Full disclosure

The limits live in the database, not in the prompt. A model that asks for something outside them gets a refusal and a logged reason — not an exception.

02

Every number comes from the books.

Reports and answers are written over query results. The model is handed rows and asked for sentences; it is never asked to remember a balance.

Full disclosure

The ledger is double entry in integer minor units — no floating point anywhere. If debits and credits ever disagreed, the write would have been refused before it happened.

03

And the part that is not built.

Sending a payout needs a permission PayPal grants per account. Until it is granted, a release is recorded as simulated and labelled as such on every screen it appears on — never as money that moved.

What that means

A payout goes to a PayPal account, identified by its email. It is not a transfer to a bank: moving a balance to a local account is a step the recipient takes inside PayPal, and this does not pretend otherwise. The money here is sandbox money.

Asked before.

Is this real money?

No. Payus runs against the PayPal sandbox with test accounts, built for the PayPal AI Hackathon 2026.

What can an agent actually do?

Write a proposal. That is the whole list. A deterministic engine decides whether it runs, and an approval is tied to the hash of the exact proposal it approved.

What if PayPal sends the same event twice?

Nothing happens twice. The event is stored under its own id, and the ledger refuses a second posting of the same capture. A redelivery is answered 200 and dropped.

Where do the numbers in a report come from?

From SQL over the ledger. The model receives rows and writes sentences; it has no write access and nothing to remember.

Can I take payments from my own app?

Yes. Create a checkout with one authenticated POST, send your customer to the page or embed the widget, and take a signed webhook when it is paid.

Can it pay out to my bank account?

No. A release sends to a PayPal account, identified by its email address. Getting that balance into a local bank is a step you take inside PayPal, and there is no bank integration here pretending otherwise. Until PayPal grants the payouts permission on the account, a release is recorded as simulated and labelled that way everywhere it shows.

What happens when a payment is refunded?

The money comes back out of the pots it went into, read from that settlement's own entries rather than recomputed from today's rules. The invoice is owed again — it is reported with an absolute figure, not a delta — and no second receipt is sent, because it never became paid twice.

Can I upload my own spreadsheet?

Three things can be done with a file, and they are different promises. Ask answers from its rows, with the same figures check that runs over a ledger answer. Reconcile matches it against the books with no model involved at all. Import creates invoices from it, each one through the same schema a typed invoice passes.

Can I approve something away from the dashboard?

If you link a Telegram chat, yes. The chat proves itself with a single-use code and the buttons call the same approve and refuse the dashboard does — same hash check, same expiry, same audit trail. Only the record of how you answered differs.

The rail is finished. The table is full.

Twelve seats: six that are ordinary code on the money path, and six that call a model and may only ever propose or draft. Nothing on this page is a plan — every claim here is a claim about a file in the repository, and the ones that are not finished say so.

Payus · PayPal AI Hackathon 2026