Overdue Invoice Chasing: A Plan-and-Fan-Out Morning Routine That Investigates Before It Acts

The morning pile: why overdue invoices eat your first hour

Every small business owner knows this morning. Seven invoices past their due dates. You pick one customer, open the email thread, remember there's a dispute about a line item, get pulled into a reply, and forty minutes later you have chased exactly one invoice. The pile doesn't shrink — it waits.

The work is slow not because the writing is hard but because the investigation is. Before you can send a reminder you have to answer a question for each customer: did they already pay and I missed the entry? Are they disputing something? Did they ask for the invoice copy again? Are they simply silent? And you answer those questions one customer at a time, because that is how a person works.

Three facts about this job make it a better fit for automation than most owners assume:

• The steps are identical every morning. Pull the overdue list, check each account, decide the nudge, send, log. It is the same loop a business workflow automation routine performs well — no judgment, no memory, no remembering to follow up twice.
• Much of the delay is a document-fetching job. Analysis from OCTA's co-founder, working alongside Careem's finance team, found a recurring reason payments arrived late: customers kept re-asking for invoice copies and statements — a fetching-and-attaching job an agent does in seconds (hackernoon). Note the provenance: that piece is OCTA-distributed and cites OCTA's own customer case study.
• It works in production, not just in theory. Careem automated its accounts-receivable workflow with OCTA — invoice creation, customer follow-ups and replies, and payment matching — and the reported result was 110+ hours a month saved and days sales outstanding down 24% (OCTA, hackernoon). Both figures come from OCTA's own vendor case study, so read them as a vendor-reported outcome, not an independent audit — but they show the job is real and automatable.

But here is the catch: most automation advice for invoice chasing jumps straight to sending. Send a reminder sequence. Trigger the dunning letters. The missing step — and the subject of this post — is investigating before you act. That is where the newest orchestration pattern fits, and it changes the shape of the morning.

Plan and fan out: the new agent pattern behind smarter invoice chasing

Until recently, an "AI agent" meant one model working through a task step by step: read a file, run a command, look at the result, decide what to do next. That works for small jobs. But a wide job — dozens of overdue accounts, each needing its own little investigation — chokes it: the single agent runs out of context, forgets earlier findings, or misses things.

On October 9, 2026, Anthropic shipped its answer to that problem: dynamic workflows for Claude Managed Agents, in public beta. A lead agent writes a plan, distributes the work to sub-agents, and merges the results — one run can start up to 1,000 agents over its life, with up to 64 threads working at once (that 64 is a cap, not a guarantee; the press shorthand of "1,000 in parallel" is loose — the docs give the precise limits) (The Decoder, AI Daily Post, CellCog's docs breakdown, Anthropic's workflow-runs docs).

