From "Govern Any AI Agent" to "Every Invoice Checked": Why We Pivoted

Our original pitch was clean and abstract:

from pliuz import gated

@gated(policy="big-payment-veto")
def send_payment(amount, recipient):
    return bank.transfer(amount, recipient)

Any tool call, any agent, any framework. LangGraph, CrewAI, Vercel AI SDK, custom Python — wrap it with @gated, attach a policy, and every high-risk action goes through a human approval gate before it executes. The policy engine is deterministic (JSONLogic, 14 operators, no eval, no exec). The audit trail is tamper-evident (SHA-256 hash chain, Ed25519 signed export). The SDKs are open-source (Apache 2.0, pip install).

It was a good product. It solved a real problem — for the 5% of companies that already had AI agents in production and were worried about control. The other 95% were not there yet. They were not searching for "agent governance" because they did not have agents to govern. And the ones who did have agents were not yet willing to pay for governance — they were still trying to ship features.

We talked to CTOs, Heads of AI, and platform engineers. The feedback was consistent: "This is cool. We will need it eventually. Come back in six months."

The shift started when we stopped talking to CTOs and started talking to CFOs and Heads of Finance. The conversations were completely different:

• "How many invoices are exceptions?" — 15-25%. Every company, every industry, every size.
• "What does an exception cost you?" — €13-26 per invoice in manual processing time. Plus the cost of the ones they miss.
• "Do you check if the IBAN changed?" — Silence. Then: "No. Should we?"
• "Do you aggregate invoices per supplier per day?" — More silence.
• "What happens when an auditor asks how you control AI in finance?" — "We have a policy document." Not a technical control. A PDF.

These were not hypothetical problems. These were problems people were living with today, could quantify in euros, and were under regulatory pressure to address. The EU AI Act (Article 14, human oversight; Article 12, record-keeping) is enforceable from August 2026. E-invoicing mandates are rolling out across the EU through 2028. Verifactu (chain-of-records) is live in Spain.

And nobody was selling them a solution. The ERPs handle the 85% that works. The 15% that does not work — the exceptions, the fraud, the blind spots — was being handled with spreadsheets, email chains, and hope.

The realization was simple: we already had the engine. A deterministic policy engine that evaluates signals and routes to human approval. A Slack integration that delivers interactive cards. A tamper-evident audit trail. Open-source SDKs. The infrastructure was built — we just needed to load it with the right policies.

So we wrote four AP-specific signals:

• dup_score — document hash (NIF + invoice number + amount + date). Exact match = 1.0. Fuzzy match scored 0.8-0.95.
• iban_changed — normalized IBAN comparison against supplier master data. Boolean.
• splitting_window — rolling 24-hour sum per supplier (by tax ID). Flagged when total crosses a configurable threshold. This is the approval laundering signal.
• low_confidence — OCR confidence score. Below threshold = force human review, never auto-approve.

And six policy templates: duplicate detection (auto-reject exact, notify fuzzy), IBAN review (notify, never auto-approve), splitting window (notify), PO variance (notify), low confidence (notify), and small-clean-autoapprove (auto-approve invoices under a threshold with no signals).

The pivot took two weeks of engineering. Not because the product changed — because the policies, the demo, and the messaging had to be rebuilt for a finance audience instead of a platform engineering audience.

Everything that matters:

• Policy engine — JSONLogic, 14 operators, deterministic. No LLM in the critical path. Same engine that gates any agent action, now pre-loaded with AP signals.
• Slack integration — interactive cards with Approve / Edit / Reject. IBAN redacted in the card body (GDPR + antifraud). Same OAuth flow, same retry logic.
• Audit trail — SHA-256 hash chain, Ed25519 signed export, pliuz_verify_chain() SQL function. Verifiable offline by an auditor without depending on us.
• SDKs — Python and TypeScript, Apache 2.0, open-source. Still general-purpose — @gated still gates any function call.
• Infrastructure — Supabase (Frankfurt, EU-hosted), RLS on every table, AES-256-GCM field-level encryption, service-role key isolation.

The horizontal product is not dead. A team that wants to gate a customer support agent's refund authority, or a DevOps agent's deployment action, can still use the SDKs and write their own policies. But our go-to-market — our demo, our content, our outbound — now focuses on the invoice exception use case. Because that is where the pain is, and that is where the buyer is.

Three lessons for other founders considering a similar pivot:

1. If nobody searches for your category, you do not have a category. You have a solution looking for a problem. "AI governance" is a term that vendors use, not buyers. Buyers search for "invoice fraud detection," "duplicate payment prevention," "IBAN verification." Meet them where they are searching.

2. The best vertical is universal, quantifiable, and urgent. Every company processes invoices (universal). The cost of exceptions is measurable in euros (quantifiable). And regulatory deadlines — e-invoicing, EU AI Act, Verifactu — create a clock that forces action (urgent). If your vertical is missing one of these three, the sales cycle will be long.

3. A pivot does not mean throwing away your product. It means pointing the same product at a problem people will pay to solve today, not one they might pay to prevent tomorrow. The hardest part of our pivot was not engineering — it was admitting that the horizontal thesis was not working and that we needed to change the story we were telling, even though the product was already good.

We are now an Invoice Exception Agent. We review every supplier invoice, detect four deterministic signals, route the exceptions to a human via Slack, and record every decision in a tamper-evident audit trail. The 85% of invoices that match expectations are auto-approved. The 15% that do not are the ones that cost money — and the ones we catch.

The horizontal SDKs are still there, still open-source, still general-purpose. But if you ask us what Pliuz does, the answer is not "we govern AI agents." The answer is: "we make sure you never pay an invoice you should not have paid — and we can prove it to your auditor."

That is a problem people will pay to solve today. And that makes all the difference.