Fruxon

The clean invoices were never the problem.

Payables, PO matching, reconciliation, collections. An agent clears the records that reconcile and routes the ones that don't to the person who owns that call — with the mismatch and its reasoning already attached.

Start Free Book a walkthrough

The exception queue is where month-end goes.

Your OCR reads the invoice and your rules engine clears the ones that match. Everything else — the PO that's off by a line, the credit note nobody applied, the vendor whose terms changed last quarter — lands in a queue that somebody works by hand, in batches, in the last week of the month. The automation didn't fail on those. It never covered them.

An invoice, end to end

What actually happens when it picks one up.

It picks the invoice up where it lands

A new document in SAP, a row in a queue table, a PDF in the shared Google Drive folder, an email to your payables address. The vendor's history and the policy that governs this spend are retrieved at the step.

It matches against the systems of record

Match the PO and the receipt, confirm the terms against the contract in Confluence, query your Postgres or BigQuery for the last three invoices from that vendor. Totals and tax get computed in an isolated Python sandbox rather than in a prompt, because arithmetic in a prompt is a guess with a decimal point.

It stops on the exception, not on the batch

A variance outside tolerance, a vendor it's never seen, an amount over the approval threshold you set. It flags that one invoice and keeps clearing the rest — a malformed record fails on its own instead of taking the run down with it.

The exception goes to the person who owns it

Not to a shared ap@ inbox. The controller gets the invoice, the variance, the contract line it's reading from, and the agent's reasoning on Slack, answers once, and it posts. If nobody answers, the run parks on the approval and resumes when they do.

One run per record, each with its own trace

Collection Pipelines map an agent across a list-style source — a table, a folder, a spreadsheet — as one isolated run per row. Each carries its own history, latency, and cost, so “which invoices did it touch and what did it do to them” is a question with an answer.

Runs that survive waiting

A workflow can park on a human approval or a long-running operation for hours and resume where it left off instead of timing out. Every reasoning step references a named, versioned agent — no anonymous prompt buried in a graph that nobody owns.

Read-only until you say otherwise

Every integration can run in Sandbox Mode: the vendor's own test environment, a stateful simulator that never leaves the platform, or read-through, where reads hit the live system and writes are captured instead of sent. Watch a month of what it would have posted before it's allowed to post anything.

When it isn't sure

Exceptions stop being a queue and start being a question.

Per action, you decide what it does alone: handle it, ask first, or just tell someone afterwards. Post the credit under a hundred, ask before anything touches a contract term, and never pay a new vendor without a signature. What it can't clear goes to the person who owns that call rather than accumulating for Friday.

Approval gates on the actions that move money, each pausing the run with a full audit trail

Timeouts and a fallback ladder, so an invoice never sits waiting on one controller being at their desk

Tag each run with the entity or business unit it served, and get cost, error rate, and p95 split per entity

Systems

It works where the invoice already lives.

Prebuilt tools for the systems your finance stack runs on — plus your own REST endpoints imported from an OpenAPI spec, and direct access to your databases when the catalog doesn't cover it.