How to Run Your Q2 Budget Past Three AI Reviewers at Once

Every FP&A team has a story about the Q-close that almost went sideways. Usually it involves an assumption that was internally consistent but factually wrong — a headcount plan that assumed a hire date that HR had quietly pushed, a revenue line that carried a deal that sales had stopped counting. Nobody made a mistake. The document was just never reviewed by someone with a different frame of reference.

Here is a practical walkthrough of using Lope to run an independent validator ensemble over a budget document before it leaves the finance team’s desk.

What Lope does for finance work

Lope’s --domain business flag activates a reviewer persona calibrated for business and operations work. When validators review your budget or financial close process, they approach it as a senior operations lead would: checking for internal consistency, missing controls, assumption clarity, and process gaps.

This is not AI that generates financial analysis. It’s AI that validates structured work — checking your deliverable against explicit criteria and surfacing disagreements between independent reviewers. The mechanism is the same one that peer review, four-eyes principle, and independent audit use. You’re just running it in 90 seconds instead of scheduling a three-hour review meeting.

Step 1: Define the deliverable as a structured goal

The first step is giving Lope a goal it can work with. Vague goals produce vague reviews. The more specific your goal, the more specific the validator feedback.

Poor goal:

lope negotiate "Review our Q2 budget" --domain business

Better goal:

lope negotiate \
  "Q2 2026 budget review and close readiness checklist for a SaaS company with 3 cost centres (Engineering, GTM, G&A), GAAP reporting, new compensation plan effective 2026-Q2, and a planned $1.2M spend increase in headcount vs Q1" \
  --domain business \
  --max-rounds 3

The specifics matter because they give validators something to push back on. “New compensation plan effective 2026-Q2” immediately prompts a validator to ask: “Does the budget reflect the full-quarter vs partial-quarter payroll impact correctly? Is the effective date mid-period?”

Step 2: Run the negotiation

Lope’s negotiate phase produces a structured sprint document: a set of phases, each with explicit deliverables, acceptance criteria, and reviewer instructions. For a budget review, the phases might look like:

1. Cost centre reconciliation — Each cost centre owner’s input reconciles with the consolidated model. Acceptance criterion: zero unexplained variances above 5%.
2. Assumption documentation — Every revenue and cost driver has an explicit assumption statement. Acceptance criterion: no implicit assumptions remain.
3. Cross-functional dependency check — Budget assumptions that depend on another function (hiring dates, contract start dates, vendor SLAs) are confirmed. Acceptance criterion: written confirmation from dependency owner.
4. Controls and access review — Approval thresholds and spend controls are documented. Acceptance criterion: every line above $50K has a named approver.
5. Presentation-readiness audit — Numbers in the executive summary match the detail model. No rounding inconsistencies. Acceptance criterion: zero mismatches.

Validators review this structure first. If they see gaps — a missing phase, an acceptance criterion that’s too vague to verify, a dependency nobody listed — they return NEEDS_FIX with specific instructions. The sprint doc revises. Second round runs. If it passes (usually does by round 2), you proceed to execution.

Here’s what a real validator feedback block looks like:

NEEDS_FIX (confidence 0.71)
- Phase 3 (cross-functional dependency) lists "HR" as a dependency owner 
  but the new compensation plan has a legal signoff requirement. Add Legal 
  as a dependency in this phase.
- Phase 5 acceptance criterion "zero mismatches" is not verifiable without 
  a defined reconciliation procedure. Specify: "FP&A to run row-by-row 
  comparison against executive deck cells D4:D12 and F7:F19."
- No phase covers audit trail requirements. GAAP close requires timestamped 
  version control of all material changes post-Q1 baseline. Add a phase or 
  integrate into Phase 1 acceptance criteria.

That’s not generic AI feedback. That’s a specific, structured critique of a specific process document. The feedback refers to exact phases, acceptance criteria, and a regulatory requirement (GAAP close audit trail) that a single reviewer might miss under time pressure.

Step 3: Execute phase by phase with validation

Once the sprint doc passes, you run:

lope execute SPRINT-Q2-BUDGET.md

Each phase executes, and validators check the output before the next phase starts. For a budget review process, “execution” means producing and submitting the artefact for that phase — the reconciliation file, the assumption documentation, the confirmation emails from cost centre owners.

If phase 2 (assumption documentation) produces a deliverable that still contains implicit assumptions (“market conditions permitting” without a defined trigger), the validator catches it before phase 3 begins. The loop sends back a specific fix instruction. You revise. The validator reruns. Phase 3 starts only when phase 2 genuinely passes.

This prevents the most common pattern in financial close: a gap in one phase becoming invisible because everyone’s attention moved to the next phase before the fix was confirmed.

What the ensemble catches that single reviewers typically miss

Based on running --domain business reviews across budget and close documents, here are the categories of issues that consistently surface:

Assumption-definition gaps. Lines in the budget that rest on assumptions never written down. “Headcount: 47 FTEs” — is that end-of-quarter or average? Does it include contractors? The assumption is in someone’s head. The validator asks for it in the document.

Cross-function dependency failures. The marketing budget assumes a product launch in May. The product budget assumes the May launch is contingent on a contract. Neither budget documents the contingency. If the contract slips, both budgets are wrong. The validator sees both phases and surfaces the dependency.

Missing controls on material lines. Large budget lines without a named approver, without a spend control threshold, or without a review cycle. These survive internal review because everyone assumes someone else is responsible. The validator asks: “Who owns the approval for the $800K vendor contract in line 47? This line has no named approver.”

Regulatory and accounting treatment edge cases. New compensation structures, lease accounting changes, revenue recognition questions. The validator doesn’t make the accounting call — that’s your team’s job — but it flags that the question exists and needs to be answered before the document is final.

Presentation inconsistencies. The summary deck says $12.4M total spend. The detail model says $12.37M. The rounding is in the notes, but the notes aren’t in the deck. These are the things that undermine credibility in the CFO review, and they’re invisible to anyone who reviewed the detail and the deck in separate sessions.

Setup: 30 seconds, no new subscriptions

Lope is open source, MIT licensed, zero Python dependencies. It uses the AI CLIs you already have — Claude Code, Gemini CLI, OpenCode, or any combination.

Paste this into any AI agent you already use:

Read https://raw.githubusercontent.com/traylinx/lope/main/INSTALL.md and follow the instructions to install lope on this machine natively.

Then:

alias lope='PYTHONPATH=~/.lope python3 -m lope'
lope negotiate "Your Q2 close process or budget review goal" --domain business

The validator ensemble is running in 60 seconds. The first NEEDS_FIX feedback usually arrives in under two minutes.

Whether the feedback saves you one difficult conversation in the CFO review or surfaces a control gap before the external audit depends on your specific document. But the questions the validators ask — the ones that represent the gaps between independent reviewers — are worth hearing regardless.

— Sebastian
github.com/traylinx/lope