Connecting the agent was the easy part. Everything below is what comes next: what it actually takes to teach an agent your version of the books. The working example is intercompany eliminations, because that’s where tacit knowledge is thickest, but the method transfers to any close process. Swap in revenue recognition or accruals and the steps are the same.
The Semantic-Layer Template
This sounds basic, but it’s important. You have to start with the definition.
Here’s what a working semantic-layer entry for intercompany eliminations looks like:
Category: Intercompany elimination
What it is: An entry that removes the effect of a transaction between two entities in the same consolidated group. It exists only so the consolidated statements reflect the group as a single company.
Distinct from: Third-party revenue or expense (has an external counterparty), reclassifications (move amounts between accounts within one entity), and consolidation adjustments that don’t involve two trading entities.
Required attributes: The two entities involved. The direction (who recorded the receivable, who recorded the payable). The period the entry belongs to. The rule that both sides must net to zero once recorded.
Accounts: [your elimination account range]
Exclude from: Operating expense analysis, revenue analysis, and entity-level variance explanations unless specifically requested.
Valid exceptions: [your list: timing differences under a threshold, FX rounding, whatever your close actually tolerates]
Notice what’s in there and what isn’t: There’s no code or API references. It’s an accounting policy memo written for a reader with no judgment or context, which is an accurate description of even the smartest model on day one.
The test for whether your definition is done: hand it to someone who’s never seen your books, give them ten journal entries, and ask which ones are eliminations. If they can’t answer without asking follow-up questions, the definition isn’t finished. If the answer depends on “well, you’d just know,” you’ve found exactly the tacit knowledge that has to come out of your controller’s head and onto the page.
Now blank the template and point it at any other category: what it is, what it’s distinct from, required attributes, where it lives, what it’s excluded from, and what the valid exceptions are. Six fields. Your best person can fill them out for one category in under an hour. The first one takes the longest, because nobody’s ever had to say this stuff out loud before.
Testing the Process, Not Just the Output
Now the part that separates this from documentation for documentation’s sake: using what you wrote to check the agent’s work.
Most AI evaluation checks outcomes. Did the number come out right? The problem, and anyone who’s reviewed a first-year’s workpapers knows this, is that a right answer from a wrong process is a time bomb. The staff accountant who ties out to the penny by plugging the difference didn’t do the reconciliation. An agent that produces a correct consolidated number by ignoring an elimination that happened to offset another error didn’t do the close.
In review, you don’t just check the number. You check whether the process that produced it was sound. Agents need the same treatment, and there’s now a standard way to give it to them.
In July, Braintrust and Basis (the AI company whose agents complete tax returns autonomously over hours or days) released behavior specs, an open standard for defining and evaluating how an agent works, not just what it produces. A behavior spec is a markdown file. It describes, in plain language, a behavior the agent must exhibit: what evidence it should inspect, what decision it should make from that evidence, what actions to take, what to do when something doesn’t check out, and what failure looks like. A judge model then reads the agent’s full trajectory, every step it took, and scores each behavior true, false, or not applicable.
Written out for an eliminations review, a spec reads almost exactly like your review checklist:
The agent identified both sides of the entry before classifying it. The agent verified the entities against the group structure. The agent confirmed the balances net to zero, or flagged the difference against the exception list. The agent cited which account and period it pulled for each determination. The agent escalated anything it couldn’t verify instead of guessing.
Each line gets its own true, false, or N/A. An agent can produce a perfect consolidated number and still fail the spec, which is the point. You’ve been grading juniors this way for your entire career. The format is new. The idea isn’t.
The practical takeaway: the review checklist your team already uses is about 80% of a behavior spec. Writing the spec is mostly transcription plus one discipline you’re already good at, defining what pass and fail look like concretely enough that two reviewers would score the same work the same way.
The Five-Step Roadmap
Pick one process your team knows cold. Eliminations if that’s your world. Revenue recognition or accruals if not. One process, done properly, teaches you the method. Done looks like: a named process and a named owner.
Write the semantic-layer definition. Your best person, the six-field template, one category at a time. Done looks like: a stranger can classify ten entries using only the document.
Map the relationships. Entities, hierarchy, who trades with whom, what offsets what, and when things net out. Done looks like: the org chart and the elimination logic exist somewhere besides the consolidation tool’s configuration and your controller’s memory.
Turn the review checklist into a behavior spec. Every check a reviewer performs, in order, with pass, fail, and NA defined for each. Done looks like: two people scoring the same workpaper independently get the same scores.
Then, and only then, connect an agent. Access is the easy part now. When the agent’s output disappoints, and early on it will, you’ll be able to see which behavior failed instead of staring at a wrong number with no idea where it came from.
Steps one through four require no AI budget, no procurement, and no IT ticket. They’re documentation work your team can start Monday. They also make your human close better, which is a decent consolation prize if your agent plans slip a quarter.
Who Does This Work
The free edition made the argument. Here’s how to act on it.
Look for the person whose policy memos never generate follow-up questions. The senior accountant who catches the contradiction in a process doc before anyone else. The one everybody routes tricky wording through even though it’s not their job. That instinct, precise definition without contradiction, is the qualification. Basis calls these people Language Architects and hires philosophy majors to do it. You probably already employ your version of them, and they’re probably not the person on your team who’s most excited about AI. Enthusiasm for the tools and precision with language are different skills. For this work, precision wins.
Give that person the template, the checklist, and protected time. This is close-quality work, not a side project for slow Fridays.
The Prompt Pack
Five prompts to run the buildout with your own team. One reframe before you use them: these aren’t prompts for the model to answer from its own knowledge. They’re prompts for interviewing your people, with the model as note-taker and editor. The knowledge being captured is your controller’s, not the internet’s.
Prompt 1 (Controller). Define [category] using the six-field template: what it is, what it’s distinct from, required attributes, accounts, what it’s excluded from, and valid exceptions. Give the model your chart of accounts and current close process as context. Ask for a completed one-page template.
Prompt 2 (Controller). Map every entity relationship that generates intercompany activity: who trades with whom, who consolidates whom, and what should offset. Context is your legal entity structure. Ask for a plain-text relationship map.
Prompt 3 (Reviewer). List every check you actually perform when reviewing [process], in the order you perform them, including the ones missing from the documented procedure. Context is your real review habits, not the policy binder. Ask for an ordered checklist.
Prompt 4 (Reviewer). For each check, define what pass, fail, and not applicable look like, specifically enough that two reviewers would score the same work identically. Context is the checklist from prompt 3. Ask for one row per check.
Prompt 5 (Finance lead). Review these documents as if you’d never seen our books, and flag every place you’d need to ask a follow-up question. Context is the completed template and spec. Ask for a numbered list of gaps.
Run prompt five last, and take it seriously. Every follow-up question it surfaces is a gap an agent would’ve filled with a guess.
The complete behavior spec standard, including the judge prompt template and file structure, is open source at agentbehavior.dev if your team wants to go past the checklist stage.
Forward-thinking FP&A teams use these frameworks every week.

