Neo | Devpost

Technical Architecture
Four agents run the desk. Three calls are waiting for the controller.
Exploits caught: 5 clients paying just before a restriction, $648K exposed, evidence and fix
Monarch pays, the hold comes off, and Sage turns their access back on.
The RM says Ivory Lane is being acquired. Sage checks it out and asks the controller.
Quinn wasn’t sure enough to move Juniper’s tier, so it asked first.
The controller said no. Iris remembers why.
A reminder policy goes out on its own, the client pays on time, Iris marks it working.
Rowan compares a first dispute with similar cases before flagging it.
Every Nessie account matches the ledger to the cent.
What a restricted client sees: what’s paused and how to fix it.
One payment, from the bank to applied, in 0.26 seconds.
Every client scored on value and reliability, sorted into tiers.

In one line

Neo fills two seats on a B2B finance team. The Credit Analyst sets each client's terms, and the Access Controller restricts clients based on those terms, only as far as the contract allows, and gives access back the moment they pay.

The moment

A fund is restricted for unpaid bills, with only the amount it owes on hold. Its relationship manager says they already paid, but billing still shows the invoices open. Neo searches the bank feed, finds a wire sent under the fund's parent company with no reference, and matches it to the invoices with evidence. The hold lifts, the client is notified, the fund's credit profile updates, and the books tie out to the cent, all without anyone on the finance team stepping in.

For the Hyphenate track

Is it real enough? : Neo runs a live company, not a demo. 30 institutional clients, a year of history and a business that never stops: billing goes out, clients pay late, pay in part, game the terms and bounce payments, all through Capital One’s Nessie bank. 21 planted problems, one answer key, 330 passing tests.
Would you hire it? : Neo takes over two finance jobs on day one. It runs credit and access control end to end. It never approves its own work, never goes past the contract, and brings in a person only for the calls that matter. Every move is on the record.
Did we see something new? : Neo gets clients to pay without breaking their business. Emails get ignored, and a full freeze destroys the relationship. Neo holds exactly what’s owed, keeps trading open, and gives access back the moment the money lands.
The moment? : Neo finds the money everyone missed. A client swears it paid, and billing disagrees. Neo traces the wire to the parent company, proves the match and restores access in under a second. It also catches the client that disputes every invoice to buy time, before anyone else notices.

Inspiration

One of us worked on the B2B team at a large crypto platform. Clients would stop paying for the product and keep using it, and the company couldn't do much about it. Finding who hadn't paid and restricting them took too many manual hours, the data was scattered across systems, and teams weren't aligned. The stopgap was an engineering manager restricting clients by hand until they paid, which didn't scale. AI collections tools today chase payments by email, but an email is easy to ignore. What gets a client to pay is a change in the product they use every day. We built Neo for that gap.

What it does

Neo is an autonomous multi-agent system for B2B finance teams. It runs inside Northstar Prime, a fictional crypto prime broker with 30 institutional clients billed monthly by usage.

The Credit Analyst seat is three agents. Iris scores every client on reliability and value. Quinn sorts them into tiers that decide how firmly the desk acts and when a person has to sign off, and drafts client-specific policies. Rowan catches clients gaming the terms, like paying the day before a restriction or sending small partial payments to reset aging.

The Access Controller seat is Sage. It waits out each contract's grace and cure periods, collects from custody where the contract allows, then takes the gentlest step that still protects the company, like making API access read-only or holding only the amount owed while hedged trading stays open. Every restriction is shown next to what a full cutoff would have done. Access comes back the moment the client pays.

Iris also keeps the books honest. After every change, the bank is tied out against the ledger to the cent. When something doesn't tie, she traces it to the payments behind it and posts a correction only if it closes the gap exactly. Money from unknown senders is matched to its owner or sent back.

How we built it - Sponsor tech

Agents use rules first and models second. When they need judgment, they decide through Factory's Droid.

Only one gateway writes to the outside systems, through an outbox where each command is keyed so it can't run twice. The server and agents are TypeScript on Azure, the console is React on Vercel, and CI tests every push before it deploys.

SpacetimeDB: the database is the orchestrator. Neo has many actors touching the same money at once, including four agents, controllers, relationship managers, every client in its own portal, the bank sync and the gateway. One of them working from stale data means a client gets restricted after they paid, so SpacetimeDB gives every actor one live, consistent copy of the truth. It's also our orchestrator, with no job queue or message bus. The reducer that applies a payment checks the contract, releases the hold, writes the audit row and queues a task for each agent that should look, all in one transaction, and subscriptions push that change to the agents and every screen in about 100 ms. Only clients whose data changed get a task, so the demo runs 30 clients and the design is built for thousands.

