Agentic AI for accounting: 3 problems RPA never solved
Published on :
May 25, 2026
Nicolas Marchais is co-founder and CEO of Phacet. After seven years at Spendesk, he built Phacet as the agentic layer that orchestrates across ERP, banking and email systems. Reliable, auditable, cross-system, what he calls a Finance Workforce.
Most accounting teams that adopted RPA between 2018 and 2024 hit the same wall around year two. The scripts work brilliantly on the 70% of invoices that arrive in a clean predictable format. They break silently on the 30% that don't. A vendor name with a typo. A cost center label that drifted. A bank reconciliation where the reference field was empty. Each exception triggers a manual review, and after enough exceptions, the controller is doing 80% of the work the RPA was supposed to eliminate.
This is not a failure of execution. RPA was designed for a specific class of problem (repetitive deterministic tasks on structured inputs) and it solves that class well. The accounting workload that broke RPA is the part that requires reasoning about variability, jumping across systems, or producing an audit trail a CPA can defend. According to Informatica's enterprise agentic automation analysis, Gartner expects over 60% of AI projects to miss their business SLAs through 2026 due to lack of AI-ready data practice. The number is a symptom: most accounting teams are bolting AI tools onto pipelines that were never restructured to use them.
Agentic AI for accounting does not replace your RPA. It sits on top of it, covering the three categories of work where RPA structurally cannot reach: semantic variability, cross-system orchestration, and native audit trail. This article maps each of those three gaps, the work patterns where they show up in an accounting team, and the architectural shift that closes them. The broader trajectory of this transition is documented in our AI agents accounting automation 2026 analysis.
Why "Agentic AI" is not just RPA with a smarter engine
A common framing in vendor marketing positions agentic AI as the next generation of RPA: same pipeline, smarter brain. The framing is misleading. Agentic AI changes what kind of work can be automated, not just how fast the same work runs.
An AI agent is a specialized software entity with a defined goal, the ability to act across multiple systems, and a structured way to expose its reasoning. It does not just follow a script. It reads context, applies judgment within a confidence threshold, and surfaces its work for human review when the threshold is not met. The architecture is fundamentally different from RPA in three ways that matter for accounting. The distinction matters in practice: an intelligent agent is not an SaaS application with AI features bolted on, it is a different category of software.
RPA executes instructions. Agents execute intent. An RPA script told to "fetch the invoice number from cell B7 of the email body" will fail when the email body changes layout. An agent told to "find the invoice number" will read the document, recognize it, extract it, and proceed even if the layout is new.
RPA runs inside one system. Agents act across systems. An RPA bot processing invoices in your AP tool will not check whether the supplier's URSSAF certificate has expired in the vendor master, validate the IBAN against the contract, or cross-reference the amount against the original purchase order. An agent that owns the "approve an invoice" job will do all of those things in one operation.
RPA produces logs. Agents produce audit trails. An RPA execution log says "step 14 succeeded at 10:32:17." A native audit trail says "this invoice was matched to PO 2026-0451 with 94% confidence based on supplier name, line items, and amount; the 6% uncertainty came from a single line description mismatch; the agent flagged it for review; the controller approved it at 10:32." The first satisfies a sysadmin. The second satisfies an auditor.
This is what distinguishes an agentic platform from a script library. The platform makes the agents trustworthy in production through shared data, observability, audit trail, human-in-the-loop controls, and fallback mechanisms.
Problem 1: semantic variability (where RPA silently fails)
The first gap is the most operationally visible. A supplier called "Acme Logistics SARL" on the invoice header, "ACME LOGISTICS" in the bank statement, and "Acme Log." in the email subject is the same supplier to a human accountant. To an RPA script, they are three different strings that fail an exact-match condition.
The accounting team learns to live with this. The reconciliation routine flags the three records as unmatched. A junior pulls each one up, recognizes the pattern, and manually unifies them. By the end of the month, the team has done thousands of these recognitions, each one fast, each one mundane, and collectively responsible for the bulk of the reconciliation backlog.
Agentic AI closes this gap because semantic matching is what large language models do natively. The supplier billing control agent recognizes that "Acme Logistics SARL" and "ACME LOGISTICS" are the same supplier without being explicitly told. The bank reconciliation agent matches a payment in the bank statement to an outstanding invoice in the ERP even when the reference fields don't align exactly. The standardize and reclassify agent maintains consistent coding across a portfolio of clients even when the source data drifts.
Astotel - 18 hotels, line-by-line variance detection
Line-by-line price variance checks recovered 5,000 euros per year on a single supplier. The variance only became visible because the agent could recognize the same product across invoices that used slightly different labels. The errors were always there. RPA could not see them because the labels varied across the dataset. The agent could.
"Je gagne jusqu'à deux jours par mois, et je repère des erreurs que je n'aurais jamais vues seule." -- Valérie, Directrice Achats
This is the single largest source of operational lift when an accounting team moves beyond RPA. The work that used to require human pattern recognition (the 30% of invoices that broke the script) becomes work the agent handles, with exceptions surfaced for human review.
Problem 2: cross-system orchestration (where RPA stops at the border)
The second gap is architectural. Accounting work crosses systems by design. A single invoice approval requires touching the AP tool (the invoice), the ERP (the purchase order), the bank (the supplier IBAN), the vendor master (compliance certificates), the contract repository (negotiated rates), and sometimes the email inbox (the original supplier communication). Each system holds part of the truth.
RPA architecture is intra-system. A bot lives inside a single application and automates the human actions inside that application. Crossing to another system requires either an API integration (which doesn't always exist), a second bot in the second system (which doubles the maintenance), or a brittle browser-based screen scrape that breaks when the UI changes. Most accounting teams that started with RPA ended up with a portfolio of bots that each handled a slice of a workflow, and a controller stitching the slices together by hand.
Agentic AI closes this gap because agents are designed to act across systems natively. The accounting inbox agent reads the email, extracts the invoice, queries the ERP for the matching PO, checks the contract for the negotiated rate, validates the IBAN against the vendor master, and routes the result. All in one operation. No human stitching.
The architectural reason this matters: agentic platforms are positioned over the existing stack rather than inside one tool. Phacet specifically operates as a layer that orchestrates between the systems already in place (Pennylane, Sage, NetSuite, Yooz, Qonto, BNP, etc.) rather than as a replacement for any of them. A migration to a new ERP costs hundreds of thousands of euros. An orchestration layer added on top ships in weeks.
The cross-system pattern is also what makes agentic platforms genuinely different from a generic AI assistant like ChatGPT or Claude. The assistants are smart on a single query. They are not connected to your finance stack, do not produce audit trails, and the data you give them may be used to train the next version of the model. An agentic platform handles all three.
Problem 3: native audit trail (where RPA logs are not enough)
The third gap is the one that auditors and compliance officers care about. RPA produces execution logs: a list of steps, timestamps, success or failure flags. The logs are useful for system administrators debugging a script. They are not useful for a CPA defending the books to an auditor, an internal audit team running a SOX walkthrough, or a controller answering "why did this invoice get approved?"
A defensible audit trail captures not just what happened but why it happened: the inputs the system considered, the comparison it ran, the threshold it applied, the confidence score it produced, the human who reviewed it, the override (if any) and its justification. This level of explainability is structurally outside what RPA produces, because RPA does not reason. It just executes.
The native audit trail is what makes agentic platforms defensible in regulated contexts. Every agent action (every extraction, every match, every flag, every routing decision) is timestamped, stored, and inspectable in the Vue Détail per record. A CPA can open any invoice and see the full reasoning chain. An auditor can run a sample of 50 transactions and verify each one in seconds. The compliance officer for SOX, French Loi Sapin II, RGPD, ISO 27001, or sector-specific accounting standards has the evidence trail they need without manual reconstruction.
For a finance function under regulatory pressure, this is the criterion that takes agentic AI from "interesting upgrade" to "non-negotiable architecture." It is also what distinguishes purpose-built finance platforms from generalist AI assistants, which produce remarkable answers but no audit trail at all.
What accounting work looks like when the 3 gaps are closed
A practical view of an accounting workflow that has moved beyond RPA to agentic execution:
This is not faster RPA. It is a different workflow architecture, where the agent does the work the controller used to do, and the controller does the work the agent cannot (judgment on the genuinely ambiguous cases). The pattern in production at Phacet customers: 38% of projects in production are control and reliability agents. That is the moat, and that is where the operating model shifts. The full picture of this transition is mapped in our autonomous finance team analysis.
How to decide which processes to move first
A common question from accounting teams considering the shift: which processes do we migrate first? The decision framework has three filters.
Filter 1: Variability of inputs. Processes that handle highly structured, stable inputs (a fixed monthly payroll posting, a recurring rent payment) work fine in RPA and do not benefit much from migration. Processes with high input variability (supplier invoices, expense reports, bank transactions, multi-client portfolios) are where agentic AI delivers immediate lift. Start there.
Filter 2: Cross-system span. Processes contained inside one system (a journal entry posted from a template) are RPA-friendly. Processes that span systems (an invoice that requires PO matching, vendor master validation, and contract verification) are agent territory. Migrate the cross-system processes first.
Filter 3: Audit pressure. Processes that the auditor reviews in detail (revenue recognition, intercompany flows, period-end accruals) benefit from native audit trails. Processes that are operational and rarely audited can stay in RPA. Move the audit-heavy processes first because the audit trail is where the value compounds.
Combining the three filters: supplier invoice processing, bank reconciliation, multi-client recategorization, intercompany matching, and contract-driven billing controls are the typical first migrations. Payroll postings, recurring rent, and templated journal entries can stay in RPA.
CPA -- French accounting firm
CPA deployed the platform progressively without ripping out their existing tooling. The firm now operates with a new revenue line built around the deployment and 2 to 4 points of margin gained that they communicate to their own clients. CPA did not replace their stack. They added an orchestration layer where the gaps were.
"C'est comme un tableau Excel dopé à l'IA. On n'est pas dépaysés." -- Romain Joussellin, partner at CPA
How Phacet agents make this architecture concrete
Phacet operates as a catalog of 40+ specialized agents for finance work, built across 100+ real customer deployments. Each agent follows the same structure: it structures the input (extracts and normalizes data from emails, ERPs, contracts, bank feeds), controls against a reference (vendor master, contracts, prior periods, budgets), and exposes its reasoning with a confidence score. Every step is timestamped in a native audit trail. The combination makes the work reliable, controllable, and auditable by design.
The agents most relevant to a team moving beyond RPA:
- The accounting inbox agent replaces the RPA email triage that consistently failed on layout variation.
- The supplier billing control agent does the line-by-line price variance check that RPA could not do because the line descriptions varied across invoices.
- The bank reconciliation agent handles the semantic matching that RPA exact-match rules cannot.
- The standardize and reclassify agent enforces consistent coding across portfolios where RPA scripts had to be rewritten for each client.
Each agent surfaces its results in Tables (a tabular view where each row is a transaction with its source documents, extracted fields, confidence indicator, and audit history). When an agent is below threshold, the AI Match component surfaces the proposed match with its reasoning in the Vue Détail. The 40+ agents in the catalog were built on 100+ real customer deployments -- they reflect the patterns that broke RPA in real accounting teams, not features designed for a feature page.
The first agent goes into production in under two weeks. The full beyond-RPA migration (semantic variability, cross-system orchestration, native audit trail) typically takes one to three quarters depending on the existing stack and the cleanliness of the master data. Phacet does not require ripping out RPA. The two coexist: RPA handles the deterministic patterns it was designed for, and agents handle the patterns that broke it.
Why most "AI Accounting" projects still underdeliver
The Informatica analysis citing Gartner reports that over 60% of AI projects will miss business SLAs through 2026, and 97% of GenAI adopters struggle to prove business value. The pattern is consistent across surveys: AI adoption is fast, AI value capture is slow.
Three structural reasons explain the gap, and all three are accentuated in accounting:
The data is not AI-ready. An accounting team's chart of accounts, vendor master, and historical coding are full of inconsistencies that the team has worked around manually for years. An AI agent inherits those inconsistencies unless the underlying data is cleaned. The standardize and reclassify agent addresses this specifically, but it has to run before or alongside the other agents, not after.
The workflow is not redesigned. Most teams deploy AI on top of the existing workflow. The agent runs faster but produces the same output pattern, which means the team still does the same handoffs and reviews. The lift comes from redesigning the workflow around the agent (the controller reviews exceptions, not transactions), not from adding the agent to the existing flow.
The audit trail is treated as an afterthought. Teams discover during their first audit that their AI tool does not produce a defensible trail. They retrofit the trail, which is expensive and incomplete. Native audit trail from day one is what makes the project sustainable beyond the pilot.
The teams that get past the 60% failure rate solve all three: AI-ready data, redesigned workflow, native audit trail. This is the operating-model change that distinguishes a successful agentic AI deployment from another tool added to the stack.
FAQ
What is agentic AI for accounting in one sentence?
Agentic AI for accounting is the use of specialized AI agents that act across the systems an accounting team already uses (ERP, banking, email, contracts), each owning a defined job, exposing its reasoning, and producing a native audit trail. It is distinct from RPA (which executes scripts in a single system) and from generalist AI assistants (which give answers but do not connect to finance systems or produce audit trails). See our AI agent glossary entry for the building-block definition.
How is agentic AI different from RPA in accounting work?
RPA executes deterministic scripts on structured inputs in a single system. It works for 70% of routine accounting work and breaks on the 30% with semantic variability, cross-system span, or audit complexity. Agentic AI handles the semantic and contextual layer (matching when descriptions vary, reasoning when context shifts, orchestrating across systems), with a native audit trail RPA does not produce. The two are complementary: RPA stays for deterministic processes, agents take over where RPA broke. Our beyond RPA analysis breaks down the architectural differences in more detail.
Do I have to rip out my existing RPA to deploy agentic AI?
No. Agentic AI sits on top of the existing stack as an orchestration layer. Phacet specifically operates as a catalog of agents that integrate with the systems already in place (Pennylane, Sage, NetSuite, Yooz, Qonto, BNP, etc.) rather than as a replacement. RPA continues to handle the deterministic patterns it was designed for. Agents handle the semantic and cross-system patterns that broke RPA.
Which accounting processes should I migrate first?
Three filters guide the decision. First, processes with high input variability (supplier invoices, expense reports, bank reconciliation) benefit most. Second, processes that span multiple systems (an invoice that requires PO, contract, and vendor master checks) are agent territory. Third, processes the auditor reviews in detail benefit from native audit trails. The typical first migrations: supplier invoice processing, bank reconciliation, multi-client recategorization, intercompany matching.
How long does an agentic AI deployment take for an accounting team?
The first Phacet agent is in production in under two weeks. A meaningful coverage of the three RPA gaps (semantic, cross-system, audit) typically takes one to three quarters, depending on the existing stack and the cleanliness of the underlying data. The pace is not limited by the agents themselves but by the upstream data quality and workflow redesign work. Teams that have invested in clean master data deploy faster.
Is agentic AI more risky than RPA from a compliance standpoint?
Properly deployed, it is less risky. RPA produces execution logs that are not audit-grade. Agentic AI produces a native audit trail with reasoning, confidence scores, and human review history. For SOX, French Loi Sapin II, RGPD, ISO 27001, and sector-specific accounting standards, the agentic audit trail is what makes the automated work defensible. The risk profile is lower than RPA in regulated contexts, not higher.
The question "agentic AI versus RPA" frames the choice wrong. RPA still works for the deterministic, single-system, low-audit-pressure work it was designed for. Agentic AI does not replace it. It covers the three categories of work that RPA structurally could not reach: semantic variability, cross-system orchestration, and native audit trail. Together, they cover the full range of accounting work that a human controller used to do.
The teams that get the most value from this shift do three things in order. They identify the processes where the three gaps are biting hardest (typically supplier invoices, bank reconciliation, multi-client portfolios). They deploy agents on those processes first, with the existing RPA still running on the deterministic patterns. And they redesign the workflow so the controller's role shifts from processing transactions to reviewing exceptions and owning the policy.
Phacet operates exactly in this layer. The 40+ specialized AI agents cover the semantic, cross-system, and audit-trail-bound work that defines beyond-RPA accounting. Each one is in production at real customers. The first agent ships in under two weeks. The full transition through the three gaps takes one to three quarters. The strategic vision behind this transition is laid out in our agentic revolution in finance automation analysis.
Beyond RPA is not the next generation of automation. It is the work the previous generation could not reach. The teams that get there first will be doing the same accounting work with 38% of their agent portfolio dedicated to control and reliability, which is exactly where the value compounds.
Latest Resources
Unlock your AI potential
Go further with your financial workflows — with AI built around your needs.
