Finance tech hasn't really changed in 20 years. Digitising spreadsheets and pushing offline approvals into a browser application is useful but hardly transformational.

‍

AI agents change that.

‍

Autonomous agents are changing the fundamentals of how software works. They read messy documents, reason across systems, and execute workflows the way an experienced analyst would.

In finance operations, that is a huge unlock.

In this post I will:

• Outline why finance workflows are such a brutal testbed
• Show where AI agents are genuinely strong, and where they are fragile
• Sketch what an actual Finance Agent Platform needs to look like
• Walk through a reconciliation case that a human analyst would dread and an agent can actually handle

‍

The target audience here: Finance Managers, VPs of Finance and CFOs who care less about model architectures and more about close quality, cycle times and headcount constraints.

‍

Why finance workflows are so hard for generic AI Agents and workflow tools

‍

A lot of back office AI decks quietly assume the inputs are nice, structured tables. That is not necessarily the reality.

‍

Typical finance workflows look like this:

• Unstructured data
  • PDFs, scans, emails, screenshots
  • Supplier statements with creative layouts
  • Payment provider exports that change format without warning
• Large, ugly datasets
  • Payment Provider exports with hundreds of thousands of semi-structured rows
  • Invoice summaries with hundreds of line items
  • GL dumps with years of history
• Non standard documents
  • Contracts with custom fee ladders and carve outs
  • One off side letters that materially change economics
  • Marketplace payout reports that do not match invoice logic one to one
• Indirect, circumstantial matching
  • No single ID that ties invoice, PSP transaction and settlement together
  • Need to triangulate by amounts, dates, currencies, users, SKUs
  • Many situations where you can only reach a high confidence hypothesis, not a perfect match
• Multiple data sources involved
  • ERP, PSP dashboards, bank statements, app store reports, contract repositories, ticketing systems
  • None of them designed to talk to each other natively

These are simple problems. They are multi step, investigative tasks and that is exactly where AI agents start to look interesting.

‍

Where AI agents are strong vs where they are fragile

‍

At their core, today’s best AI models are extremely capable reasoning engines with limited working memory and no native integrations.

Understanding that tradeoff is key to designing something useful for finance.

‍

Strengths

‍

1. Handling non standard inputs

Agents are very good at reading weird stuff:

• Invoices that do not match the template
• Contracts written by lawyers who have never seen your chart of accounts
• Payment Service Provider reports that mix English labels, local language fees and internal codes

Pattern recognition and layout understanding are generationally better than what legacy OCR or rule based extraction can do.

‍

2. Deductive reasoning

Agents can follow multi step instructions such as:

For each invoice, try to match against PSP exports. If no direct match exists, search by user, by amount within tolerance, and by date proximity. If still unresolved, propose the most likely explanation and a concrete next action.

This is not simple classification, it is a chain of hypotheses:

• "If X does not match, try Y"
• "If Y and Z conflict, flag an exception rather than forcing a match"
• "If data is missing, recommend which system to query next"

Pretty much that's how an Analyst would think about that.

‍

3. Understanding finance tasks and procedures

With the right prompting agents can internalise:

• Basic accounting logic (debits, credits, accruals, prepaids)
• Policy rules (approval thresholds, materiality, risk tiers)
• Domain specific workflows (PSP reconciliation, vendor statement recs, revenue share calculations)

This makes it realistic to encode your playbooks as agent policies instead of if/else decision trees.

‍

Weaknesses

‍

1. Limited context for large datasets

Models have a finite “context window”: The amount of data they can actively hold in working memory in one go.

Finance blows through that quickly:

• You can't dump a 200k row CSV and a 300 page PDF into the model and say “reconcile this”.
• Naively splitting the data to make it fit loses context and produces inconsistent reasoning.

‍

2. Instruction overload

If you ask an agent to:

Read six documents, understand five policies, reconcile three systems, draft a report, and redesign the chart of accounts

in a single run, quality collapses.

Technically, this is instruction overload: the task surface is too broad for the model to maintain a coherent reasoning process. You get shallow, generic answers rather than deep, investigative work.

