Seal what your enforcement engine
was configured to enforce.
Verifiable offline, after the policy is gone. Every policy’s exact text, the mode it ran in, the role and the authorizer, sealed into a bundle your counterparty checks with no network, no access to your cloud account, and nothing of ours installed.
Your enforcement engine decides whether the agent may act. Rends makes that decision portable, and provable to someone who has no reason to trust you.
The problem, stated without villains
Agent authorization has arrived as infrastructure. Amazon Bedrock AgentCore intercepts tool calls at its gateway and evaluates them against policy before execution. Microsoft ships agent identity. This is the right architecture, and it is becoming standard.
That architecture solves enforcement for one party governing itself. The operator writes the policy, runs the engine, holds the record, and configures retention. When those are the same party, that is entirely sufficient.
Regulated deployments are not one party. A bank evaluating a vendor’s agent is being asked to accept evidence produced, stored, and attested by the vendor it is evaluating. Nothing is wrong with the record. The problem is who holds it.
The distinction, in one exchange
- Bank:
- Show me that the agent was authorized to move that money.
- Vendor:
- Here's the log.
- Bank:
- Who wrote that log?
- Vendor:
- We did.
That is the entire gap. Not whether the control worked — whether anyone outside your company can confirm it did.
What we measured
We stood up Amazon Bedrock AgentCore Policy in a real AWS account — gateway in enforcing mode, Cedar policies, a live tool behind it — and ran allow, deny and tamper scenarios against it on 2026-09-13 in us-west-2. Raw output is in the reproduction repository at github.com/eishops23/rends-agent-authz-reproduce.
An outside party can establish exactly what an AgentCore gateway was configured to enforce — offline, credential-free, with nothing of Rends installed, and including the Cedar text of a policy the operator has since deleted. A default AgentCore deployment retains counters, not per-decision records. A gateway with trace delivery configured does emit a per-decision record — but it names the deciding policy, not the agent that asked or what it asked for.
On 2026-09-13 we enabled CloudWatch Transaction Search, raised indexing to 100%, granted the gateway role permission to write traces, and ran one allow and three enforced denials in the same window. The allow produced six spans in thirteen seconds — every one of them the tool Lambda’s. The gateway emitted none of its own, while propagating trace context downstream, so the decision sits in the trace as a reference to a span that never arrives. Twenty-two seconds later, three enforced denials produced nothing at all: no span, no trace, no log line.
We were wrong, and here is the re-test. That measurement was taken against incomplete instrumentation. AgentCore documents per-gateway trace delivery as a separate enablement step, and it was never configured on the gateway under test. We said we would publish the re-test whichever way it came back. It came back against us.
With trace delivery configured, the same gateway emits a span for every authorization decision — including denials. The denied call produced an AgentCore.Policy.AuthorizeAction span carrying the decision, the reason, and the Cedar policy that produced it by name, plus the enforcement mode, the policy-engine ARN and a unique request id. The trace also resolves properly: the gateway is the entry point, and the dangling reference we described was the missing delivery, not a gap in the product. A denial is recorded, not merely counted, on a correctly configured gateway.
One caution against over-correcting in the other direction. The decision span names the policy — it does not name the principal. There is no agent identity and no delegated human identity on it, the call arguments do not appear, and the policy is identified by id rather than by version. So the record establishes that a decision happened, which policy decided, and what it decided. It does not establish who asked or what they asked for.
We can now verify the decision itself, within one hard limit. With trace delivery configured, the gateway’s own AgentCore.Policy.AuthorizeAction spans can be pulled into a hash-linked bundle and checked by a counterparty offline — the same envelope, and the same verifier, as the configuration seal above. It establishes that a decision happened, which Cedar policy decided, and whether it allowed or denied. It does not establish who asked or what they asked for, because the record AWS emits contains neither, and no amount of work on our side adds them to it. A configuration seal says what the rule was; a decision record says that it fired. Together they answer a question neither answers alone — and they still do not answer “who”.
What we have captured this way is 52 decisions — 26 allow and 26 Cedar default-deny, all at enforcement mode ENFORCE — taken on 16 September 2026 and sealed into a bundle a counterparty can check offline. An earlier capture, taken on 14 September 2026, holds two decisions: one allow, and one deny determined by a named forbid policy. It is kept because it is the only capture that shows that path. Neither is a throughput claim.
A practical note for anyone reproducing this: vended trace delivery takes minutes to become active. A run fifteen seconds after configuring it reproduced the old result exactly. A four-minute wait changed the answer. Reading a pipe before it is carrying is how the original error was made.
What it did well
- Deterministic interception. A denied call never reached the tool — not blocked after the fact, prevented.
- Typed schema validation at authoring time. A policy comparing a decimal field to a whole number was refused on creation, with the type error named.
- Default-deny, and it hides the tool. With no permitting policy, the tool did not appear in the agent's tool list at all.
- Overly-permissive policies refused outright — the analyzer enumerated every combination the policy would have opened, including tools that did not exist yet.
- The decision counter is append-only. There is no API to delete a metric datapoint, and the reserved namespace refuses operator writes.
What a default deployment retained
In its default configuration, with tracing not enabled, the deployment retained fifteen CloudWatch metrics and no log groups. Allow and deny arrive as counters, dimensioned by which policy decided — and without the principal, the arguments, or the policy version.
A denial is counted, not recorded. You cannot reconstruct a particular decision from it.
Per-decision spans are available — they require tracing enabled on the gateway and CloudWatch Transaction Search enabled per account and region. We measured the default first, deliberately, because the gap between the two is the finding. Our first attempt at the traced configuration was incomplete — per-gateway trace delivery is the step we missed — and the corrected re-test is above. Nothing here says AgentCore cannot record decisions, and with delivery configured it demonstrably does.
Architecture
The adapter never sits in the action’s path. Your engine decides and the action proceeds. Rends receives the decision afterward, out of band. It is not in your critical path, so it cannot add a failure mode to it. We will publish the measured overhead when the adapter ships rather than claiming a number now.
Steps 3 and 4 are under construction. The AgentCore adapter and external anchoring of chain heads are not yet available as product. A capture tool exists and we have run it against our own AWS account — the bundle described on rends.ai/verification is its output: 52 decisions taken on 16 September 2026, read across two pages, verified offline in a clean room. It is one-shot, it is not scheduled, and no bundle links to the one before it, so it measures a decision stream and does not yet keep one. Steps 1, 2 and 5 are live today: AgentCore enforces, and Rends evidence is verifiable offline, without access to Rends systems, with the tools at rends.ai/verify.
The out-of-band latency claim above describes the design. It has not yet been measured against a running adapter, and we will publish the measurement rather than the intention.
What the evidence actually contains
- which policy produced the decision
- the verdict, with denials recorded as first-class records rather than counters
Five further properties are being built. The arguments as evaluated — today the record carries a SHA-256 over the action type, name, resource type and a caller-supplied summary string. The raw arguments are never transmitted and are not stored, so a value in a past decision cannot be read back or totalled from history. A delegated-identity pair — which agent requested the action AND which human it acted for, on the same record. Today the chain records one actor per row; the agent and the human it acted for are not carried together, and we do not claim they are. A sequence number per agent and per session, so that a missing record leaves a visible hole; and a chain position published outside the operator’s control; and provable approval ordering — that an approval preceded the execution it authorised. Approvals are recorded today and can be joined to an execution by id, so the ordering is readable. But the approvals table is not part of the hash chain, so that ordering is not tamper-evident, and we do not claim it is.
Today the chain is hash-linked and checkpointed per organization, which makes an altered or removed interior record detectable. Neither per-agent sequence numbering nor third-party anchor custody is in place yet, and we do not claim them.
Denials matter most. Proving an action did not happen is the hardest thing to evidence and the first thing a risk team asks about.
Why this holds up
Verifiable offline Live
An open-source, zero-dependency verifier validates a bundle with no Rends account, no network call, and no live service. Your customer’s retention obligation outlives its vendors — including us.
Deterministic Live
No model sits in the decision path. The evaluation is a pure function — no I/O, no clock, no randomness.
Tamper-evident Live
Records are hash-linked, and the verifier distinguishes a valid bundle from a modified one by exit code — a changed record, a broken signature, or a missing segment each fail distinctly.
Externally anchored In build
Chain heads published where the operator cannot reach them. Without it, a hash chain proves the internal consistency of a history that could have been rebuilt wholesale — which is why we are building it rather than describing the chain as though it were already true.
Integration
The integration is intended to be small: point the adapter at the AgentCore decision stream, configure the anchor target, done.
We are not printing a code sample for an interface you can point at your own stream, because that interface does not exist yet. The code that produced the bundle on rends.ai/verification does exist and is in the reproduction repository — it reads our log group with our credentials, which is exactly why it is not an integration. When the customer-facing adapter ships, a real, runnable block goes here.
What this does not prove
Rends provides integrity and chronology for the authorization evidence it observes, verifiable offline, without access to Rends systems. It does not, by itself, attest that every execution traversed the observed enforcement boundary. An operator who routes an action around the gateway produces no decision for Rends to seal.
Sequence continuity makes omission visible within the observed stream. It does not make omission impossible upstream of observation.
Where a customer requires provable completeness, that needs a completeness mechanism verifiable offline, without access to Rends systems — signed execution receipts, dual-source reconciliation, or in-path placement. Those are on the roadmap and demand-gated. They are not shipped, and we would rather you read that here than discover it in an audit.
Enforcement sources
Rends seals the configuration an enforcement engine was running, and ingests decisions from any engine that emits them. Anything producing a decision — allow, deny, or escalate — with an identifiable subject, action, and policy reference can be a source. The adapter for a given source is a connector, not a rebuild.
Verified against
| Source | What we ran | Date |
|---|---|---|
| Amazon Bedrock AgentCore Policy | Gateway in enforcing mode, Cedar policies, live AWS account; allow, deny, restricted-destination and tamper scenarios. CloudWatch Transaction Search enabled and read; per-gateway trace delivery initially missed, then configured and re-run. With delivery configured the gateway emits a span for every authorization decision, denials included — naming the deciding Cedar policy, but not the principal or the arguments. Gateway configuration sealed and re-verified after the sealed policy was deleted. | 2026-09-13, us-west-2 |
That is the entire column. We will add each source as it is verified, with the date it was verified.
Designed to sit above
Cloud and identity enforcement
- Microsoft Entra Agent ID — agent identity and scoped authorization
- Okta and Auth0 — agent identity and access controls
- Self-hosted Cedar or OPA policy engines
Runtime agent security and governance platforms
- ServiceNow — agent governance and controls inside the workflow platform where the actions originate
- Zenity — runtime agent action control
- Check Point and Lakera — runtime agent security and tool-call policy
- Holistic AI — runtime agent controls
- WitnessAI — enterprise AI activity control
- Credo AI — governance, policy and evidence
- HumanLayer — human approval before consequential actions
Vendor and in-product enforcement
- Backbase Sentinel and comparable in-platform authority layers
- Any proprietary gateway or middleware built in-house
Nothing in this column has been tested, and naming a system here implies no partnership, endorsement, or relationship of any kind. These are interoperation targets. Only AgentCore has been built and tested, and it is in the column above with the date. The rest describes the shape the adapter is designed for — the requirement is a decision with an identifiable subject, action and policy reference, not a particular product.
How it is packaged
One enforcement source is included in every paid tier. The adapter is what removes the rip-and-replace objection. Charging separately for it would tax the thing that makes Rends adoptable by a team that already runs an enforcement engine.
Multiple sources is the enterprise trigger. When a customer runs AgentCore in one business unit, Microsoft Entra Agent ID in another, and a vendor’s own gateway in a third, normalization is the product.
Independent custody is enterprise. External anchoring to a witness the customer selects, multi-witness co-signing, and customer-nominated destinations. Every tier gets the chain and the offline verifier.
Metered on sealed decisions, not seats. The cost driver is the volume of evidence, which scales with your agent deployment rather than your headcount.
We are not publishing figures yet. Talk to us and we will quote against your workflow.
Work with us
We’re looking for a small number of teams already running agents that take real actions. One workflow, six weeks, scoped and paid. You keep the evidence.
Talk to us about a pilotCapability statements on this page were last reconciled on , against Amazon Bedrock AgentCore Policy as documented by AWS on that date. AgentCore is developed by Amazon Web Services and ships frequently; capabilities described here may have changed since. Rends works with Amazon Bedrock AgentCore. Rends is not affiliated with, endorsed by, or certified by Amazon Web Services. “Amazon Bedrock”, “AgentCore”, and “AWS” are marks of Amazon.com, Inc. or its affiliates.