TL;DR for operators
Financial AI becomes consequential when it recommends which invoices to pay, how much cash to retain, or which collections to prioritize. Access to ERP records does not automatically make those recommendations correct.
- Architectural contribution: A proposed three-engine system assigns financial records and relationships to a knowledge graph, constrained calculations to an optimization engine, and request interpretation and explanation to specialized LLM agents.
- Operational mechanism: Context engineering selects the relevant entities, historical states, permissions, business constraints, computational steps, and validation checks for each financial question. A separate validation process checks generated claims against structured evidence and solver outputs.
- Production observations: Across 15 selected deployments, the authors report approximately 7–9% unsupported recommendations in early single-agent reviews versus roughly 1% in later graph-backed production reviews. Deployment duration also declined from approximately six to two weeks.
- Evidence boundary: These are uncontrolled observational comparisons, not estimates of the architecture’s independent causal effect. The paper does not establish financial returns or universal reliability.
- Implementation priority: For decision-bearing financial workflows, invest in source normalization, temporal validity, explicit optimization constraints, claim-level verification, and reproducible audit trails before expanding agent autonomy.
A plausible payment schedule can still be wrong
A finance manager asks an AI assistant which supplier invoices should be paid this week while preserving enough cash for payroll and other commitments.
The assistant produces an orderly payment schedule. It identifies vendors, explains discount opportunities, and estimates the remaining cash balance. The language sounds convincing. But the recommendation is only useful if the invoices exist, their amounts and due dates are current, the cash reserve is correctly represented, and every recommended payment fits the actual constraints.
In an evaluation of approximately 500 early single-agent financial recommendations, researchers identified 36–43 responses containing at least one unsupported financial claim. Problems included fabricated invoices, invented discounts, incorrect totals, stale dates, and violations of cash constraints.
These observations appear in Beyond LLM Wrappers: Context Engineering and the Three-Engine Architecture for Reliable Financial AI, by Pradeep Kumar GS and Ravi Tanniru.1
The failures matter because they arise at different points in a financial decision. Retrieving the wrong invoice, omitting a reserve requirement, calculating an incorrect total, and inventing an explanation are not interchangeable errors. Each demands a different control.
An ERP-connected chatbot can reduce some information-access problems. It does not, by itself, establish a reliable process for converting financial records into executable decisions.
Three engines assign responsibility for financial decisions
The proposed architecture separates functions that a conventional LLM application may attempt to handle within one generation process.
An invoice belongs to a vendor, carries payment terms, changes status over time, and originates from a particular source record. Those connections must remain available even when the user asks a different question or a later update changes the underlying balance.
The first engine, a financial knowledge graph, maintains these relationships, historical states, source identifiers, synchronization metadata, and transformation provenance.
The second engine, deterministic optimization, calculates decisions using explicit objectives and constraints. A payment scheduler might seek to capture available discounts while respecting cash limits, payroll reserves, and payment deadlines. OR-Tools is the primary solver identified in the reported deployments.
The third engine comprises specialized LLM agents responsible for understanding requests, coordinating tools, generating explanations, and validating claims. The deployments primarily used Gemini as the LLM provider, although other models were evaluated without detailed comparative results.
| Component | Primary responsibility | Failure it is intended to address |
|---|---|---|
| Financial knowledge graph | Preserve entities, relationships, historical state, and provenance | Incorrect or untraceable financial context |
| Optimization engine | Compute reproducible decisions under explicit constraints | Unreliable arithmetic or infeasible recommendations |
| Specialized LLM agents | Interpret requests, orchestrate execution, explain and validate results | Unsupported interpretation or explanation |
| Context-engineering layer | Assemble evidence and determine the execution and validation sequence | Missing, stale, irrelevant, or improperly scoped context |
This is a systems-integration architecture, not a new optimization algorithm or a fundamentally new knowledge-graph technique.
Its central architectural argument is that financial records, calculations, and generated explanations should have distinguishable sources of authority.
A language model can explain why an invoice was selected. It should not be the authoritative source of the invoice amount or the mechanism that establishes whether the payment schedule is feasible.
Context engineering decides what the calculation needs
Separating components creates another problem: deciding which components should be used, with which information, for a particular request.
The paper calls this financial context engineering.
Conventional retrieval-augmented generation typically emphasizes finding information relevant to a user query. Financial context engineering has a broader responsibility. It must select financial evidence and construct the execution plan required to answer the question.
For a payment-scheduling request, that process involves resolving the correct vendors and invoices, selecting the appropriate time window, checking authorization, retrieving current balances and relevant historical states, determining applicable constraints, and preparing inputs for optimization.
The output is therefore more than text placed into a prompt. It is a structured context package accompanied by a sequence of computational and validation operations.
Consider a vendor with several invoices. One record may have been partially paid, another may contain a disputed amount, and a third may offer an early-payment discount. Retrieving all three invoices is insufficient if the system cannot determine their present status and relevant relationships.
Likewise, including a payroll reserve in a retrieved document is not equivalent to enforcing that reserve as an optimization constraint.
The context layer must translate relevant evidence into the financial decision process without losing its source identity, temporal meaning, or authorization boundaries.
The paper presents this selection problem conceptually in Section 4, but does not provide a complete mathematical optimization formulation for context engineering.
That distinction matters for implementation: the architecture identifies the necessary coordination responsibilities without supplying a fully specified algorithm for resolving every context-selection trade-off.
Production observations show fewer unsupported claims reaching users
The empirical foundation consists of 15 production deployments selected from a client base exceeding 150 over approximately 11 months.
The deployments covered manufacturing, SaaS, services, e-commerce, and trading businesses, with ERP integrations including Zoho, Tally, QuickBooks, and Acumatica. Operational optimization queries typically involved 50–500 invoices, while tenant knowledge graphs ranged from tens of thousands to more than one million nodes.
The primary quantitative comparison concerns recommendations containing at least one unsupported financial claim.
| Observational measure | Early configuration | Later configuration |
|---|---|---|
| System approach | Single-agent pipelines | Graph-backed multi-agent validation |
| Evaluated recommendations | Approximately 500 | Equivalent labeled review |
| Unsupported recommendations | Approximately 36–43 | Approximately 4–5 |
| Approximate response-level rate | 7–9% | 0.8–1.0% |
Source: Section 6, production observations. The paper describes the later rate as below 1%; because 5 out of 500 equals exactly 1%, the reported bound should be understood as approximate.
The metric concerns unsupported claims reaching users, not every incorrect statement produced internally. A validation process could reject an erroneous intermediate response without that error appearing in the reported user-facing rate.
The observed difference is substantial. It is also not a controlled comparison.
The deployments were selected partly for readiness and data availability. Over time, prompts, models, integrations, validation checks, data pipelines, and engineering practices evolved together. No component-level ablation isolates the effects of the knowledge graph, optimization engine, multi-agent decomposition, or validation.
Consequently, the results describe an association between successive production configurations and fewer unsupported recommendations. They do not establish how much of the improvement any individual component caused.
The authors also report deployment duration declining from roughly six weeks for early tenants to approximately two weeks for later tenants. Reusable ERP mappings, graph templates, validation patterns, and context policies accumulated during implementation.
This is descriptive deployment evidence, not a measured return on investment or a controlled estimate of the savings attributable to template reuse.
Reliable validation requires a trustworthy source of truth
The production observations identify a recurring implementation constraint: substantial engineering effort was consumed by ERP normalization and data-quality problems.
Duplicate entities, inconsistent payment terms, missing fields, incorrect mappings, and delayed synchronization affect the information available to every downstream engine.
A knowledge graph can retain source lineage and temporal relationships. It cannot independently repair missing financial truth.
Similarly, deterministic optimization guarantees reproducibility for a specified computation, not the correctness of the business objective or its inputs. If a payroll reserve is omitted, a solver may return a mathematically feasible schedule that violates the organization’s actual liquidity requirements.
This is why the paper’s validation approach extends beyond asking another LLM whether an answer looks reasonable.
Its specialized validation process checks claims against source entities, numerical outputs, timestamps, financial constraints, policies, and solver results. Execution traces connect request interpretation, entity resolution, retrieved evidence, solver inputs, calculated outputs, and final explanations.
These traces also improve diagnosis. An incorrect recommendation can be investigated as a source-data error, context-selection error, constraint-specification error, solver-input problem, or unsupported explanation.
However, the paper does not provide complete formal specifications of graph schemas, optimization formulations, or validation rules. Nor does it establish standardized metrics for context completeness, freshness, or minimality.
What an accounts-payable deployment should measure
For an accounts-payable team considering decision-support automation, Cognaptus infers a practical implementation sequence from the architecture.
Begin with normalized invoices, vendors, payment terms, balances, and timestamps. Establish entity-resolution and synchronization controls before relying on generated financial recommendations.
Next, express payment objectives and constraints explicitly. The optimization process should return a feasible schedule together with the assumptions and source-linked information needed to reconstruct it.
Finally, validate each user-facing recommendation against the records and computed outputs that supposedly support it. Ambiguous entities, stale balances, unsupported claims, and infeasible schedules should trigger blocking or escalation rather than an unqualified payment instruction.
Evaluation should track several distinct outcomes: user-facing unsupported-claim rates, entity-resolution failures, stale-context usage, solver feasibility, validation failures, audit-trace completeness, implementation effort, and actual financial results such as realized discounts or avoided errors.
This approach is most defensible where recommendations depend on multiple connected financial records and binding operational constraints.
For a low-stakes summary of a financial document, the full multi-engine architecture may introduce costs without corresponding value.
The remaining boundary is operational, not rhetorical
The paper establishes a credible production-grounded architecture and identifies recurring engineering problems. It does not establish independent reproducibility, causal reliability gains, or systematic monetary benefits.
Customer data and operational traces are private. Sampling and model-configuration details are incomplete, and no public benchmark reproduces the reported comparisons. The selected deployments also do not demonstrate generalizability to banks, microbusinesses, or organizations with substantially different data maturity.
A multi-engine system introduces additional latency, integration, security, and maintenance responsibilities. Authorization-aware retrieval, cross-tenant isolation, sensitive audit logs, and model-provider exposure require controls that architectural diagrams alone cannot certify.
For financial AI builders, the central contribution is a clearer allocation of responsibility. Enterprise records establish financial facts; optimization establishes computational feasibility; agents handle interaction and explanation; context engineering coordinates the process; and validation determines which claims can safely reach users.
The reported production experience makes this architecture worth evaluating for consequential financial workflows. Its reliability must still be demonstrated against each organization’s own data, constraints, decision processes, and economic outcomes.
Cognaptus: Automate the Present, Incubate the Future.
-
Pradeep Kumar GS and Ravi Tanniru (2026). Beyond LLM Wrappers: Context Engineering and the Three-Engine Architecture for Reliable Financial AI. arXiv:2610.39230. https://arxiv.org/abs/2610.39230 ↩︎