For any CFO or controller who has lived through a month-end close, intercompany reconciliation is the recurring nightmare that never quite goes away. The friction is relentless: subsidiary ledgers that don’t match, transfer pricing adjustments that land days after the close, intercompany loans with mismatched interest accruals, and the endless email chains between entities trying to agree on a single number. Every quarter, your team burns hundreds of hours manually matching invoices, chasing missing supporting documents, and building spreadsheets that are obsolete by the time they are reviewed. The pain is not just the time—it is the risk. A single unreconciled balance can delay the audit, trigger a restatement, or hide a real operational issue.
Claude Code, Anthropic’s agentic coding and automation tool, changes this dynamic fundamentally. Instead of asking a human analyst to painstakingly compare two ledgers row by row, Claude Code can read both files, apply your matching rules, flag exceptions, and generate a reconciliation report with explanations—all in minutes. It does not just find differences; it understands the context. It can distinguish between a timing difference (invoice in transit) and a true error (duplicate entry). It can draft the journal entries needed to clear the balance. And it can do this across dozens of entity pairs, every single month, without fatigue.
The key insight is that intercompany reconciliation is not a math problem—it is a language and logic problem. The numbers are straightforward. The difficulty lies in interpreting the metadata: which cost center code maps to which entity, which intercompany agreement governs a particular transaction, which FX rate was supposed to be applied. Claude Code excels at parsing this unstructured context and applying your specific business rules. The result is a reconciliation process that is faster, more consistent, and auditable, freeing your team to focus on the exceptions that actually require human judgment.
Why Traditional Automation Falls Short
Most ERP systems have built-in reconciliation modules, but they are rigid. They require perfect data entry, identical account codes, and a level of discipline that rarely exists across multiple legal entities. Blackline and similar tools are powerful but expensive and still require significant manual configuration. Spreadsheet macros are brittle—one change in the source file format breaks everything. Claude Code sits on top of your existing data, regardless of its messiness. It can handle inconsistent naming conventions, missing fields, and PDF statements alongside Excel exports. It adapts to your process, not the other way around.
The practical application is straightforward. You export your subsidiary and parent ledgers, upload them to Claude Code, and provide a prompt that specifies your matching criteria and reporting format. Claude Code reads the files, performs the analysis, and produces a detailed output. For teams that want to operationalize this, the prompt below is a proven starting point. It is designed to be copied, modified, and run immediately.
First, read these files completely before responding:
[subsidiary_ledger.csv] — Contains all intercompany transactions recorded by the subsidiary, including date, invoice number, description, amount in local currency, and FX rate applied.
[parent_ledger.csv] — Contains all intercompany transactions recorded by the parent, including date, invoice number, description, amount in functional currency, and settlement status.
[intercompany_agreement.pdf] — The signed master agreement governing pricing, payment terms, and dispute resolution between the two entities.
[fx_rates.xlsx] — The daily exchange rates used for the period, sourced from the central treasury system.
Here is a reference for what I want to achieve:
A reconciliation report similar to the one my team previously prepared manually, which listed unmatched items by aging bucket, showed net settlement amounts, and included a summary of root causes for each variance.
Here’s what makes this reference work:
The report groups variances into three categories: (1) timing differences under 30 days, (2) FX revaluation mismatches, and (3) true errors requiring correction. Each line item includes the original transaction date, invoice reference, and a plain-language explanation of the discrepancy.
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: A structured markdown report, maximum 3 pages, with a summary table first, then detailed variance list, then proposed journal entries.
Recipient’s reaction: The controller can review and approve the adjustments in under 30 minutes without needing to open the source files.
Does NOT sound like: A generic list of differences. It must read like an analyst who understands the business context, not a data dump.
Success means: All variances above [Materiality Threshold] are identified, categorized, and have a proposed adjustment. Zero false positives on timing differences.
My context file contains my standards, constraints, audience. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
The prompt above works because it forces Claude Code to understand the full picture before touching the data. The explicit instruction to ask clarifying questions first is critical—it prevents the model from making assumptions about your materiality threshold or FX method. In practice, you will run this prompt, answer two or three clarifying questions, and then receive a plan. Once you approve the plan, Claude Code executes it and delivers the report.
For teams that have already built a basic reconciliation workflow, the next level of sophistication involves handling the settlement process and dispute tracking. The second prompt below addresses the more complex scenario where balances do not just need to be identified but also cleared, and where disputes require formal documentation. This is the prompt you use when you want to move from “what is the difference” to “how do we fix it and prevent it from recurring.”
Moving from Reconciliation to Resolution
Once you have identified the variances, the real work begins. Clearing intercompany balances requires agreement between entities, approval from both controllers, and proper documentation for tax and audit purposes. This is where Claude Code’s ability to generate draft communications and track action items becomes invaluable. The prompt below structures that entire resolution workflow, turning a reactive process into a proactive one.
First, read these files completely before responding:
[open_balances.csv] — The output from the reconciliation run, listing each disputed item, amount, entity pair, and current status.
[entity_contacts.md] — The list of authorized approvers for each subsidiary, including their email, role, and escalation authority.
[resolution_policy.pdf] — The corporate policy document that defines what constitutes a valid dispute, the approval thresholds, and the documentation required for write-offs.
[prior_resolutions.xlsx] — A log of how similar disputes were resolved in the last 12 months, including the rationale and final treatment.
Here is a reference for what I want to achieve:
The dispute tracker that our internal audit team praised last year, which had a clear status workflow (Open → In Review → Pending Approval → Closed), a column for “Proposed Resolution,” and a “Risk Level” indicator for items requiring CFO attention.
Here’s what makes this reference work:
Each dispute has a one-paragraph narrative explaining the root cause, the proposed fix, and the fallback position if the counterparty disagrees. The risk level is automatically assigned based on amount and aging.
Here’s what I need for my version / SUCCESS BRIEF:
Type of output + length: A markdown action plan with a table of all open items, a draft email for each counterparty, and a summary memo for the CFO.
Recipient’s reaction: The CFO can approve all items in one sitting, and the counterparty controllers can respond without asking clarifying questions.
Does NOT sound like: A generic template. Each email must reference the specific transaction details and the relevant clause from the intercompany agreement.
Success means: Every open item has a proposed resolution with a named owner and a target date. The CFO memo is under 2 pages and highlights only items above [Escalation Threshold].
My context file contains my standards, constraints, audience. Read it fully before starting.
DO NOT start executing yet. Ask clarifying questions first.
Give me your execution plan (5 steps max) before you begin.
When you run this second prompt, Claude Code will generate the dispute tracker, draft the emails to subsidiary controllers, and prepare the CFO memo. The key benefit is consistency—every email follows the same structure, cites the same policy sections, and proposes resolutions that align with prior precedent. This eliminates the ad-hoc, often contradictory communications that slow down the current process.
For your first implementation, start small. Pick one entity pair with a moderate number of transactions. Run the first prompt, review the output, and compare it to what your team produced manually last month. You will likely find that Claude Code catches a few items your team missed. Then, once you trust the output, expand to all entities and consider running it on a weekly cadence rather than monthly. The technology is ready; the only requirement is your willingness to let an AI agent handle the grunt work while your analysts focus on the exceptions that truly need a human brain.
Published on 20 August 2026 on growwithgpt.com