Factory Droid SDK: how the agents think. Droid makes the judgment calls in the running product, on triggers the database fires: a payment lands, an RM writes a note, a deadline passes. Sage and Rowan run Droid sessions whose only tools are ours, served over MCP and scoped to one client per session. They can read invoices, payments, notes, and how similar cases ended at other clients, and take one action per task through the database's guardrails. Built-in tools are off, and permission requests are refused. Every step the agent took and the reason it gave show in the agent's panel.

Capital One Nessie: the platform's bank. Northstar Prime and all 30 clients have their own Nessie accounts, and money really moves between them. Wires and ACH payments, partial and short payments, ACH returns, duplicate refunds, withdrawals from custody to the client's bank, and unknown money sent back to its sender are all Nessie transactions. Neo reads the raw bank text, matches it to invoices, and ties the bank to the ledger to the cent after every change. A client clears its balance from its own Nessie account and gets access back on its own.

Microsoft: built for the real world, running on Azure.

Customer understanding: it started with a real problem one of us lived through at a crypto platform.
Measurable usefulness: in the simulated company, 91% of decisions needed nobody, and the share that needed a person fell from 35% to under 5% over 12 weeks.
Path to production: the API server and agents run on Azure Container Apps, deployed by GitHub Actions through a managed identity with no stored secrets. Only one gateway writes to outside systems, so swapping the simulated billing and custody for NetSuite and a real custodian doesn't touch the agents.
Responsible design: limits live in the database, not in prompts. Every action is logged with its reason, and a person decides anything risky.
End-to-end: the live demo runs the whole loop, from a wire landing to access restored.

Why you'd hire it

Limits are enforced in code, not prompts. Agents propose through checked reducers, nobody approves their own work, and a client in default who tries to trade is refused by the database itself.
It keeps a clean record. Every action, denied attempt, and decision to wait is logged with its reason.
It knows when to ask. The desk acts on its own, and the controller decides only on top clients, offboarding, contract changes, exceptions no policy covers, promotions into Tier 1, and any call where the model goes beyond the rules at under 70% confidence.
It handles a no. A rejected proposal isn't made again for 30 days, and exception requests go to the controller instead of being decided by the agent.
It learns. Every human decision becomes a precedent. The policies it writes actually run and get graded against real payments, and failing ones get redrafted. Memory lives in the database, not a context window.
It keeps a person in charge of the calls that matter, which is what a fintech's risk team needs before trusting software with client access.

What's real, what's simulated, and how we know

The system of work, rules, gateway, audit log, tie-out, every agent decision, and the Nessie bank are real. The company is simulated but alive: a business day passes every 15 minutes, and clients pay, pay late, dispute, trade, and withdraw on their own, so the desk is always working on something new. It starts from 12 months of history with planted problems like short SWIFT wires, affiliate payers, ACH returns, disputes, an acquisition mid-default, and clients gaming their terms.

Verify scripts check live results against an answer key (sync, payments, ledger, tie-out, and credit tiers), 330 automated tests pass, and one payment went from the bank feed to applied at the platform in 0.26 seconds.

Challenges we ran into

Our first version reloaded everything on a timer and took 64 seconds to restore access. We rebuilt it so the database pushes changes to the agents, which takes about 100 ms.
Running eight model calls at once ran the container out of memory. We capped it at two, with rules as the fallback.
Factory's Droid is built to write code. We turned off every built-in tool and gave it only ours, scoped to one client per session, so it can investigate a case but can't step outside it.

Accomplishments that we're proud of

The "already paid" moment works end to end on a live database
A payment lands and access comes back on its own, with every step checked against the contract
Every agent leaves a full audit trail, so any decision can be explained months later
The desk runs on its own and only asks a person when the risk is real
It catches clients exploiting loopholes in their payment terms
Policies the agents write actually run, and get graded on whether they worked

What we learned

Finance is mostly edge cases, like a wire that's $35 short or a payment from the wrong legal entity. The hard part wasn't calling a model. It was building the rules, roles, and records that make an autonomous decision safe to trust.

What's next

Discover strategic clients instead of declaring them. Group linked entities through shared payers and wallets, and propose strategic status for a person to confirm. Goal: on the back-test, rediscover every hand-marked strategic client with no false promotions.
Predict defaults before they happen. Turn the expected pay date into a 30-day default probability, and act on early signals with a reminder or a prepay offer before an invoice is ever late.
Run on real rails with one design partner. Swap the simulated billing, custody, and admin systems for NetSuite, a qualified custodian, and a live permissions API. The gateway contract stays the same.
Retire every kill switch. Bring the same desk to any business that bills in arrears and controls access: cloud and API platforms, payment processors, usage-based software.