Claude Cowork Finance Walkthrough: Accrual Review

Most write-ups about agentic AI in finance stop at the demo: "look, Claude built a reconciliation." Real teams need the whole arc — from the messy problem on Monday morning to a shipped, signed-off outcome that survives an audit. This post walks one realistic end-to-end use case from start to finish: automating a monthly accrual review for a mid-sized company's operating entity, using Claude Cowork and a small plugin. No invented metrics, no magic — just the actual sequence of decisions and the artifacts each step produces.

The goal is that by the end you could run a near-identical project on one of your own recurring tasks.

Key takeaways

• A successful agentic finance project follows a predictable arc: scope → spec → connect → parallel-run → harden → ship.
• Pick a task that is recurring, rule-governed, and currently painful — accruals, reconciliations, and flux commentary are ideal first projects.
• Run the plugin alongside the manual process for at least one full cycle before trusting it.
• The shipped artifact is not just output — it's the spec, the connectors, the checks, and the review log together.
• "Shipped" means a second person can run it and an auditor can follow it, not that it worked once.

The problem: accrual review eats three days every month

Our example team closes a US operating entity each month. One painful step is the accrual review: an analyst pulls open POs, prior-month accruals, and recent invoices, then decides which accruals to keep, release, or true up. It is judgment-heavy but deeply rule-governed, and it reliably consumes two to three days of a senior analyst's time. That combination — repetitive, rule-based, expensive — makes it a perfect first agentic project. Anything chaotic and one-off would be a bad place to start.

The desired outcome is concrete: a proposed accrual schedule with a clear rationale per line, every material change flagged for human review, and a clean trail an auditor can follow. Note what is not in scope — the agent will not post anything. It proposes; humans decide.

The walkthrough, step by step

Here is the full arc, from the analyst's spec to the controller's sign-off. Each node produces an artifact you keep.

flowchart TD
  A["Define scope & success
accrual review, one entity"] --> B["Write plugin spec
rules for keep/release/true-up"]
  B --> C["Connect read-only
ERP, PO list, invoices"]
  C --> D["Claude drafts accrual schedule
+ rationale per line"]
  D --> E{"Material change?"}
  E -->|Yes| F["Flag for controller review"]
  E -->|No| G["Carry forward with note"]
  F --> H["Controller signs off"]
  G --> H
  H --> I["Export proposals + audit log"]

The spec encodes the firm's real accrual policy in plain language: release an accrual when the matching invoice has posted; true it up when the invoice differs from the estimate by more than a set tolerance; keep it when the obligation clearly persists; and escalate anything ambiguous. Claude Cowork loads that as a Skill and follows it line by line, pulling supporting data through read-only connectors.

The artifact you actually ship

The deliverable is not a chat transcript. It is a structured output the team can review and store. A useful pattern is to have the plugin emit machine-readable proposals so they can be diffed, sorted, and audited:

{
  "period": "2026-05",
  "entity": "US-OPCO",
  "proposals": [
    {
      "account": "2100-Accrued-Expenses",
      "vendor": "Acme Logistics",
      "prior_accrual": 42000.00,
      "action": "true_up",
      "proposed_amount": 45120.00,
      "rationale": "Invoice INV-8842 posted at 45,120; exceeds estimate by 7.4% (> 5% tolerance).",
      "evidence": ["PO-3391", "INV-8842"],
      "requires_review": true
    },
    {
      "account": "2100-Accrued-Expenses",
      "vendor": "Northwind Supply",
      "prior_accrual": 12000.00,
      "action": "release",
      "proposed_amount": 0.00,
      "rationale": "Matching invoice INV-8810 fully posted in period.",
      "evidence": ["INV-8810"],
      "requires_review": false
    }
  ]
}

Every line carries its rationale and evidence, and requires_review routes the material items to a human. The controller reviews the flagged lines, not all of them — which is exactly where the time savings come from while keeping judgment in human hands.

Running it for real: the parallel month

You do not flip the switch and walk away. For the first full close, the team runs the plugin in parallel with the existing manual process. The senior analyst still does the accrual review by hand, then compares their answer to Claude's proposals. Disagreements are gold: each one reveals either a gap in the spec (tighten it) or a genuine catch by one side. After one or two parallel cycles, the spec stabilizes and the comparison converges — and that convergence is your evidence to start trusting the automated path for the routine lines.

Common pitfalls in an end-to-end finance rollout

• Starting with a chaotic task. One-off, judgment-soaked work makes a terrible first project. Choose something recurring and rule-governed so the spec can actually capture it.
• Skipping the parallel run. Going straight to production with no manual comparison means you find the spec's gaps in your live close — the worst place to find them.
• Reviewing everything. If the controller re-checks every line, you've saved nothing. Use a requires_review flag so humans focus only on material or ambiguous items.
• Shipping output without the spec. If the only artifact is the result, the project dies when its author leaves. Ship the spec, connectors, and checks together as a runnable package.
• No defined "done." "It worked once" is a demo, not a shipped capability. Define done as "a second person can run it and an auditor can follow it."

Ship your first end-to-end finance plugin in five steps

1. Choose one recurring, rule-governed, painful task and write down its policy in plain language as a plugin spec.
2. Wire the needed data sources as read-only connectors and confirm the agent can see the right entity and period.
3. Have Claude produce structured proposals with a rationale and evidence per line, and a review flag on material items.
4. Run it in parallel with the manual process for one full cycle; reconcile every disagreement and tighten the spec.
5. Package the spec, connectors, checks, and review log so a second person can run it — then hand it off.

Manual vs. agentic accrual review

Dimension	Manual process	Claude plugin (proposal mode)
Who pulls the data	Analyst, by hand	Agent, via read-only connectors
Human focus	Every line	Flagged material lines only
Audit trail	Workpaper, often sparse	Per-line rationale + evidence + log
Posting authority	Human	Human (agent proposes only)

Frequently asked questions

How long does a first project like this take?

The spec and connectors often come together in days, but the honest timeline is one to two full close cycles, because the parallel run is where the spec actually hardens. Plan around your close calendar, not a sprint.

What makes a task a good first candidate?

Recurring frequency, clear rules, real current pain, and a contained blast radius. Accruals, reconciliations, intercompany matching, and flux commentary all fit. Avoid anything one-off or politically charged for your first attempt.

Does the agent ever post to the ledger in this walkthrough?

No. Throughout, Claude proposes and humans dispose. Posting authority stays with people; the agent's job is to do the heavy preparation and surface exactly what needs a decision.

From close-the-books agents to answer-the-phone agents

CallSphere runs this same problem-to-shipped-outcome loop for voice and chat — agents that gather context, follow your rules, and complete real tasks on every call while keeping a human in the loop where it matters. See a live example at callsphere.ai.

---

Source & attribution: This is an independent, original explainer inspired by Anthropic's coverage on the Claude blog. Claude, Claude Code, Claude Cowork, Claude Opus, and the Model Context Protocol are products and trademarks of Anthropic. CallSphere is not affiliated with or endorsed by Anthropic.