Over the past year, a lot of the agent-security field has converged on one idea: check every tool call before it runs, outside the model, against a policy. It's the right idea. This post looks at where that work stands, and at the part that's still easy to miss: deciding is not the same as proving.
Why gating at the tool call won
The case for it is now well documented. A few data points from this year:
- A measurement study of nearly 8,000 remote MCP servers found that 40.55% expose tools without any authentication. Each of the 119 OAuth-enabled servers the authors tested had at least one flaw. (Zhou et al., 2026)
- CVE-2025-6514 in
mcp-remote, rated CVSS 9.6, let a malicious MCP server run operating-system commands on the client through a crafted authorization URL. It affected versions 0.0.5 to 0.1.15. (JFrog) - In a live adversarial testbed of 4,437 authorization decisions across 1,151 sessions, social engineering succeeded 74.6% of the time when the model was the main defense. Deterministic policy enforcement at the tool call brought that to 0%, at a median of 53 ms. (Uchibeke, 2026)
The lesson is consistent. A model that is told not to do something can be talked into it. A policy engine that sits outside the model, sees the concrete call and its arguments, and says no, can't be.
The standards are catching up
The IETF draft Agent Action Decision Protocol (AADP), currently an individual Internet-Draft, writes this down as a protocol. It separates who an agent is and what it can reach from "whether a specific proposed action, with specific argument values, may be performed now." Two of its rules are worth quoting. On missing policy: "Absence of policy is a denial with reason 'default_deny', never a permission." And an action that can't be undone doesn't run on its own; it escalates to human confirmation.
Decision Horizon works the same way. Policy runs outside the model, using Cedar or built-in rules. A verdict is allow, soft_deny (pause for a human) or hard_deny. Anything not explicitly granted is recorded in not_granted, and a call to it is refused.
Deciding is not proving
A policy decision answers "may this run?" An incident review, an auditor or a regulator asks something harder, months later: why was this allowed, by whom, knowing what? To answer that, you need more than the verdict:
- What the agent knew. What it had read before acting, whether that content reached the action, and what it could have read but didn't. A verdict made after the agent read a credential means something different from the same verdict made before.
- The authority at that instant. Permissions change. The record needs the grants that applied at the moment of the decision, not the ones in place today.
- What the human saw. "Approved" means little unless you can show exactly what the approver was shown.
- What the record can't see. Every insertion point has blind spots. Evidence that hides its own gaps gets discounted entirely once someone finds one.
- Proof it wasn't edited. Signed, hash-chained, and checkable offline by someone who doesn't trust the system that wrote it.
Some pre-action systems already sign their decisions, and that's a good start. The difference we care about is what's inside the signature, and whether a third party can check the whole session, not just one decision.
One record per decision, written first
That's why Decision Horizon writes the record before the action, in the same place the policy runs. The intent record captures the sponsor, the authority, the horizon of what the agent knew, the rule and the verdict. The outcome record follows. Both are chained to everything before them in the session. The record format post goes block by block.
Authorization stops the bad action. The record is what lets you show, later, to someone who wasn't there, that the system worked, or exactly where it didn't.