Your AI Agents Are Starving for Context

Your AI Agents Are Starving for Context

When a new accountant joins your team, you probably spend their first month answering questions you didn't know you needed to answer. “Why does this vendor get coded differently? Why does this accrual use a six-month lag? Which customer's contracts arrive with weird quirks, and what do we do with them when they do?”

The new hire absorbs the necessary context over coffees and Slack threads, and a year later, they're the one explaining it to the next hire.

Agents are the same kind of new hire, except they can't tap you on the shoulder. They don't pick anything up by osmosis. Everything you'd otherwise say out loud has to live somewhere they can read.

AI is already good. AI with your team's context is great. In the finance engineer era, the human data (the reasoning, the exceptions, and the unwritten rules) is going to be just as important to the machine as the CSVs, PDFs, and PNGs the AI is already accustomed to parsing. The context layer underneath your process is quickly becoming one of the most crucial success (and failure) points for your close.

A New Data Type - Context

For most of accounting's history, "data" meant the output your systems gave you. The GL extract and the CSVs from billing. That's machine data, and it's what your tools (like NetSuite) were built to consume.

But today, there's a second category of data that's beginning to have even greater operational value: the information that used to live only in your team's collective head. Call it context, call it tribal knowledge—at the end of the day it's data that's waiting to be converted.

The SOP docs and the Notion pages were built to capture some of the team knowledge, but they were built for humans reading on demand, not for agents querying programmatically. The bigger issue is that most of the human data was never written anywhere. It was transferred person to person, hire to hire, manager to junior. The new opportunity isn't fixing the documentation stack; it's expanding what counts as documentation in the first place.

The fix: Treat process knowledge and systems knowledge as a data source

1. Audit what only lives in one person's head. Ask each teammate: "If you left tomorrow, what would the next person have to relearn from scratch?" The answers are your starter list.
2. Treat documentation as part of the close, not a side project. Knowledge work scheduled for "after the close" almost never happens because there's always another close. Build a documentation task into the checklist itself, the same way you'd build in a review or a sign-off.
3. Document how fields, objects, and naming conventions work across your systems: Systems configuration decisions are what take a standard ERP like NetSuite or Quickbooks from a boilerplate tool to a highly customized machine for your team. Though these configurations might be helpful, It's hard to enable teammates or agents who don't understand how your fields and accounts are set up at your company vs. how they learned in a prior instance. The more context you can derive from how your tools are set up, the better.

Teams also use Numeric to pin documentation and Claude Skills right to the task they're working on. This way, knowledge around task execution exists even when team members go on PTO, and it can help LLMs discover how to execute against certain tasks.

Users can add any relevant context to their tasks in Numeric -- whether that's in the form of links, attachments, or written notes.

1. Write your SOPs with agents in mind. When you draft an SOP, picture handing it to someone with zero context about your company. If a step assumes you already know which entity "the main one" refers to, or which inbox "the AP inbox" is, the documentation will work for you and fail for the agent. Specificity that feels excessive to a human is exactly the level an agent needs.

Jonathan Krabbenschmidt, a Numeric Solutions Manager, former Accounting Manager, and ex-PwC echoes these sentiments:

“When I led our CECL process, we would meet monthly as a credit committee to decide how to treat individual accounts in terms of what we expected to recover. This wasn't written anywhere because this was something that was cross-functional and human-to-human. When I had to pass this process down, there was no way to point to an SOP, and this just lived within my knowledge.”

“These edge cases can now be linked to an edge case repository that’s a database of specific situations. That way, your agent is able to read the context of every single edge case that's ever happened in a database, whereas before, it wouldn't make sense for us to just write down every edge case in a database, because no human's going to read and memorize everything that has ever happened that's off-process. But now, this agent can just go through a database almost of every situation that hasn't occurred by the strict SOP, and then it can use that context to make a decision.”

Treat your team's process knowledge as a real data source. This is where the unwritten becomes written. The rest that’s unwritten can remain a song by Natasha Bedingfield.

The Fragmentation Problem

Today, much of the systems fragmentation that has plagued accounting is fading away -- thanks to MCPs and APIs. The understanding and context fragmentation, however, remains an issue.

MCPs - A New Tool in the Accounting Toolbelt

If APIs have been popular in accounting & data circles for their ability to port data from one system to another, then MCPs take that core functionality and improve upon it greatly.

MCPs, or Model Context Protocols, are an open standard that lets AI agents connect to the tools and data sources you already use. From here, the agent can read and act directly on your system, instead of relying on what you copy and paste into a LLM chat window.

So, if you use the NetSuite MCP, you can navigate and pull data from your specific NetSuite instance. A Slack or Gmail MCP helps you to write emails and messages with ease. And the Numeric MCP exposes 15+ tools that help teams to use Numeric right from their preferred AI interface.

And with Claude, ChatGPT, Cursor, etc. operating as the central node, these MCPs can work functionally as data rivers that stitch data together in real-time.

Solving for Fragmented Understanding

MCPs are helping by fixing the scattered systems problem that have plagued accounting and finance teams since time immemorial.  Reconciling data across apps and pulling from twelve sources at once—that's getting easier every quarter. What MCPs don't fix is fragmented understanding: the documentation exists, but it’s not in an agent-readable format.

When documentation only exists as a Loom, an agent can't act on it at all yet. Non-readable formats are genuine blind spots. A 12-minute walkthrough video might contain the single most important piece of context about how your team handles deferred revenue, yet to the model, it's a black box.

The fix: Consolidate your documentation languages

Consolidate documentation into readable mediums so an agent can comprehend the context directly. The agent can already connect to your different platforms; your task as an accountant is to bring in the context that AI can't read yet. (See also: how to onboard a new accountant—the same principles apply when your "new hire" is an agent.)