‍

3. Being detached from real systems

Out of the box, agents:

• Do not see your Inbox
• Do not connect to your ERP
• Do not push entries into your GL
• Do not post into MS Teams or Slack to collaborate with your team

Without a platform around them, they are powerful but isolated analysts who can only ever say: “Here is what I would do, if I could touch the systems.”

‍

What an optimal Finance AI Agent platform must look like

‍

To make agents actually useful for finance teams, you need more than a model and a chat UI. You need three layers that work together:

1. Data Capture Layer
2. Operations Layer
3. Reporting and Integration Layer

Think of it as designing an operating model around a very smart analyst: you define how work enters, how they process it step by step, and how the outcomes flow back into your systems and reports.

‍

1) Data Capture Layer: giving agents structured eyes

The job of this layer is to normalise messy reality into something agents can query and reason over.

Capture and extract

Agents handle the intake of:

• Invoices
• Purchase orders
• Contracts and side letters
• Bank statements
• PSP exports and app store reports
• Vendor statements

They:

• Read documents in whatever format they arrive
• Extract key fields and line items
• Link them to entities such as suppliers, customers, SKUs, accounts, cost centers

Routing and classification

Routing agents then:

• Decide where each document or record should go
• Tag them by workflow (payables, receivables, revenue share, disputes, etc.)
• Trigger the right operational agents in the next layer

This layer is about data fidelity. If you do not get this right, everything downstream is built on sand.

‍

2) Operations Layer: where actual finance work happens

‍

This is where the platform moves from “copilot that drafts emails” to “agent that actually does finance tasks”.

‍

Matching and reconciliation

Agents here perform tasks such as:

• Matching invoices to POs, GRNs and contracts
• Reconciling PSP settlement data with your invoices and your bank statements
• Checking whether refunds recorded in your system were actually processed at the PSP
• Surfacing missing documents or unexplained balances

They operate against the structured data produced by the capture layer.

‍

Workflow and conditional logic

These agents also orchestrate next steps:

• Apply conditional logic such as:
  • “If all checks pass and amount < 10k, move to auto approval”
  • “If contract and invoice disagree by more than 3 percent, route to finance review”
  • “If refund mismatches are detected, create a ticket for payments ops and attach evidence”
• Collect additional evidence autonomously:
  • Fetching additional exports for specific dates
  • Pulling fee schedules from contracts
  • Checking historical patterns for similar exceptions

The important property:

Agents take instructions and procedures and interact with the Data Capture Layer autonomously, exploring deeper where their reasoning says “this does not add up”.

‍

3) Reporting and Integration Layer: closing the loop

‍

Once work is done, results must leave the Agent world and enter the finance world.

That means:

• ERP and ledger pushes
  • Posting suggested journal entries
  • Updating invoice and payment statuses
  • Tagging disputes and credits
• Reports and spreadsheets
  • Generating reconciliation reports that a controller can review and sign off
  • Exporting exception lists to Excel or Google Sheets when needed
  • Producing management views for close and audit
• Collaboration hooks
  • Summaries and links posted into MS Teams, Slack or email
  • Human in the loop approvals where required by policy

Case study: reconciliation that a human analyst hates and an agent can handle

‍

Consider a very typical but painful situation.

You run a consumer app. Revenue flows through multiple payment service providers (PSPs). For a given period, you want confidence that:

• Every invoice is backed by a real transaction
• Fees match the contract
• Refunds are real and reflected correctly

On the table:

• An invoice summary with hundreds of line items
• PSP exports with thousands of rows across multiple days
• Several contracts with different fee structures and payout timings

A human analyst will:

• Open five systems
• Fight with CSV filters
• Keep a mental model of amounts, users and dates in their head
• Spend hours on edge cases that do not quite match

Here is how an agent inside the platform would tackle it.

‍

Step 1: Build a coherent picture

‍

The agent:

• Pulls the invoice summary and normalises the line items
• Loads the relevant PSP exports for the period plus a window around it
• Parses the contracts and derives fee rules and expected net payouts
• Aligns currencies, timestamps and customer or order identifiers

