Every demo of an AI agent looks the same. A chat window opens, a goal goes in — "book me a flight to Lagos and reserve a table at the place with the goat pepper soup" — and a series of tool calls cascade across the screen until something resembling a result drops out. The audience claps. The investor pulls out a chequebook. The journalist writes a piece called "the year of agents." And then, somewhere in a windowless office in a real city, a real public servant continues to print the same form she has been printing since 2017, because nothing in the demo has anything to do with her.

This essay is about closing that gap. Not by making the demos prettier — they are quite pretty — but by being honest about what is actually missing between a working demo and a working institution. Because that is the unit of analysis, finally. Not the agent. Not the framework. The institution.

What we have, and what we don't.

What we have is a Cambrian explosion of agent frameworks. LangGraph, AutoGen, CrewAI, Pydantic AI, the in-house build at every serious AI lab — all of them solving variations of the same problem: how do I get a language model to call tools, remember things, and recover from its own mistakes long enough to finish a task? This is hard, and the people working on it are doing important work.

What we do not have is the layer above. Call it whatever you like — the civic stack, the institutional layer, the public-interest tier — but it is the part of the system that decides:

  • Who is accountable when the agent gets it wrong?
  • How is the citizen's record corrected, and by whom?
  • What happens when two agents in two different ministries disagree?
  • Who pays for the compute? Who audits the prompts? Who FOIA-requests the trace?
  • What is the human being supposed to feel when they meet this system on the worst day of their year?
The framework gives you the agent. The institution gives the agent its meaning. We are five years into building one and have barely begun the other.

Why governments — and why first.

The intuitive objection is that governments are the last place AI agents should land. They are slow, risk-averse, often technically under-equipped, and politically allergic to anything that smells like robot-replaces-public-servant. All true. And yet governments are precisely the institution where the institutional layer is non-optional. A bank can paper over an agent's mistake with a refund. A government cannot paper over the fact that a citizen was wrongly deported. The seriousness of the stakes forces the construction of the layer that the private sector skips.

This is the thing the AI safety community has, in my view, gotten almost-but-not-quite right. They keep insisting on alignment as a property of the model. I want to insist on alignment as a property of the system the model is embedded in — and that system, when it works, is not built of code. It is built of constitutional clauses, due-process protections, audit trails, ombudsmen, FOIA requests, and the slow boring discipline of administrative law.

What the civic agent stack actually looks like.

I have been building toward a working version of this for the last fourteen months, in three pilots across two governments. The architecture is still rough, but the shape is clear. There are five layers. From the bottom:

1. The trace layer.

Every agent action — tool call, retrieval, reasoning step, output — is logged in a tamper-evident store accessible to the citizen whose case it concerns. Not just the IT department. The citizen. This is the FOIA-by-default principle, and it is the foundation that everything above it stands on.

2. The correction layer.

Citizens can flag a record as wrong. Flags are routed to a human, with a clock, and the clock is publicly visible. Failure to resolve within the clock window escalates automatically. This is administrative law, ported into a system that learns.

3. The disagreement layer.

When two agents — or one agent and a public servant — disagree, the system does not pick a winner. It pauses, surfaces the disagreement, and routes to a designated arbitrator. Most contemporary agent frameworks have no answer for this. The civic version starts here.

4. The accountability layer.

Every action is signed. Not by a model. By an office. The output of the agent is the responsibility of a named human being holding a named role, and that role is publicly attributable. No "the algorithm decided." Algorithms do not get to decide things.

5. The dignity layer.

Finally — and this is the part I am least sure of — there is a layer that is responsible for how the system feels. The wording. The pacing. The defaults. Whether it apologises when it is wrong. Whether the citizen is treated like a number to be processed or a person to be served. This is not UX. UX is the surface. This is closer to protocol: the thing that decides what counts as a respectful interaction in the first place.

The objection.

The standard pushback to all of this is, "fine, but no government will move fast enough to actually build it." I do not buy this. Estonia exists. Singapore's Smart Nation exists. IndiaStack exists. The question is not whether governments can build modern public infrastructure — they have done so many times. The question is whether the people who currently build agent frameworks are willing to spend a quarter of the energy on the institutional layer that they are currently spending on the framework layer.

I think the answer should be yes, and I am building toward a world where it is. If you want to help, the door is open.

— Jacob Ajiboye, Dallas, April 2026