We have a problem at Praeva.
Our adversarial agents have been trying to do things they aren't authorized to do, and our authority controls have been stopping them.
Normally, that would be good news.
Unfortunately, we're trying to build infrastructure that other people will eventually trust to stop consequential actions in their own systems. Being pleased with ourselves isn't much of a testing strategy.
So the next question is considerably less comfortable.
What if the agent simply goes around Praeva?
A successful DENY isn't enough
In our last installment, we turned a collection of adversarial agents loose in a synthetic procurement environment.
Twenty real AI-model sessions produced $3,072 in eligible purchase demand against a shared $1,000 spending authority. The protected system committed $972.
In a separate test, we allowed five transactions to pass their initial authority checks, held them just before commit, and revoked the common parent authority.
All five were rejected. No unauthorized orders committed.
Those were encouraging results. More importantly, we inspected the downstream transaction records rather than accepting our own dashboard's assessment of success.
But those tests also raised another question.
What happens when an agent finds a route to the business system that never passes through the authority control?
A perfectly functioning checkpoint is of limited use if there's an unlocked door around the corner.
The problem with building your own security tests
Amok and our Orcas are intentionally unpleasant.
They probe boundaries, try alternative approaches, and look for ways to accomplish an objective after a particular request has been denied.
We've tested identity binding, delegated spending limits, revocation during execution, privileged credential issuance, and completed-ticket replay. Those tests have exposed useful behavior, and the results have helped us understand what our architecture actually enforces.
But there's a limitation we need to acknowledge.
We designed the environment. We defined the interfaces. We selected the scenarios. And we evaluated the evidence.
That's founder testing, not independent assurance.
An outside engineer might discover a path we never considered. A real enterprise integration might introduce a shortcut that bypasses the gateway. Two transactions arriving simultaneously might expose a weakness that a sequential test never sees.
And an agent doesn't particularly care that we drew a nice architecture diagram.
If another route works, that route is the one we need to worry about.
The control has to survive the execution path
Praeva's central premise is that an AI agent's ability to access a system is not proof that it has legitimate authority to perform a particular action.
We separate the credential that provides technical access from the delegated business authority that justifies the action.
That authority needs to be current, properly delegated, and valid for the specific action, resource, and purpose.
But none of that matters if the protected business system accepts the operation through an alternate route.
This is why the next engineering phase cannot be limited to testing whether Praeva makes the right decision.
We need to test whether consequential operations can happen without a valid Praeva decision at all.
We also need to know what happens when the gateway becomes unavailable, when a previously issued execution ticket is reused, when an approval is revoked halfway through a workflow, or when the evidence describing an action is altered.
The answers must come from the actual execution path, not merely from the system reporting that it did its job.
Evidence shouldn't be a matter of trust
We've talked quite a bit about Authority Receipts.
A receipt should tell an organization which agent requested an action, who originally delegated its authority, which constraints applied, and why the action was allowed, denied, or escalated.
That is useful.
But if those receipts can be altered without detection, we have another problem.
A system that evaluates its own behavior, records its own conclusions, and supplies the only evidence of its own success creates an uncomfortable amount of trust in one place.
Independent verification matters. So does protecting the integrity of the evidence and connecting an authority decision to the outcome recorded by the actual target system.
A record saying DENY is not proof that an action was prevented.
A record saying ALLOW is not proof that the eventual transaction remained authorized.
And a beautiful dashboard isn't proof of either.
What comes next
Praeva's founder proof-of-concept demonstrated execution-time delegated authority enforcement under controlled, local conditions. We've published the results, including the limitations.
The next phase is harder.
Independent engineers need to challenge the enforcement boundaries, verify the execution evidence, examine failure behavior, and determine whether the same controls survive real integrations.
We need to know where our assumptions break.
If there's a way around the gateway, we want to find it before somebody else does.
If a receipt can be tampered with, we want to know.
If two individually legitimate operations can combine into an unauthorized business outcome, that needs to become another test.
We're not declaring victory because a collection of deliberately troublesome agents couldn't exceed a synthetic spending limit.
We're building toward something that has to stand up when the environment is considerably less cooperative.
Amok isn't finished with us.
Good.
Before action, authority.
About the work: Praeva Founder Proof-of-Concept v1 was tested in a controlled synthetic environment. The results described in #008 do not establish production readiness, comprehensive bypass resistance, or independent security certification. The additional assurance work discussed here represents engineering requirements and future validation, not completed tests.