Agentic AI: Where Autonomy Helps, Where Control Must Stay
A trade-offs guide to agentic AI: use agents for open-ended analysis and repair, but keep execution deterministic, context governed, and human checkpoints explicit.
Stack OverflowFabio Marcello SalvadoriExplainer
Four recent AI governance proposals, from industry leaders, discuss who should oversee frontier models, but none address the code that decides whether an agent can execute an action. Using a concrete example from the PIC protocol, the author shows that a JSON Schema validates payload shape but cannot enforce a rule like ‘an evidence identifier must refer to exactly one provenance entry.’ This ambiguity lets two reasonable implementations give different authorization verdicts for the same input, creating a vulnerability similar to HTTP parameter pollution or JWT alg confusion. The author argues that agent-authorization protocols must tighten specifications, add conformance tests, and force deterministic resolution of duplicate identifiers, normalization, and error-check order. Without shared rules at the implementation level, different services with the same policy can reach opposite conclusions about the same proposal.
The article moves from a summary of recent AI governance proposals to a detailed technical analysis of how ambiguous specifications in agent-authorization code can cause security vulnerabilities, illustrating the gap between policy and implementation.
Tightening the PIC agent-authorization specification and adding conformance tests for each ambiguous case, while recommending the same approach for all agent protocols.
JSON Schema validates payload shape but cannot express cross-field constraints like ‘an evidence ID must reference exactly one provenance entry’, leaving resolution to individual implementations.
Normalization (trimming whitespace, lowercasing) at an authorization boundary can cause two services with the same policy to give different verdicts, or break signature verification.
Error-check order is undefined in most specifications, so the same proposal can produce different debug outputs; protocols must fix a deterministic order.
If two provenance entries share the same ID but differ in trust level, one implementation that returns the first match (trusted) may allow a payment, while another that returns the last match (untrusted) blocks it. The same input produces different authorization results, which an attacker can exploit.
If a signature covers a string with uppercase hex digits, a verifier that lowercases the input before signature checking will reject an authentic proposal. Worse, if the verifier checks the signature over the original and then normalizes before applying policy, it enforces policy on a value different from what was signed, potentially changing allow-list matches.
The specification must decide how to resolve duplicate identifiers, require exact value comparison for security-sensitive fields (no normalization), keep integrity and authority separate, derive trust only from verifier-checkable evidence, and fix the order in which error checks run so that the same input always produces the same verdict.
Summaries are generated from the original by a language model. Check the original before relying on it.
See the idea
A trade-offs guide to agentic AI: use agents for open-ended analysis and repair, but keep execution deterministic, context governed, and human checkpoints explicit.
Keep reading
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
One useful email. Unsubscribe anytime.