AI is very good at producing confident answers. It is much worse at producing accountable ones.
That gap is fine when the stakes are low. It becomes a real problem when an AI is helping decide a regulated government application, where a wrong or unexplained decision affects a real person, and where an auditor may one day ask: why did the system reach that conclusion?
“The model said so” is not an acceptable answer in that world. When I set out to bring AI into a government e-services workflow, I started from a different requirement: every decision has to show its work.
The idea: a council, not a single model
The instinct is to throw one large model at the whole application and ask for a verdict. I did the opposite. I modelled the system on how a competent human review board actually operates.
Instead of one all-knowing model, the platform runs a council of specialist agents, each with a narrow, well-defined job:
- One reads and understands the submitted documents.
- One extracts the structured facts.
- One checks the photos and images.
- Others validate the rules, compliance requirements, and business logic.
- One cross-checks everything for internal consistency.
- One assesses overall risk.
Each specialist forms an independent opinion. No single agent decides the outcome, and that is the point. Narrow, focused agents are easier to reason about, easier to test, and far easier to trust than a monolith.
The Judge and the deliberation loop
Independent opinions are only half the story. Real review boards deliberate, and so does this one.
After the specialists weigh in, an AI Judge reviews their opinions and does one of two things:
- If there is an evidence-backed consensus, it certifies the decision and picks exactly one action from the allowed set.
- If there is not, it does not guess. It issues precise instructions, like “this agent should re-examine that point,” and the relevant work is redone before another round of deliberation.
This loop is bounded, so it always converges to a decision. And when the deciding factor is missing information rather than a clear failure, the system is designed to ask for more information instead of forcing a call. Humility, by design.
No black box: transparency as a feature
Here is the part I care about most. The entire run is recorded, not as a log buried in a file, but as a first-class, inspectable trail:
- Every agent’s opinion and confidence.
- Every message passed between agents.
- Every rule that passed, failed, or could not be verified.
- Every piece of supporting evidence.
You can open a completed decision and replay exactly how it was reached, step by step, on a live execution canvas. If a decision is ever challenged, the answer to “why?” is not a shrug. It is a receipt.
This is what turns “AI made a decision” into “AI made a decision, and here is the complete, auditable reasoning behind it.”
Giving the agents tools and MCP
An expert does not rely only on what is in front of them. They look things up.
So the agents can now call external tools on demand, and more powerfully, connect to MCP servers (Model Context Protocol). Register a source once, say an authoritative regulations service, and the agents can query it during a review. When a rule needs verifying against the official regulations, an agent checks the live source instead of relying on stale training data.
Crucially, this is all configuration, not code. An administrator registers a tool or an MCP server from a screen, and the agents can use it based on need. Every one of those calls is recorded in the same audit trail as everything else.
Governance, safety, and sovereignty
Because this is government software, the foundational parts matter as much as the clever ones:
- A human is always in the loop. The system recommends; a person makes the final call before anything is submitted.
- Secrets are encrypted at rest. Access is scoped and key-based, and external calls are constrained to approved destinations.
- The model layer is swappable. A mix of sovereign and on-prem AI options means sensitive processing does not have to leave trusted infrastructure.
- Clean, ports-and-adapters architecture. The LLM provider, the database, the document engine, and the tool sources can each be changed through configuration, not rewrites. The whole thing is backed by a large automated test suite.
Trustworthy AI, it turns out, is mostly good engineering.
Why this matters
The debate about AI in the public sector often gets stuck on capability. Can the model do it? I think that is the wrong question. The models are already capable enough. The real question is accountability: can you explain it, audit it, govern it, and keep a human in charge?
That is what this project has been about. Not the most powerful AI, but the most answerable one. A system that deliberates like a panel, shows its reasoning like a good analyst, checks its facts against real sources, and hands the final decision to a human.
If you are working on AI in a regulated or high-stakes domain, I would love to compare notes.
Why use multiple specialist agents instead of one large model?
Narrow, focused agents are easier to reason about, test, and audit than a monolithic model. Each specialist can be independently verified, and the deliberation process mirrors how real review boards work. This separation also makes it easier to replace, update, or constrain individual agents without affecting the whole system.
How does the AI Judge prevent deadlock or endless deliberation?
The deliberation loop is bounded with a maximum number of rounds. After each round, the Judge either certifies a consensus decision or issues specific re-examination instructions to targeted agents. If sufficient information is missing, the system asks for more data instead of forcing a decision, then reconvenes.
What happens if the agents disagree?
If there is no evidence-backed consensus, the AI Judge does not guess or force a call. Instead, it identifies the specific point of disagreement, instructs the relevant agent to re-examine that evidence, and the deliberation loop runs again. The goal is to resolve disagreement through evidence, not override it.
How are external tool calls and MCP queries audited?
Every tool call and MCP query is recorded in the same immutable audit trail as agent opinions and messages. The system logs what was requested, what source was queried, what response was received, and how the agent used it in its reasoning. This makes the entire decision chain fully inspectable.
Can this architecture work with different LLM providers?
Yes. The model layer is intentionally swappable through a ports-and-adapters architecture. You can use sovereign AI options, on-prem models, or cloud providers, and switch between them through configuration without rewriting the core logic. This is essential for regulated environments where data residency and vendor lock-in are concerns.
