Timesheet Reconciliation Agent: Working Sketch
GEN·METRICS
Working sketch · internal
Timesheet reconciliation agent

The agent reads.
The rules decide.
A person signs off.

A system shape for the payroll reconciliation engagement: AI is used only where the mess is (reading timesheets in several formats), the arithmetic is done by deterministic rules that can be audited line by line, and nothing writes to the master ledger without human approval.

4–5
timesheet formats arriving today
2×
payroll runs per month
£250k
per run: the cost of getting it wrong
L1
on the AI Spectrum: trust must be earned in stages
The shape of the system

One pipeline, three kinds of work

Follow the colour: teal is the AI reading and explaining, grey is deterministic rules doing arithmetic, orange is a person deciding. Lime only appears at the end, where verified entries reach the ledger.

TIMESHEETS IN Excel workbook PDF scan CSV export Email / portal Extraction agent AI one reader per format unsure values flagged, never guessed normalises Standard record who · period · hours · rate every value keeps a pointer to its source cell or page Reconciliation engine RULES, NOT AI ✓ duplicates ✓ missing entries ✓ rate × hours totals ✓ approver present same input, same answer Master ledger source of truth for payroll read-only compare Exception queue agent explains each one in plain English + suggests a fix, linked to the source doc doesn't match Approval gate HUMAN a person reviews the run and signs it off matches resolved Ledger updated payroll runs as today, from reconciled entries writes, only after sign-off The AI never touches the arithmetic. The rules never make judgment calls. Nothing writes to payroll unchecked.
AI reads & explains Deterministic rules Human decides Verified output
Timesheets in any format become one standard record; rules compare records against the ledger; people approve what the rules surface. The only write to the master ledger happens after sign-off.
Why AI here

AI only where the mess is

The only job the AI has is reading 4–5 messy formats into one clean record. It is the smallest, most testable use of AI in the whole system, and the easiest to prove right: every extracted value can be checked against the document it came from.

Why rules

The arithmetic is deterministic

Reconciliation is rules, not a model: same input, same answer, every time. Each decision (duplicate, missing, mismatch) is explainable line by line. There is no "the AI decided" anywhere near the money.

Why a gate

A person holds the pen

Nothing reaches the master ledger without sign-off. The system prepares the payroll run and shows its working; it never runs payroll. For a team new to AI, that line is the whole basis of trust.

Stage by stage

What happens between a timesheet arriving and payroll running

Each stage is a talking point on its own. Expand the technical depth only if the conversation goes there.

1

Ingest & extractAI

Timesheets arrive as they do today: workbooks, PDF scans, CSV exports, portal entries. A per-format reader lifts the entries out. Anything the reader is not confident about is flagged for a person, never silently guessed.

Technical depth
  • LLM extraction with structured output, validated against a fixed schema on every document.
  • Confidence thresholds per field: below threshold, the field is marked "needs review" instead of being filled.
  • Every value carries provenance: file, page or cell, and the raw text it was read from.
  • New format arrives? Add a reader; the rest of the pipeline is untouched.
2

NormaliseRules

Every timesheet becomes the same shape: who, period, hours, rate, approver. From here on, the system has one format to deal with, which is what makes everything downstream simple and testable.

Technical depth
  • A versioned canonical schema; basic validity checks run here (dates in period, hours in range, known employee IDs).
  • Failures at this stage are data problems, not judgment calls, so they route straight to the exception queue.
3

ReconcileRules

A deterministic engine compares each record against the master ledger: duplicates, missing submissions, rate and total mismatches, period boundaries, sign-off present. The output is two piles: entries that match, and exceptions.

Technical depth
  • Pure rule engine, unit-tested, no model in the loop. The rule catalogue grows during Discovery from how the team reconciles today.
  • Read-only against the ledger: this stage compares, it never writes.
  • Every run is replayable: same inputs re-produce the same result, which is what makes the process auditable.
4

Explain exceptionsAI

The queue itself is just a list. Three parties touch it, and only one of them can close an item: rules put entries in (an item lands here because a check failed, never because an AI decided), the AI annotates each one with a plain-English reason and suggested fix linked to the source document, and a person in the payroll team resolves it. The AI is the clerk who prepared the file, not the officer who decides the case.

Rules file it→ AI explains it→ A person closes it
Technical depth
  • The agent explains and drafts; it cannot resolve an exception itself. Accept, edit or reject stays with the reviewer.
  • Resolutions are logged and become training material for better rules, not silent model behaviour.
5

Approve & postHuman

A reviewer sees the whole run: what matched, what was fixed, what changed. One sign-off posts the reconciled entries to the master ledger, and payroll runs exactly as it does today, from a ledger that is now right.

Technical depth
  • Full audit trail: who approved which run, when, and what every entry looked like before and after.
  • The write to the ledger is the only write in the whole system, and it only exists behind this gate.
On your stack

Built on tools the business already pays for

This is a Microsoft 365 shop, so the system rides the Power Platform rather than new infrastructure. Every stage lands on something already licensed and familiar; only one component is new engineering.

1 · Ingest & extract
Power Automate + AI step
Flows already watch the mailbox and SharePoint folders; extraction is an AI call inside the flow, not a separate system.
2 · Normalise
Dataverse / SharePoint list
Standard records live where the team can see them. If the master ledger is an Excel workbook today, day one works with that; no migration required.
3 · Reconcile
Azure Function · new build
The rule catalogue outgrows a flow diagram fast, so the deterministic engine is one small, unit-tested function. This is the only genuinely engineered component.
4 · Exception queue
Dataverse / SharePoint list
A list with statuses, AI annotations attached to each row. Reviewers work it from the tools they already use.
5 · Approve & post
Teams Approvals
Sign-off happens in Teams or Outlook, which staff already know, and the audit trail comes free with it.

What this means for cost: the engagement is mostly configuration of a stack the client already owns, plus one small engineered component. That keeps delivery lean and keeps the whole system inside the team's comfort zone, which matters for a client at L1.

How it lands

Trust is phased in, not assumed

The client is at L1 on the AI Spectrum. The shape above is also a rollout plan: nothing changes for them until the system has proven itself against their own history.

Now
Discovery

Map how reconciliation works today

Collect the real formats, the real failure stories, and the rules the team applies by hand. The rule catalogue and exception types come straight from this.

Phase 1

Shadow mode

Extraction and reconciliation run alongside the current manual process on real payroll cycles. Nobody relies on it yet; every cycle produces a match-rate scorecard instead.

Phase 2

Agent live, gate stays

Once the scorecard has earned it, the system leads and people review. The approval gate is permanent by design, not a training-wheel to remove later.

If they ask

The four questions this design answers

"What if the AI misreads a timesheet?"
Low-confidence reads are flagged, not guessed, so a misread becomes an exception for a person, not a payroll error. And every number links back to the exact cell or page it came from, so checking one takes seconds.
"Can we audit it?"
By design. The rules are deterministic, so any run can be replayed and gives the same answer. Every value has provenance, every exception has a logged resolution, and every posting has a named approver and a timestamp.
"Does this replace our payroll team?"
No. It removes the re-keying and the cross-checking, the part nobody enjoys. The judgment calls stay with people; they just stop hunting for discrepancies by hand across 4–5 spreadsheets.
"Why not buy an off-the-shelf timesheet tool?"
Off-the-shelf tools solve capture: they give you one more portal, and the senders keep sending whatever they send today. The hard part is reconciliation against your ledger, under your rules, and that is exactly the part this system builds, on the Microsoft stack you already own. Capture tools can slot in later without changing the design: they would simply be one more input format.