Now it has a structured graph to reason over.

‍

Step 2: Attempt deterministic matching

‍

For each invoice line, the agent tries the obvious matches:

• Same order id in the PSP export
• Same amount, same currency, within the expected date window
• Same user or account id where available

Where this works, it confirms:

• Gross amount
• Fees according to contract vs actual fees
• Settlement timing vs expectations

Step 3: Investigate exceptions with deeper reasoning

‍

The interesting part is what happens when matching fails or produces contradictions. Examples of insights the agent can surface:

• Missing PSP transaction
  • "Invoice A for user 0144 is for EUR 7.99 and is expected to be processed by Adyen, but there is no corresponding Adyen transaction. There is a Stripe transaction for EUR 7.99 that does not reference our app order id. This suggests a routing or mapping issue between our order system and PSP configuration."
• Refund mismatch
  • "Invoice B is marked as refunded in our system, but the Adyen export only shows a captured payment of EUR 3.56 with no refund record. Amounts match, but the refund flow is missing. Recommended follow up: check Adyen refund transactions and settlement batches for this transaction id, and if no refund exists, escalate to payments ops to reconcile or issue the refund."
• Invoice vs app store status conflict
  • "Invoice C is marked as refunded in the ledger, but the corresponding App Store transaction is still captured. The invoice total matches the App Store gross amount and the PSP fee matches the contract. Recommended action: verify whether a refund was actually initiated at the store. If not, either process the refund or update the invoice status to 'paid' to reflect reality."

These are structured hypotheses about what went wrong and what to do next.

‍

Step 4: Produce auditor friendly output

‍

Finally, the agent produces:

• A reconciliation report:
  • Matched items, mismatches, missing transactions, suspected mapping issues
  • For each exception, a suggested explanation and a concrete next step
• System updates:
  • Suggested journal entries, status updates for invoices, and tagged exceptions

A finance manager can review, spot check, and sign off.

The delta vs today is not that the task suddenly requires zero effort. It is that the bulk of the pattern recognition, cross referencing and explanation drafting is now done by an always on, perfectly consistent analyst.

‍

Why this is a meaningful tech unlock for finance leaders

‍

From a CFO or VP Finance perspective, a Finance Agent Platform is about fundamentally changing the constraints of your operating model.

‍

‍1. Complexity no longer scales linearly with headcount

Today, adding new geographies, PSPs or product lines often means more spreadsheets and more analysts.
Agents let you grow complexity without a one to one growth in manual reconciliation effort.

‍

2. Quality becomes systematic

Right now, many reconciliations and investigations depend on a few people who "know how things really work".
Agents, if designed correctly, encode that reasoning into procedures that are:

• Repeatable
• Inspectable
• Auditable

‍

3. You get a live view of risk

Tight integration into your systems means agents can run continuously:

• Surfacing mismatches before month end
• Flagging fee leakage against contracts in near real time
• Highlighting process failures that would otherwise only appear in an audit

‍

4. Human expertise is used where it matters

You still need humans:

• To define policies and materiality thresholds
• To handle exceptions with commercial or legal nuance
• To design controls and own the results

But instead of going through data work your team is reviewing agent results and focusing on judgment calls.

‍

Where do you start?

‍

If you are a finance leader looking at this, the path is not "replace the team with agents". The path is:

1. Pick one painful, investigative workflow. PSP reconciliation, vendor statement recs or refund audits are perfect candidates.
2. Map the data sources, the playbook your best analyst already follows, and the failure modes.
3. Deploy agents in the three layer model:
   • Capture and normalise all inputs
   • Encode the investigative steps in an operations agent
   • Integrate outputs directly into your ERP, reports and collaboration tools

The tech is now good enough that this is not speculative. What matters is platform design: respecting where AI is strong, compensating for where it is weak, and integrating it deeply into your finance stack.

The finance teams that get this right will close faster, with fewer surprises, while operating more complex businesses than their peers can support.

That is the real unlock.

‍