The idea isn't brand new — it is Anthropic's own research system, productized. Their engineering blog documented a multi-agent research setup where a lead agent decomposes a query, spawns specialist subagents in parallel with their own context windows, then synthesizes their findings (Anthropic, Simon Willison's summary). In Anthropic's internal evaluation on research workloads, the multi-agent setup outperformed a single agent by roughly 90%.

Say that number carefully: it is Anthropic's own internal research eval, not a collections workload, and it does not transfer to invoice chasing. No source in this post's research publishes a 90%-style figure for chasing receivables. This post borrows the pattern, not the number: plan across the whole pile, investigate in parallel, merge. The evidence that the pattern fits comes from the domain, not the benchmark.

Investigate every overdue invoice in parallel, then act

Here is the shape change.

The old morning: one long loop

For each overdue customer: dig through the thread, reconstruct the story, decide what to send, send it, log it, then start over on the next one.

Every account pays the full cost of a context switch.

The new morning: plan, fan out, merge

The new morning separates the job into three phases:

1. Plan: look at the whole overdue pile at once and decide what each account needs checked.
2. Fan out: investigate every account in parallel — did they pay? Is it disputed? Did they ask for the invoice copy? Each account gets its own investigation with its own context.
3. Merge: combine the findings into one owner-ready digest, with a recommended action per account. Only then does anything get sent.

That middle step is the one everyone skips, and it is the step that matters most. A reminder sent to a customer who already paid makes you look careless. A reminder sent into an active dispute makes you look deaf. The investigation is what turns a blast of automated nagging into professional follow-up. Careem's case found the same thing from the other side: their bottleneck was manual, fragmented follow-ups (OCTA) — and fragmentation is exactly what a merge step fixes.

The pattern also respects how SMB receivables actually work:

• Each account's truth is independent. Whether Customer A paid has nothing to do with whether Customer B is disputing a line item. Independent checks run in parallel without tripping over each other — which is why a 10-person business gets more from this than from one smarter single agent.
• The plan is cheap; the investigations are the work. The lead pass over the pile takes minutes and decides per account what to verify. The fan-out is where the hours used to go.
• Nothing acts on partial information. The merge happens before any message is drafted, so a decision is never made from one account's findings alone — the digest shows the whole pile.

The morning receivables routine: a follow-along blueprint

Below is the routine for a 10-person Indian business with, say, five to fifteen overdue accounts. It runs in any capable chat AI (Claude, ChatGPT, or your team's existing assistant) — no developer account needed for the manual version, and the fully automatic version is what the dynamic-workflows pattern on the developer API exists to become. Each step states the action and the expected result.

Step 1 — Pull the overdue list (10 minutes)

Open wherever your invoices live — your accounting tool, a Google Sheet, even a register you keep by hand — and produce one clean list of invoices past their due date and still marked unpaid. This workflow is deliberately accounting-software-neutral: connectors to your specific tool (Tally, Zoho Books, or a plain spreadsheet) are options you or your vendor can add later, not something this post pretends exists out of the box.

Format the list as a simple table. Copy this column layout exactly:

customer | invoice_no | amount | due_date | days_overdue | notes

Example of the expected result — one row per invoice:

Sahni Traders      | INV-2026-0412 | 48,500 | 2026-09-18 | 24 | none
Brightline Retail  | INV-2026-0441 | 12,200 | 2026-10-02 | 10 | PO missing?
Kaveri Organics    | INV-2026-0398 | 91,000 | 2026-09-04 | 38 | dispute: line 7

Keep a do_not_chase flag per customer for anyone on a payment plan, in dispute, or handled personally — the practitioner's write-up that this ladder is adapted from calls this out explicitly (DEV).

Step 2 — Fan out: one investigation per account (15 minutes)

This is the plan-and-fan-out step. For each overdue customer, open a fresh chat (or a new parallel run) and paste the investigator prompt, attaching that customer's row plus anything you have on them — past emails, payment notes, the dispute thread. The fresh chat per customer is the manual version of the subagent: its own context window, so Customer B's dispute never leaks into Customer A's verdict.

The investigator prompt. Copy it, fill in the brackets, paste it per customer — this is the actual artifact; don't paraphrase it:

You are investigating one overdue invoice before any reminder is sent.
Work ONLY from the material below; do not invent facts.

CUSTOMER: [name]
INVOICE: [invoice_no] for [amount], due [due_date] ([days_overdue] days overdue)
CONTEXT I HAVE ON THIS CUSTOMER:
[paste past emails, payment notes, dispute details — or write "none"]

Answer in exactly this format:
VERDICT: one of PAID_ALREADY | IN_DISPUTE | NEEDS_INVOICE_COPY | NO_RECORD | PAYMENT_PLAN
EVIDENCE: one line quoting or summarising the context that supports the verdict
RECOMMENDATION: one line on what the next action should be

Rules:
- If the context shows a payment, say PAID_ALREADY even if my records say unpaid.
- If there is any disagreement about the charges, say IN_DISPUTE and stop there.
- If there is no context at all, say NO_RECORD. Never guess.

Expected result: one verdict block per customer, each from its own clean context — e.g. VERDICT: NEEDS_INVOICE_COPY / EVIDENCE: customer replied on Sept 30 asking for the invoice PDF / RECOMMENDATION: attach invoice PDF to the reminder.

Step 3 — Merge into the owner-ready digest (10 minutes)

Now you play the lead agent. Collect every verdict block into one prompt and ask for the merge. The merge must not draft reminders yet — its job is one table showing the whole pile at a glance, with a recommended ladder step per row.

The digest prompt. Paste all the verdict blocks from Step 2 at the end:

Merge these per-customer investigation results into ONE owner-ready digest.
Do not draft any reminder messages yet.

[paste all VERDICT blocks from Step 2]

Return a table with columns:
customer | invoice_no | days_overdue | verdict | recommended_action

recommended_action must be one of:
- VERIFY_PAYMENT (account says paid; check your bank/records before anything else)
- HAND_TO_OWNER (dispute or payment plan; needs a human conversation)
- ATTACH_AND_NUDGE (resend invoice copy with a gentle reminder)
- STANDARD_NUDGE (nothing unusual; proceed to the reminder ladder)

End with a one-line summary: how many accounts need my eyes before any message goes out.

Expected result: a single table — the whole morning's truth on one screen. This is the merge that the single-agent approach never produces: every account investigated, then reconciled together.

Step 4 — Match each row to the fixed ladder (5 minutes)

Take the digest and walk it against the escalation ladder in the next section. Every row lands on a ladder step by day count alone — no judgment calls yet. Expected result: each row tagged day-3 auto / day-10 needs my approval / day-21 I call them.

Step 5 — Review, send, log (15 minutes)

Work the digest top to bottom in one sitting. Expected results: day-3 gentle reminders approved in one bulk pass; day-10+ rows decided individually; every send logged with invoice id, ladder step, who approved, and when. If a customer replies at any point, their ladder pauses — disputes and replies come to you, never to the machine. Details in the guardrails below.

Guardrail one: a fixed ladder for overdue invoices, not a model's judgment

The ladder decides the tone and timing of every reminder, and the ladder is fixed. A practitioner who builds these workflows for small-business finance teams specifies it exactly: pull overdue invoices daily; decide the step from a schedule, not a model — gentle nudge automatic at day 3, firmer at day 10 only with human approval, stop automation and call the owner in at day 21 (DEV). The author discloses he runs automation agency NxFlowAI, a commercial interest — weigh it accordingly. A payments company's dunning write-up independently describes the same escalating-stage structure (friendly reminder → second notice → final notice → suspension/collections), noting the timings are "starting points, not rules" (Dodo Payments). Two independent sources, same shape.

Copy this schedule into your workflow notes — it is the whole tone policy:

reminder_schedule:
  - days_overdue: 3
    template: gentle          # "in case this slipped through" — automatic
    auto_send: true
  - days_overdue: 10
    template: firm            # names the invoice, the amount, asks what is blocking
    auto_send: false          # waits for your approval in the digest
  - days_overdue: 21
    action: owner_calls       # automation stops here; you pick up the phone

Why the schedule beats the model:

• Every customer gets the same fairness. The tone follows the calendar, not a guess about their mood — which is also what keeps you on safe ground if a message is ever forwarded to someone's CFO.
• It is auditable. If a customer asks "why did I get this?", the answer is "invoice X was 12 days overdue, so the day-10 step ran" — a sentence you can say with a straight face.
• Replies pause everything automatically. Any customer reply freezes their ladder. Disputes route straight to you. That pairing — machine sends the gentle steps, humans own the sensitive ones — is the practitioner design's core.

Guardrail two: you hold the send gate over every overdue invoice

The merge gives you a digest, not a sent folder. The gate is where you earn that:

• Day-3 gentle nudges can go in bulk — the AI did its investigation, the ladder says gentle, the message is low-stakes. You still glance at the digest before they go, because a "paid already" verdict that slipped through is embarrassing, not dangerous.
• Day-10 and beyond wait for your explicit yes. The digest shows you the firmer draft and the verdict evidence; you approve, edit, or skip — per row, not per batch.
• Day-21 belongs to you entirely. The automation hands you a call task with the full investigation history attached, so the call starts informed instead of cold.

This is a companion to — not a repeat of — our post on the approval inbox for AI agents: that post was about the gate as a general pattern for everything an agent does. Here the gate is a guardrail with one job: keep the escalation ladder honest while the investigation-then-act pattern does the real work. If you already run an approval inbox, this routine plugs into it as one more item type.

Honest limits: what this invoice-chasing routine cannot do yet

A plain accounting of what this post does not claim:

• No cost figures for the fan-out. Running one investigation per customer burns more tokens than one chat — and the published token-multiplier numbers for multi-agent setups are measured on research workloads (Simon Willison), not on collections. This post makes no claim about what the fan-out costs a small business.
• No asserted integrations. The manual routine works with any invoice source because you paste the list. Automatic pulls from your accounting tool are connector work your vendor or agency wires up — this post presents them as options, not as buttons that exist today.
• No borrowed bragging rights. The ~90% multi-agent figure is Anthropic's internal research eval (Anthropic); nothing about it transfers to chasing invoices. What transfers is the pattern.
• Document AI is an indicator, not proof. Support software is now shipping AI agents that read invoice attachments (BoldDesk's October 2026 update) — verified on the release page, but single-sourced as collections evidence. A supplier-side, exception-based AP agent combining document AI with business rules and human review for 8,000+ invoices a month corroborates the design (document AI + rules + human review), not collections results — and it is an accounts-payable story, cited honestly as such (ATeam Soft Solutions).
• The ladder timings are starting points. The payments-company dunning guide says so explicitly (Dodo Payments); your contract terms set your actual clock.

What the routine does give you is a morning that starts with the whole truth on one screen — every account investigated in parallel, merged into one digest, chased by a fixed ladder, with you holding the gate. That is the plan-and-fan-out pattern doing its actual job: not writing your reminders, but earning the right to send them.