AI Agent Security
What is governed agency?
Governed agency is the design pattern for autonomous AI agents that constrains what evidence they can access, what reasoning they can undertake, what actions they can take, and creates an immutable audit trail of every decision — enabling trustworthy AI autonomy without constant human oversight.
Why this matters
Ungovernanced agents are a compliance nightmare. They make decisions in real-time, retrieve information from multiple sources, and iterate on their own reasoning. If something goes wrong, you can’t reconstruct what they thought or why they acted. In regulated industries, that’s unacceptable.
Governed agency means agents operate inside a policy envelope. They have authority boundaries (what they’re allowed to decide). They have evidence boundaries (what data they can access). They have action boundaries (what they can actually do). And every decision is logged in a chain-of-custody that proves the boundaries were respected.
How it works
A governed agent operates in a loop:
- Intent: The user makes a request.
- Planning: The agent decomposes it into sub-tasks.
- Retrieval: For each task, the agent retrieves evidence from authorized sources only (REBAC-enforced).
- Reasoning: The agent chains retrieved evidence into a reasoning path.
- Gating: Before taking action, a gate verifies the reasoning against policy.
- Execution: If the gate passes, the action is taken and logged.
- Ledger: Every step is recorded in the Claim Ledger.
If a gate fails, the agent either re-plans, asks for clarification, or escalates — never violates policy.
How Kenshiki Labs implements this
Kenshiki Labs provides:
- Evidence boundary (Kura): Agents only retrieve from sources they’re authorized to access.
- Policy gates: Before action, gates verify the reasoning satisfies policy constraints.
- Claim Ledger: Every loop iteration is recorded — planning, retrieval, reasoning, gating, execution.
- REBAC integration: Agent identity and clearances determine what evidence they can access.
This lets you deploy autonomous agents in regulated environments because every decision is auditable and provably within policy.
Frequently asked questions
How does governed agency prevent agents from going rogue?
It doesn't prevent rogue behavior — it makes it impossible. The agent operates within a bounded context: specific evidence scopes, specific action permissions, specific output gates. Before the agent takes any action (send an email, modify a record, submit an order), governance gates verify the action is authorized. If the agent tries to exceed its boundary, the action is blocked and logged.
Is governed agency the same as agent sandboxing?
No. Sandboxing isolates the agent's execution environment (like running in a container). Governed agency constrains what evidence the agent sees, what decisions it makes, and what actions it's authorized to take — before execution. Sandboxing is defensive; governance is structural. Both are useful.
Can I use governed agency with tool-calling models like GPT-4?
Yes. The agent (whether GPT-4 via function calling, a custom orchestration loop, or an agent framework) operates within the governance boundary. It sees only the evidence it's authorized for, calls only the tools it's authorized to use, and its actions are gated before execution. The model doesn't change — the orchestration layer provides the boundary.
How do I audit what an autonomous agent did?
The Claim Ledger records every decision the agent made: what evidence was in scope, what tools it called, what the results were, what gates fired, and what final action was approved. An operator or auditor can replay the entire execution trace and verify each decision was within governance.
What happens if an agent hallucinates a fact and uses it in a tool call?
The gate before tool execution checks: Is this claim grounded in the retrieved evidence? If not, the tool call is blocked or modified. The ledger records the attempted hallucination, what evidence actually supported the decision, and what the gate decided. Operators can then review and decide whether to allow it.
Can governed agency work with multi-agent systems?
Yes. Each agent has its own governance boundary: evidence scope, tool permissions, action gates. When agents communicate, Kenshiki Labs ensures: Agent A can only see information Agent B is authorized to share. Agent A can only call tools Agent A is authorized for. The ledger tracks inter-agent communication and gate decisions at each step.
Does governed agency add latency to agent execution?
Minimally. Governance checks are policy evaluations and database queries — typically single-digit milliseconds. For most use cases, the latency is negligible compared to model inference time. The tradeoff is worth it: you trade a few milliseconds for proof that the agent stayed within bounds.
What's the difference between governed agency and a supervised agent?
Supervised agents require a human to approve each action. Governed agents operate autonomously within a policy boundary — no human required for routine decisions, but humans can review the ledger and adjust boundaries if needed. Governance is autonomous within constraints; supervision is human-controlled.
Related concepts
- What is runtime AI governance? — The architecture that enables governed agency
- REBAC (relationship-based access control) — How agent evidence scope is enforced
- Boundary Gate — The policy enforcement layer for agent actions