In most finance functions there is a small group of people everyone else depends on. The controller who knows why that entity consolidates differently. The senior analyst who remembers how the intercompany process really works. The policy owner who has answered the same capitalisation question forty times, forty slightly different ways.

This dependency is invisible on the org chart and enormous in practice. It slows every process that routes through those individuals, it turns their calendars into ticket queues, and it concentrates institutional knowledge in a handful of heads — a risk that materialises the day one of them resigns.

Self-service knowledge agents — AI assistants that answer questions from an approved body of finance knowledge — are one of the most genuinely useful applications of generative AI in finance. They are also one of the easiest to build badly. The difference between an asset and a liability is not the model. It is the governance.

Why the dependency exists — and why agents help

Finance knowledge has a peculiar shape: it is mostly written down somewhere — policies, process notes, prior memos, close checklists — but retrieving the right fragment at the right moment is harder than asking a colleague. So people ask the colleague. The expert answers from memory, the answer never gets captured, and the cycle repeats.

A well-built knowledge agent breaks the cycle. Askers get an immediate answer drawn from approved sources; experts stop fielding repetitive interruptions; and — subtly but importantly — answers become consistent. Two analysts asking the same question get the same treatment guidance, rather than two recollections that diverge in the details.

The value case is real. But notice what the agent has quietly become: a channel through which people receive guidance that shapes accounting treatments, process decisions and control behaviour. That is not a chatbot. That is part of your control environment — and it deserves to be engineered like one.

The governance design that keeps agents safe

The failure mode to prevent is straightforward to state: an agent that answers fluently from the wrong material, to the wrong person, with no way to tell after the fact. Each element of good design closes part of that gap.

Approved sources only. The agent’s knowledge base must be a curated, deliberately-assembled corpus — current policies, approved procedures, vetted guidance — not a folder crawl of everything ever written. Outdated drafts and superseded memos are worse than nothing: they produce confident answers that were true three restructurings ago. Define what is in, what is out, and who decides.

Version control on the corpus. Policies change. When they do, the agent must change with them — and you must be able to say what the agent knew, when. Treat the knowledge base like a controlled document set: versioned updates, an owner for each source, and a review cadence that keeps content current.

Access aligned to roles. Not every answer belongs to every asker. Compensation guidance, restructuring plans and sensitive entity information may all live in “approved sources” while being appropriate for only some audiences. Role-based permissions on the agent should mirror the permissions on the underlying content — an agent must never become a side door around information barriers.

Citations, always. Every answer should point to its source: the policy section, the memo, the procedure paragraph. Citations do three jobs at once — they let the asker verify, they keep the agent honest (an answer that cannot cite is an answer to distrust), and they create a natural audit trail from response back to authority.

Escalation paths by design. Some questions should not be answered by a machine: novel transactions, judgement calls, anything the corpus does not cover. The agent needs a clear, graceful “this needs a human” route that hands off to the right expert — with context. Ironically, a good escalation path makes the expert more effective: the questions that reach them are now the ones that genuinely need them.

Human-in-the-loop where answers have consequences. For guidance that feeds directly into postings or reported figures, the agent’s role is to draft and support, not to decide. Define which categories of question are self-service and which require expert confirmation, and make the boundary visible to users.

Auditability of the whole loop. Log the question, the answer, the sources cited and the corpus version. When someone asks — an auditor, a regulator, or simply your future self — “why did the team treat it this way?”, the trail should exist.

Hallucination is a governance problem, not just a model problem

Language models can produce plausible, wrong answers. In casual settings this is an annoyance; in finance it is a control deficiency. The mitigations are architectural, and they are all governance choices:

  • Ground every answer in retrieved source text — the agent answers from documents, not from its general training.
  • Prefer “I don’t know” over improvisation. An agent that declines gracefully when the corpus is silent is doing its job, not failing at it.
  • Require citations (again) — hallucinated answers struggle to produce genuine references.
  • Test adversarially before launch: ask the questions the corpus cannot answer, the ambiguous ones, the ones with recently-changed policy — and verify the agent escalates rather than invents.

Measure adoption, usefulness — and trust

An agent nobody uses has failed quietly; an agent people use but silently distrust has failed dangerously. Measure both dimensions: whether questions are being asked (adoption), whether answers resolve them without re-asking a human (usefulness), where the agent declines or escalates (coverage gaps that tell you what to add to the corpus), and what users flag as wrong or unclear (the feedback loop that drives corpus maintenance).

These measures do double duty as governance evidence: they demonstrate the agent is monitored, maintained and improving — exactly what a reviewer will want to see.

Design governance in from the beginning

Everything above is dramatically cheaper on day one than on day two hundred. Retrofitting citations, permissions and logging onto a live agent that users already rely on is painful; designing them in costs little more than the discipline of asking the right questions before launch — what sources, whose access, which escalations, what evidence?

Self-service finance agents genuinely deliver: fewer interruptions for experts, faster and more consistent answers for everyone else, and institutional knowledge that finally outlives the people who carry it. The teams that capture that value safely will be the ones that treated the agent, from its first day, as what it truly is — a governed part of the finance control environment, built with the same care as any other system their numbers depend on.