1. Convert your videos into text-and-screenshot artifacts. Videos were built for a human to consume, and agents don't have eyes—yet. Lucky for us, they're excellent at reading text and interpreting image files, so you can use platforms like video2docs or docsie.io to begin converting these walkthroughs into readable context with screenshots.
2. Pick one medium per type of knowledge and stick to it. "Consolidate" doesn't mean one giant document; it means one canonical location for each kind of knowledge. SOPs can live in markdown while reasoning and exception notes live next to the task itself (in Numeric, on the recon, or checklist item they describe). Reusable scripts and Claude Skills can live in GitHub.
3. Standardize the structure inside the documents themselves. An agent reading ten SOPs written in ten different shapes will get ten different qualities of output.The same way a well-formatted JSON file is easier to parse than the same data in a paragraph, a well-structured SOP is easier for both the agent and your next new hire to act on. You can find a great SOP Documentation Template in our AI Mandate Playbook.
4. Treat screenshots and diagrams as first-class context, not decoration. Modern agents read images well—embed them in the same document as the corresponding procedure, with descriptive alt text or a caption underneath so the model can connect the visual to the text.

The Exceptions Problem

Most teams document the standard versions of their close processes. Far fewer document the exceptions to those processes like which vendor invoices arrive outside of the software and need email intake. When documentation does get written, it often captures the steps and skips the reasoning.

An SOP may say: "book accruals on a 6-month lag for major customers."

What it doesn't say is: "the 6-month lag is because our biggest customer takes 4–5 months to dispute first invoices, and we want a buffer so we don't suffer."

Exceptions are where the manual work hides. They prompt a bulk load of close work that doesn't appear in any standard process map, and automations built on top of the standard SOP will silently produce errors on the exceptions because nothing told them to behave differently. Without the why of your process, the LLM can mimic a rule but can't extend it. An exception document without rationale is a recipe that says "bake for 35 minutes," when what the agent actually needs is a description of what "done" looks like in your specific oven.

SOP templates are usually structured to describe the primary process, with exceptions treated as footnotes. Personiv calls finance "a notorious epicenter of tribal knowledge," which is really another way of saying the exceptions outnumber the rules. The Controllers Council has identified pre-documentation: writing the rationale before the work starts as a method proven to capture it. But most teams skip pre-documentation because by the time you've finished the actual reconciliation it's 11pm and writing the why feels like homework.

Either way, the LLM can't act on a footnote.

The fix: Make no exceptions for documenting exceptions

1. Treat the exception documentation as a real artifact that sits alongside the SOP for the standard process.
2. Make rationale a required field in your documentation template. Capturing the why when you write a procedure minimizes the guess work an LLM has to do later (and “guess” is a scary word with AI).
3. Keep a running exceptions log. Add a single line to a running log every time you handle something that didn't fit the standard process. Six months in, you'll have caught the exceptions you would've otherwise rediscovered the hard way when an agent runs the wrong rule on them.

Building Better Process Documentation for You and Your Team

A few concrete moves you can make this quarter:

1. Create Claude Skills to store process documentation for your agents. Skills are folders of instructions and reference material that an agent reads before it acts. They're effectively onboarding fuel: you can drop in your chart-of-accounts conventions, your accrual rules, your "things to check before closing AP" list, and the agent will pull from it the same way a new hire would pull from a binder on their first day. Skills make your process documentation both repeatable and consistent. Many MCPs already have pre-built skills—use them to your advantage. When using the Numeric MCP, our pre-built skills can get you started by automating accruals, making overdue task nudges, and even creating a board ready executive report.

2. Use a team GitHub to store Python scripts, Skills, and reusable artifacts. Having a Github repo is quickly becoming standard finance hygiene. A central repo gives your team one place to version-control the documentation that matters most, and also makes the documentation portable across agents and tools. In our good friend Francisco Mayo’s Github piece, he says, “GitHub isn’t just an engineering tool. Once your scripts start interacting with financial systems, it effectively becomes part of your control framework.”

3. Run your Looms and video walkthroughs through a platform like video2docs and docsie.io. Convert them into text and screenshots an LLM can ingest. You don't need to delete the originals; just give the agent context it can actually read.

4. Leverage close software like Numeric to visualize and document the processes within your close itself. When the documentation lives next to the task—the recon, the flux, the checklist item—both humans and agents end up with a clearer picture of how the work actually runs. Teams use Numeric as an orchestration layer for their close, adding context right into the description field for any task. Between these written descriptions, any linked workpapers, and clear audit trails showing preparer + reviewer sign-offs, it’s easy for any accountant or agent to reference necessary task documentation at the time of completing a task.

5. Use Claude to retroactively reconstruct documentation. Claude excels at piecing together what decisions were made inside a piece of software based on the artifacts those decisions left behind. Treat Claude’s first pass as a draft, then have a human verify. You'll be surprised how much of your unwritten process can be recovered this way.

6. "Cook and wash dishes" as you go. The next time you execute a process, use Claude to capture the documentation in the moment. The marginal cost is small, maybe two extra minutes per task, and the marginal value compounds every time you (or an agent) repeat the work.

Conclusion

Process documentation used to be something accounting teams did when they had time or when an auditor asked.  In this new era of AI and finance, process documentation will be the thing that gives teams tailored, accurate, and useful AI outputs as opposed to generic or even inaccurate products. The teams that commit to documentation and creating a context layer will give themselves a compounding advantage that manifests across both human and agent teams.

The good news is none of the documentation work requires any particular skills you don't already have. The new process documentation mindset just requires you to write down what you already know, in a format an agent can read, in a place an agent can find. The same instinct that made you a good teammate to the last new hire will make you a good teammate to the next agent.

Start with attentively documenting one process this week. Future you (and your agent) will be grateful.