<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>The Unattested Agent · Behavry</title>
  <link>https://behavry.ai/blog</link>
  <atom:link href="https://behavry.ai/blog/feed.xml" rel="self" type="application/rss+xml" />
  <description>Essays on the independent record for autonomous agents: attestation, evidence, and what it takes to prove what an agent did.</description>
  <language>en</language>
  <lastBuildDate>Wed, 18 Nov 2026 12:00:00 +0000</lastBuildDate>
  <item>
    <title>How to Evaluate an AI Agent Governance Platform: Five Tests to Run Before You Buy</title>
    <link>https://behavry.ai/blog/evaluate-ai-agent-governance-platform</link>
    <guid isPermaLink="true">https://behavry.ai/blog/evaluate-ai-agent-governance-platform</guid>
    <pubDate>Wed, 18 Nov 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>Five hands-on tests for evaluating AI agent governance, from scoped permissions and human approval to independently verifiable evidence.</description>
    <content:encoded><![CDATA[<p>Ask the vendor to govern one workflow you actually plan to put into production. Use a test environment, a named agent, and a resource you control. Bring the person who owns the workflow and the person who will review the evidence. Give them five things to check: who acted, what authority they had, whether a denial stopped the action, what a human approved, and whether anyone outside the platform can verify the record.</p>
<p>Here’s a scenario you can reuse. An engineering agent may read issues and open a draft pull request in one demo repository. It needs a human’s approval to open a ready-for-review pull request in that same repository. Merging and writing to other repositories are outside its grant. Ask the vendor to work through those cases on the same integration. You’ll learn more from the results than from a feature matrix.</p>
<h2 id="1-identify-the-agent-and-who-gave-it-authority">1. Identify the agent and who gave it authority</h2>
<p>Start with the permitted draft PR. Ask the vendor to show the agent’s identity, its accountable owner, and the delegation or policy grant that covered the action. Then find the service identity the downstream system actually saw.</p>
<p>This matters because the same integration account might serve several agents. The downstream system may correctly attribute the call to that account, while the governance platform has the context to tie it to the specific agent and grant.</p>
<p><strong>Pass when</strong> your reviewer can follow the request from the named agent to the applicable grant and reconcile it with the service identity that reached the repository.</p>
<h2 id="2-change-the-target-and-check-that-the-policy-follows-it">2. Change the target and check that the policy follows it</h2>
<p>Keep the requested action the same. Change the target from the approved demo repository to a second test repository outside the grant. Make that second repository available to the integration in the sandbox so the test isolates the governance policy.</p>
<p>Ask the vendor to show which request attributes the policy evaluated and why the two calls received different decisions. Repeat the exercise with the same target and a different action if you also need to confirm that permission to open a PR confers no merge authority.</p>
<p><strong>Pass when</strong> the allowed request can proceed and the out-of-scope request is denied for the expected reason. Record where the decision was made and which resources that control covers.</p>
<h2 id="3-verify-that-a-denial-stopped-the-action">3. Verify that a denial stopped the action</h2>
<p>Have the agent request one action the policy explicitly denies in the test repository. Ask the vendor to show the policy decision and the interception point. Then check the downstream record or resulting repository state using a source you control. A control-plane dashboard tells you what decision was recorded. The downstream check tells you whether the outcome agrees with it.</p>
<p>Ask the vendor to identify the paths covered by the test and what happens if policy evaluation is unavailable. Record any gaps before you decide where to deploy.</p>
<p><strong>Pass when</strong> the evidence shows the denial occurred before the prohibited action reached the target and the downstream check corroborates the expected outcome.</p>
<h2 id="4-make-a-human-approval-specific">4. Make a human approval specific</h2>
<p>Have the agent request permission to open a ready-for-review PR. The approver should see the proposed operation, the repository, and the revision or request details needed to make the decision. Let the request sit pending long enough to confirm it stays held.</p>
<p>Approve it, then try a materially different request in the sandbox. Change the target or revision and confirm that the platform requires a fresh decision. Run a second case in which the human declines.</p>
<p><strong>Pass when</strong> the original action remains held until the right person approves it, the approval applies to the reviewed request, and a declined or materially changed request does not inherit permission.</p>
<h2 id="5-hand-the-evidence-to-someone-outside-the-vendor-console">5. Hand the evidence to someone outside the vendor console</h2>
<p>Export the decision record from the test. Give it to a reviewer with the verification method and, for signed evidence, a trusted signing key or trust anchor. Ask the reviewer to identify the agent, requested action, policy version, decision, and any approval. Have them verify the package, then change a signed field in a copy and confirm the check fails.</p>
<p>A valid signature establishes integrity and authenticity under the key you trust. To prove a change landed in GitHub or another system, reconcile the decision record with evidence from that system. Ask the vendor to show which facts each record supports and how the two records are linked.</p>
<p><strong>Pass when</strong> the reviewer can verify the package independently of the vendor console and explain which parts of the workflow the evidence covers.</p>
<h2 id="bring-this-scorecard-to-the-demo">Bring this scorecard to the demo</h2>
<table>
<thead>
<tr>
<th>Test</th>
<th>Evidence to take away</th>
<th>Result</th>
</tr>
</thead>
<tbody>
<tr>
<td>Identity and delegation</td>
<td>Agent identity, owner, applicable grant, and downstream service identity</td>
<td>Pass / Gap / Untested</td>
</tr>
<tr>
<td>Resource and action scope</td>
<td>Allowed and denied decisions for the paired requests</td>
<td>Pass / Gap / Untested</td>
</tr>
<tr>
<td>Pre-action enforcement</td>
<td>Denial record, control point, and downstream corroboration</td>
<td>Pass / Gap / Untested</td>
</tr>
<tr>
<td>Human approval</td>
<td>Pending record, approver, reviewed request, and decision</td>
<td>Pass / Gap / Untested</td>
</tr>
<tr>
<td>Independent verification</td>
<td>Exported evidence, trust anchor or verification method, and verification result</td>
<td>Pass / Gap / Untested</td>
</tr>
</tbody>
</table>
<p>Score the integration you intend to deploy. For each gap, record whether it affects production approval, who owns it, and what evidence would close it. That gives the people signing off a record they can use after the demo ends.</p>
<p>To see what the fifth test looks like, download Behavry’s signed sample and its matching trust anchor from the Decision Trace page. Open the package in the public verifier and check the result against that anchor. The sample demonstrates verification for a governed sequence. For your own deployment, run the same test on one workflow and reconcile it with the downstream record. <a href="/decision-trace#verify-sample">Get the sample and verify a Decision Trace</a>.</p>
]]></content:encoded>
  </item>
  <item>
    <title>A log you have to trust is not a record</title>
    <link>https://behavry.ai/blog/a-log-you-have-to-trust-is-not-a-record</link>
    <guid isPermaLink="true">https://behavry.ai/blog/a-log-you-have-to-trust-is-not-a-record</guid>
    <pubDate>Thu, 05 Nov 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>Every agent platform now says it keeps the record. Four questions a regulator, auditor or insurer will ask, and why a log cannot answer any of them.</description>
    <content:encoded><![CDATA[<p>Every agent platform now says it keeps the record. The gateways log every tool call. The posture tools build a graph of every agent, identity and data source. One of them published a checklist this week on what CISOs must track for MCP audit logging: log every call, ship it to the SIEM, keep it for the EU AI Act and SOC 2 and ISO 42001. The checklist is correct. Follow all of it and you still do not have evidence.</p>
<p>You have a log. The difference matters the moment someone who is not you has to rely on it.</p>
<h2 id="four-questions-the-log-cannot-answer">Four questions the log cannot answer</h2>
<p>A regulator, an auditor, an insurer or opposing counsel will ask four things about any record of what an agent did. Not one of them is answered by "we logged it."</p>
<p><strong>Who wrote this, and can anyone prove it?</strong> A log row is bytes in a database. The vendor that wrote it can rewrite it. The operator with database credentials can rewrite it. The agent, if it is the one emitting telemetry, wrote it in the first place, and the entity that acts cannot attest to its own behavior.</p>
<p><strong>Has anything been removed?</strong> Retention windows on most agent gateways run seven to thirty days below the enterprise tier. A record that expires before the inquiry starts is not a record. A record where a row can be deleted and nothing downstream notices is worse, because it looks complete.</p>
<p><strong>When did this exist?</strong> Every timestamp in a log was written by the same system that wrote the log. If that system is the party under examination, its clock is not evidence of anything.</p>
<p><strong>Can I check this without you?</strong> This is the one that separates a record from a log. If verifying the evidence means logging in to the vendor's dashboard, or calling their API, or trusting a checkmark their service rendered, then the vendor is vouching for the vendor. That is fine for a dashboard. It is not fine for a filing.</p>
<p>"Cryptographic audit trail" on a feature page does not answer these. A mechanism answers them. So here is ours.</p>
<h2 id="what-behavry-already-does">What Behavry already does</h2>
<p><strong>Every event is signed, not just the export.</strong> Each Decision Trace event carries its own Ed25519 signature and a SHA-256 hash of the event before it, per agent chain. Edit one row anywhere in history and every hash after it breaks, and the row's own signature breaks with it, because the link to the predecessor is inside the signed bytes. Signing keys are per tenant. A customer who wants the key in their own custody can hold it in KMS; we sign through it and never see it.</p>
<p><strong>Every hour, the chain is sealed by clocks we do not control.</strong> Each period's event hashes are rolled into a Merkle root. That root is signed, then timestamped by an RFC 3161 authority whose clock is not ours, then written to the customer's own S3 bucket under Object Lock in compliance mode. Not Behavry, not the customer's root account, not AWS support can delete that object before its retention expires. Only the tamper-evidence layer is written there, never payloads and never personal data, so a GDPR erasure request stays satisfiable after the seal.</p>
<p><strong>Verification needs no Behavry.</strong> The verifier is a separate open repository, behavry-verify, with one third-party dependency, readable end to end in about twenty minutes. It runs air-gapped from the command line, or in the browser at verify.behavry.ai, where nothing submitted is stored, logged or forwarded. It checks the manifest signature, the Merkle root, every event signature, every chain link, and the RFC 3161 token over the anchor digest. Every check runs independently, so "signed by Behavry but missing an event" and "not signed at all" are reported as the different findings they are. A check that cannot run reports SKIPPED. It never reports a pass it did not earn.</p>
<p><strong>The trust anchor comes from the customer, not from us.</strong> An evidence package does not contain the public key needed to verify it, on purpose. It carries a fingerprint so you can confirm you are holding the right key. The key itself is a small JSON file the issuing organization exports once and hands to the auditor out of band. Verify against that and Behavry is not in the loop at all. If you skip that step and let our published registry supply the key, the report says so in plain words: this is Behavry vouching for Behavry. We label the weaker path rather than hide it.</p>
<h2 id="why-we-have-the-record-is-no-longer-the-claim">Why "we have the record" is no longer the claim</h2>
<p>Eighteen months ago, keeping a record of agent actions was the differentiator. It is not anymore. The gateways log. The posture platforms map. The platform vendors ship their own audit for agents built inside their own walls. "We have the record" is now the table, not the stakes.</p>
<p>What still separates a record from a log is four properties together, and we will keep saying them outright:</p>
<ul>
<li><strong>Signed.</strong> Per event, per tenant, with the customer's own key if they want it.</li>
<li><strong>Independently verifiable.</strong> By a third party, offline, against a key the vendor did not hand them, with the weaker path labeled when it is used.</li>
<li><strong>Cross-system.</strong> One chain across every system the agent touched, not one log per platform. Behavry sits in the execution path for custom agents, stdio MCP servers and HTTP MCP backends alike. It does not live inside one model vendor's platform, and it does not need the agent's cooperation to write the row.</li>
<li><strong>Identity-bound.</strong> Every event is bound to the agent identity that acted and the human it acted for, so the record answers "who" without a join against someone else's directory.</li>
</ul>
<p>A platform's own audit log can be signed. It is rarely verifiable without the platform. It is never cross-system, because the platform only sees itself. And it is written by the party whose conduct is in question.</p>
<p>The data-governance tools sit one step earlier and answer a different question: what data could this agent reach, and should it. That is a real question and a good tool answers it well. It is a question about permissions. The record answers what every agent actually did, across every system, in a form a stranger can check. You need both. Only one of them is evidence.</p>
<h2 id="try-it-before-you-believe-it">Try it before you believe it</h2>
<p>Download a sample evidence package and the matching trust anchor from behavry.ai/trust. Install the verifier with <code>pipx install behavry-verify</code>, disconnect from the network, and run it. Then open the package, change one byte in one event, and run it again.</p>
<p>That second run is the product. Everything else is a log.</p>
<hr />
<p><em>Behavry is the system of record for autonomous agents: a signed, independently verifiable Decision Trace of what an agent did across every system it touched. verify.behavry.ai</em></p>
]]></content:encoded>
  </item>
  <item>
    <title>The Control Point Is in the Wrong Place</title>
    <link>https://behavry.ai/blog/the-control-point-is-in-the-wrong</link>
    <guid isPermaLink="true">https://behavry.ai/blog/the-control-point-is-in-the-wrong</guid>
    <pubDate>Thu, 30 Apr 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>Fifty vendors. One structural flaw. None of them will tell you about it.</description>
    <content:encoded><![CDATA[<p>I thought I was the only idiot.</p>
<p>It was not one incident. It was a pattern.</p>
<p>I kept watching agents do things nobody had asked them to do. I would carefully scope a prompt, feel good about it, and then watch the model chain actions I had not planned, infer context I had not intended to expose, and produce outputs that were technically allowed but strategically wrong. Every system in place reported that everything worked exactly as designed.</p>
<p>That should not have been possible.</p>
<p>The deeper issue was structural. There was no inspection point before execution. The entire ecosystem assumed: send a prompt, the model responds, maybe log it, maybe filter the output. Nobody had built a place to inspect what was being sent before it reached the model. No policy enforcement on the way in. No way to redact or reshape a prompt carrying too much information, too much access, or too much implicit permission.</p>
<p>You either trusted the prompt or you cleaned up the mess afterward.</p>
<p>I hate cleanup work.</p>
<p>So I built something. I called it PromptTrap, a pre-execution interception layer that sits between the user and the model, enforcing policy on what is sent, redacting sensitive context, and attributing every request. I open-sourced it and gave it away because I could not yet see its value. Something about it felt patentable. I filed the instinct away and kept moving.</p>
<p>Then MCP arrived.</p>
<p>The Model Context Protocol standardized the execution layer. It provided AI agents with a consistent interface for calling tools, accessing data, and taking actions across enterprise systems. It made the boundary between agent and tool a real, addressable protocol layer.</p>
<p>And I realized that PromptTrap was sitting at the wrong boundary.</p>
<p>The prompt layer is where you shape intent. The tool-call layer is where intent becomes action. The prompt matters, but the tool call is what changes the state of the world. We secured the conversation and left the execution path exposed.</p>
<p>The problem is not missing controls. The control point is in the wrong place.</p>
<p>That was the wrong lesson I had been carrying: do not be careless with prompts. The real lesson was this.</p>
<p>Even when you do everything right, the system still behaves in ways you cannot fully predict or control. That is not a prompt problem. That is an architecture problem.</p>
<hr />
<p>Twelve months later, I have reviewed the architectures of fifty enterprise AI agent security vendors. <em>(I am actually approaching 80 different vendors at this point.)</em></p>
<p>Every major category is represented, including identity platforms, runtime monitors, MCP gateways, LLM firewalls, endpoint agents, and behavioral analyzers. Some have raised hundreds of millions of dollars, and some have already been acquired.</p>
<p>They are all solving real problems.</p>
<p>None of them sit at the point that actually determines the outcome.</p>
<hr />
<p>The pattern looked like this.</p>
<p>An agent with authorized access. A well-engineered prompt. A legitimate task.</p>
<p>A chain of actions nobody anticipated, authorized, or could stop in real time.</p>
<p>The agent was not compromised. Not manipulated. Not running malicious code. It was doing exactly what the combination of its instructions and its access permitted.</p>
<p>The outcome was wrong. The execution was technically correct. Every system agreed it was correct.</p>
<p>Every security layer I had in place was irrelevant. Identity controls confirmed the agent was authorized. Credential scoping granted it exactly the access I had configured. Monitoring tools faithfully recorded every action it took.</p>
<p>What was missing was something that could evaluate the chain of actions before they executed. Not the identity. Not the access policy. The actual tool calls, in sequence and with full context, before they ran.</p>
<p>That does not exist in most enterprise deployments today. This will fail in production before it fails in theory.</p>
<hr />
<p>Twenty years of enterprise security taught me to ask one question.</p>
<p><strong>Who</strong>?</p>
<p>Who is authenticated? Who is authorized? Who is being monitored?</p>
<p>We have spent twenty years getting very good at answering the wrong question. We have built entire categories of tooling around it, and we are still optimizing it. I am part of this problem; I contributed to it.</p>
<p>Agentic AI is not a <em>who</em> problem. It is a <strong>What</strong> problem. What is the agent about to do? What sequence of actions is it assembling? What will the state of the system be after the next tool call executes?</p>
<p>Governing access asks: is this agent allowed to reach this system?</p>
<p>Governing execution asks: should this specific action, with these specific parameters, in this specific context, be permitted to run right now?</p>
<p>Every mature security tool in the market answers the first question. Almost none answer the second. And the gap between those two questions is where the damage happens.</p>
<hr />
<p>When an agent executes a tool call, who records what happened?</p>
<p>In most architectures, the answer is: the agent, or the systems the agent accessed.</p>
<p>The agent generates its own traces. The agent reports its own actions. The agent is the source of truth about what the agent did.</p>
<p>This is a structural flaw.</p>
<p>If the entity that acts is also the entity that attests to its own behavior, you do not have governance. You have self-reporting.</p>
<p>In a financial audit, we do not let a company audit itself and call it independent verification. In physical security, we do not let an employee badge their own access logs and call it accountability. We separate the actor from the attestor. We require that the record of what happened be produced by a system that is not the system being governed. I keep using this example because it works and everyone understands it. There are entire movies about this (Accountant/Accountant 2)</p>
<p>We have not applied this principle to AI agents.</p>
<p>I will call it the Attestation Separation Principle.</p>
<p><strong>The entity that acts cannot attest to its own behavior.</strong></p>
<p>If your current system relies on the agent to describe what it did, you have already violated this principle.</p>
<hr />
<p>Looking at what most of the market is building starts to highlight this issue pretty quickly.</p>
<ul>
<li><p>An SDK hook that runs inside the agent process is not an independent attestation. The hook and the agent share a trust boundary.</p></li>
<li><p>A behavioral monitoring layer that reads the agent’s own telemetry is not independent attestation. The signals come from the system being governed.</p></li>
<li><p>A gateway that logs which MCP servers the agent connected to is not an independent attestation. It records the connection. What happened inside the connection is recorded downstream.</p></li>
<li><p>A JIT credential provider that logs which credentials it issued is not an independent attestation. It records the authorization. What the agent did with that authorization is recorded elsewhere.</p></li>
</ul>
<p>Most of the market is optimizing visibility inside the same trust boundary.</p>
<p>None of this means these tools are useless. They serve real purposes. But none of them satisfy the Attestation Separation Principle. None of them can answer the question that a regulator, a board, or an incident response team will eventually ask.</p>
<p>Most of what is being deployed today can observe failure. It cannot prevent it.</p>
<p>The test is simple: prove what the agent did from a record it could not alter.</p>
<hr />
<p>The architectural requirement is specific.</p>
<p>The governance layer must sit in the execution path. Not adjacent to it. Not downstream of it. In it. The tool call cannot complete without passing through a system that is not the agent.</p>
<p>That system must make a deterministic decision before execution. Allow. Deny. Intercept. Not log. Not detect. Not guide. Decide.</p>
<p>And that system must produce its own record. Independent of the agent’s runtime. Cryptographically verifiable. Tamper-evident. Produced by the entity that governed, not the entity that acted.</p>
<p>This is not a feature set. It is an architectural position.</p>
<p>You cannot observe your way to the chain of custody.</p>
<hr />
<p>The mistake I made a year ago was not being careful with prompts.</p>
<p>The mistake was believing that because the agent was authorized, what it did was governed.</p>
<p>Authorization and governance are not the same thing.</p>
<p>Every enterprise deploying AI agents at scale is making that mistake right now. Not because they are careless. Because the market has not given them the tools to make the distinction.</p>
<p>Are you willing to swallow the risk? Where does the liability fall? At what point does “we have monitoring” become legally indistinguishable from “we knew the risk and chose not to prevent it”?</p>
<hr />
<h2 id="appendix-the-technical-architecture-of-the-problem"><strong>Appendix: The Technical Architecture of the Problem</strong></h2>
<p><em>For practitioners who want to go deeper.</em></p>
<p>If the Attestation Separation Principle is correct, the architecture becomes unavoidable.</p>
<p><strong>Why inline position is the only position that satisfies the principle</strong></p>
<p>The Model Context Protocol defines a client-server architecture. An AI agent (the MCP client) sends tool-call requests to MCP servers: tools, APIs, and databases. The MCP server executes the tool and returns the result.</p>
<p>A governance layer that satisfies the Attestation Separation Principle must sit between the client and the server. Every tool call request passes through it before reaching the MCP server. The governance layer evaluates the request against policy, makes an enforcement decision, and forwards it if permitted. The MCP server never receives an ungoverned request.</p>
<p>Everything else people are deploying today sits outside the execution path.</p>
<ul>
<li><p>A sidecar monitor reads the agent’s outbound traffic without intercepting it. The tool call executes regardless of what the sidecar observes.</p></li>
<li><p>An SDK hook runs in the agent process. The hook and the agent share a process boundary. The hook’s record is generated within the governed system.</p></li>
<li><p>An endpoint agent intercepts at the OS or network layer. Closer to inline, but the interception point is on the same machine as the governed agent.</p></li>
<li><p>An MCP gateway controls which MCP servers the agent can reach. It governs the connection boundary, not the execution of tool calls within an authorized connection.</p></li>
</ul>
<hr />
<p><strong>The policy evaluation model</strong></p>
<p>An inline governance layer evaluates tool calls against structured policy using a declarative engine. Open Policy Agent with Rego is a mature option for this class of problem. Policy rules inspect the tool call method, parameters, the agent’s task context, the delegating user, the data classification of the resources being accessed, and the cumulative sequence of prior tool calls in the session.</p>
<p>The enforcement decision is deterministic. Given the same policy and tool call, the decision is always the same. This is structurally distinct from LLM-based guardrails, which are probabilistic. Probabilistic safety applied to deterministic execution is not governance. It is a confidence interval.</p>
<hr />
<p><strong>The audit trail model</strong></p>
<p>Each tool call evaluation produces a Decision Record. The record contains: timestamp, agent identity, tool called, parameters, policy evaluated, decision rendered, and a cryptographic hash linking it to the prior Decision Record in the session chain.</p>
<p>The hash chain ensures that any tampering with a record, whether deletion, modification, or reordering, breaks the chain and is detectable. The chain is produced by the governance layer, not by the agent. The agent cannot produce, modify, or access the Decision Record.</p>
<p>This satisfies the Attestation Separation Principle. The actor and the attestor are different systems.</p>
<hr />
<p><strong>The practical implication for enterprise deployment</strong></p>
<p>An enterprise that can produce a complete, tamper-evident Decision Trace for every agent session can answer the regulatory question. Every tool call is evaluated. Every policy decision is made. Every enforcement action taken. From a system that the agent cannot modify.</p>
<p><em>What did the agent do, and how do you know?</em></p>
<p>An enterprise that relies on the agent’s own logs, platform telemetry, or behavioral monitoring cannot answer that question. It can describe what it observed. It cannot prove what happened.</p>
<p>That distinction will matter more than most people expect and sooner.</p>
]]></content:encoded>
  </item>
  <item>
    <title>Governance Is Not a Security Product</title>
    <link>https://behavry.ai/blog/governance-is-not-a-security-product</link>
    <guid isPermaLink="true">https://behavry.ai/blog/governance-is-not-a-security-product</guid>
    <pubDate>Mon, 30 Mar 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>The real buyer isn't the person who says no. It's the person who needs to say yes.</description>
    <content:encoded><![CDATA[<p>For four articles, I’ve been building a security argument.</p>
<p>Agents are unattested. The entity that acts cannot attest. The record you need is a decision trace, not a log. The only architectural position where enforcement and attestation are possible is inline, in the execution path.</p>
<p>Every word of that is true. But if you stop there, you'll build the right architecture and sell it to the wrong person.</p>
<hr />
<p>Here is what’s actually happening inside enterprises right now.</p>
<p>A CIO or CTO has committed to an AI strategy. The board has approved the investment. The CEO has mentioned it in an earnings call. Engineering teams have built agents — or are deploying off-the-shelf ones — that automate real workflows: code generation, document processing, data analysis, customer support, internal operations.</p>
<p>The agents work. They’re fast. They deliver. The business case is clear.</p>
<p>And then everything stops.</p>
<p>Legal wants to know who’s liable when an agent makes a mistake. Compliance wants to understand how agent behavior will be audited. Risk wants to know what controls are in place. The CISO wants to understand how agent actions are monitored, how data is protected, and how incidents will be investigated.</p>
<p>These are reasonable questions. They are also, in most organizations, unanswerable because the governance infrastructure — independent enforcement in the execution path — doesn’t exist.</p>
<p>So, the AI initiative remains in a staging environment. Alternatively, it goes to production only with a waiver and a prayer. Or it gets quietlyCIO/CTO searches for a way to answer questions no one can currently address. shelved as the</p>
<p>This is the real problem. Not that agents are insecure, but that agents are undeployable.</p>
<hr />
<p>The security industry has characterized AI agent governance as an. Every conference talk, every analyst report, and vendor pitch begins and ends security concer with the CISO.</p>
<p>That framing is understandable. Governance sounds like security. Policy enforcement sounds like security. Audit trails sound like security. The vocabulary maps directly onto the CISO’s domain.</p>
<p>But the CISO isn’t accountable for deployment. The CIO/CTO is.</p>
<p>The CIO/CTO is the person who committed to the board that AI would deliver operational efficiency by Q4. The CIO/CTO is the person whose budget is funding the AI initiative, whose team built the agents, and whose career depends on getting them deployed.</p>
<p>And the CIO/CTO doesn’t need a security product. They need a governance layer that makes deployment possible.</p>
<hr />
<p>Let me make this concrete.</p>
<p>A Fortune 500 company has built an AI agent that automates a significant portion of its internal document processing. The agent reads contracts, extracts key terms, flags anomalies, and routes exceptions to human reviewers. It works. In testing, it reduced processing time by 70% and error rates by half.</p>
<p>The CIO wants it in production. The CFO is asking when the savings will materialize. The CEO mentioned it at an investor event.</p>
<p>Now the governance gauntlet begins.</p>
<p>The CISO asks: “How do we monitor what this agent accesses? Can it read sensitive contracts? What happens if it leaks data to an external API? How do we investigate if something goes wrong?”</p>
<p>Legal asks: “Who is liable if the agent misinterprets a contract clause and we act on that interpretation? Can we produce evidence of what the agent did and why? Will this stand up in discovery?”</p>
<p>Compliance asks: “How does this map to our SOC 2 controls? Can we demonstrate governance to our auditors? What does the audit trail look like?”</p>
<p>Risk asks: “What’s the blast radius if this agent misbehaves? Can we shut it down instantly? How do we know its behavior hasn’t drifted from what was tested?”</p>
<p>Every one of these questions is legitimate. Every one of them is currently unanswerable in most enterprises. And every one of them becomes answerable — immediately — if an independent governance layer exists in the execution path.</p>
<p>The CISO gets accountability: independent attestation, decision traces, behavioral baselines, anomaly detection. The answer to “how do we monitor it” is “every action passes through an independent enforcement point that produces a tamper-evident chain of custody.”</p>
<p>Legal gets evidence: a producible, auditable record of what the agent did, what policy governed the action, who authorized it, and what data was involved. Not a platform log. A decision trace.</p>
<p>Compliance gets demonstrable governance: independent records mapping directly to SOC 2 controls, EU AI Act requirements, NIST AI RMF categories. Not “we have logs.” Actual evidence produced by a structurally independent observer.</p>
<p>Risk gets containment: policy enforcement that can deny or escalate actions before execution, kill switches for immediate suspension, behavioral baselining that detects drift before it causes damage.</p>
<p>And the CIO/CTO gets the only thing that actually matters to them: the ability to say yes.</p>
<hr />
<p>This is the reframe the industry hasn’t made yet, and it changes everything about how governance should be positioned, sold, and prioritized.</p>
<p>When you frame governance as a security product, it lives in the CISO’s budget. It competes with EDR renewals, SIEM expansions, and penetration testing contracts. It gets evaluated by security engineers who care about detection coverage and alert fidelity. It gets prioritized against the security team’s existing roadmap — which is already overloaded.</p>
<p>When you frame governance as deployment infrastructure, it lives in the AI initiative’s budget. It’s not a cost center. It’s the missing layer that unlocks the return on an investment the organization has already made. It doesn’t compete with security tools. It competes with the cost of not deploying — the stalled initiatives, the waivers, the risk acceptances that nobody is comfortable signing.</p>
<p>Security products reduce risk. Infrastructure unlocks execution.</p>
<p>The budget dynamics are completely different. A CISO evaluating a new security tool is managing a constrained budget against a long list of priorities. A CIO/CTO trying to get AI into production is sitting on an approved investment that can’t move forward without a governance answer. One buyer is managing costs. The other is trying to unlock value.</p>
<p>The governance layer is what turns “we can’t deploy this yet” into “we can deploy this now.” That’s not a security pitch. That’s a deployment pitch. And the person who cares most about that outcome is not the CISO.</p>
<hr />
<p>I want to be clear: the CISO is not irrelevant. The CISO is essential.</p>
<p>The CISO is the internal validator. The CISO is the person who confirms that the governance architecture is sound, that the attestation model is independent, that the policy framework is rigorous, and that the evidence it produces will satisfy auditors and regulators.</p>
<p>The CISO’s approval is what gives the CIO/CTO confidence that saying yes won’t come back to haunt them. The CISO is the person who makes the governance answer credible.</p>
<p>But the CISO is not the buyer. The CISO doesn’t wake up thinking about AI deployment velocity. The CISO wakes up thinking about risk. The governance layer reduces the CISO’s risk, and the CISO will champion it for that reason. But the urgency — the budget, the timeline, the executive pressure — lives with the person who owns the AI initiative.</p>
<p>The dynamic is: the CIO/CTO needs to say yes. The CISO needs to not say no. The governance layer serves both — but the person with the deployment problem is the one who will move fastest, pay first, and push hardest for implementation.</p>
<hr />
<p>There’s a pattern here that’s familiar if you’ve watched enterprise technology long enough.</p>
<p>Cloud governance followed the same arc. In the early days of cloud adoption, CISOs were the primary voice in the room. “We can’t move to the cloud until we understand the security implications.” Security teams evaluated cloud platforms against their existing control frameworks. Many enterprises stalled for years.</p>
<p>Then the business pressure became overwhelming. CIOs and CTOs committed to cloud migrations. Boards approved the investments. And suddenly the question wasn’t “should we move to the cloud” but “how do we move to the cloud without creating unacceptable risk.”</p>
<p>Cloud governance platforms — the tools that provided visibility, policy enforcement, and compliance mapping for cloud environments — succeeded not because they made CISOs happy, but because they enabled CIOs to execute a cloud strategy with the CISO’s sign-off. The buyer was the person trying to go faster. The validator was the person making sure it was safe.</p>
<p>AI agent governance is following the same pattern. The CIO/CTO has committed to an AI strategy. The agents are built or being built. The business case is approved. The only thing missing is the governance layer that turns commitment into deployment.</p>
<p>The enterprise that deploys this governance layer first doesn’t just reduce risk. It moves faster. It gets agents into production while competitors are still stuck in staging environments, waiting for governance answers that their security team can’t provide with existing tools.</p>
<p>Governance isn’t a brake. It’s the road.</p>
<hr />
<p>This reframe has implications for how the entire AI agent security conversation should be structured.</p>
<p>Right now, every conference talk about AI agent security starts with threat scenarios. Prompt injection. Data exfiltration. Agent compromise. The audience is CISOs, and the message is: “Here are scary things that can happen, and here’s how to detect them.”</p>
<p>That’s one conversation. It’s a valid one. But it’s not the conversation that moves budgets.</p>
<p>The conversation that moves budgets starts with deployment. “You have agents ready for production. Your CISO can’t sign off because there’s no governance layer. Your legal team can’t sign off because there’s no evidence framework. Your compliance team can’t sign off because there’s no independent attestation. Here’s the architecture that answers all three — and gets your agents into production this quarter.”</p>
<p>That’s not a security pitch. That’s an infrastructure pitch. And it lands differently because it starts with the CIO/CTO’s problem — deployment velocity — rather than the CISO’s problem — threat coverage.</p>
<p>The technical architecture is identical. Independent enforcement in the execution path. Decision traces. Policy-as-code. Behavioral baselines. Attestation separation. Nothing changes about what gets built. Only who it’s built for. And that changes everything about how fast it gets adopted.</p>
<hr />
<p>I’ve spent the first four articles in this series building an architectural argument from the security side. Unattested agents. Attestation separation. Decision traces. Inline enforcement.</p>
<p>Every one of those concepts is correct. Every one of them matters. And every one of them becomes ten times more urgent when you realize that the governance gap isn’t just a security risk — it’s a deployment blocker.</p>
<p>Enterprises are not struggling to secure AI agents. They are struggling to deploy them. The agents work. The business case is proven. The investment is approved. What’s missing is the governance infrastructure that lets the CIO/CTO move forward with the CISO’s blessing.</p>
<p>That infrastructure is not a security product. It is the deployment layer for the age of autonomous AI.</p>
<p>Your CISO gets accountability. Your board gets oversight. Your legal team gets evidence. Your compliance team gets demonstrable governance.</p>
<p>And your CIO gets to say yes.</p>
<hr />
<p><em>Up next in the series — what you can’t see is already running — and why governance starts with a map, not a policy.</em></p>
]]></content:encoded>
  </item>
  <item>
    <title>You Have to Be in the Execution Path</title>
    <link>https://behavry.ai/blog/you-have-to-be-in-the-execution-path</link>
    <guid isPermaLink="true">https://behavry.ai/blog/you-have-to-be-in-the-execution-path</guid>
    <pubDate>Sun, 22 Mar 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>Every generation of security governance eventually learned the same lesson. The AI agent industry hasn't learned it yet.</description>
    <content:encoded><![CDATA[<p>In the first three pieces, I built a case. Agents are unattested. The entity that acts cannot attest. And the record you actually need — a decision trace — can only be produced from a specific architectural position.</p>
<p>Now I want to talk about that position. Because the industry is converging on an approach to AI agent governance that is architecturally incapable of delivering what it promises. And the people promoting it aren’t wrong about the problem. They’re wrong about where you have to stand to solve it.</p>
<hr />
<p>Here is the framing you’ll hear at every conference, in every analyst briefing, and in every vendor pitch this year:</p>
<p><em>“Runtime security for AI agents.”</em></p>
<p>It sounds right. Agents operate at runtime. You need to monitor them at runtime. Therefore: runtime security.</p>
<p>But listen to what’s actually being proposed. Better logging. Threat graphs. Endpoint telemetry. Behavioral detection. Trace-back analysis. SIEM correlation.</p>
<p>Every one of these approaches shares a single architectural property: they observe after the action has occurred.</p>
<p>The agent makes a tool call. The tool executes. The result is delivered. And then — afterward — a detection system notices something suspicious, raises an alert, and an analyst begins an investigation.</p>
<p>This is the observe-and-detect model. It’s the same model the security industry has used for decades. And for a specific category of threat — human adversaries moving at human speed through systems designed for human interaction — it worked well enough.</p>
<p>For autonomous agents operating at machine speed, it is structurally insufficient.</p>
<hr />
<p>I want to be precise about why, because this isn’t a philosophical objection. It’s an architectural one.</p>
<p>When a human employee does something suspicious — accesses a file they shouldn’t, sends data to a personal email, runs an unusual query — the security stack has time. The action takes seconds or minutes. The detection pipeline processes the telemetry. An alert fires. An analyst investigates. If it’s serious, the employee’s access is revoked. The damage is contained, because humans are slow and the response can usually catch up to the threat.</p>
<p>An AI agent doesn’t work like that.</p>
<p>An agent can chain ten tool calls in two seconds. It can read a sensitive database table, extract PII, format it as a summary, and post it to an external API — all before a detection pipeline has finished processing the first event. By the time your threat graph has traced the connection, the data is gone. By the time your analyst reviews the alert, the session may already be over.</p>
<p>Observe-and-detect assumes there’s a meaningful window between action and consequence. For human actors, that window exists. For autonomous agents, it often doesn’t.</p>
<p>This isn’t a speed problem you can solve by making detection faster. It’s a sequencing problem. If your governance model evaluates an action after it executes, you are always behind. You are governing the past. The agent is operating in the present.</p>
<hr />
<p>Recent industry coverage has framed runtime security as “the new frontier” of AI agent governance. The framing is thoughtful. The problem identification is accurate. And the proposed solutions are, almost without exception, observe-and-detect.</p>
<p>Endpoint detection tools that build threat graphs after actions occur. Behavioral monitoring that flags anomalies for human review. Platform logging improvements. SIEM aggregation.</p>
<p>The claim from one major endpoint vendor is that existing EDR tools already handle AI agent monitoring — that because EDR instruments the operating system, it can see everything an agent does and trace it back through a threat graph.</p>
<p>This is technically true and architecturally misleading.</p>
<p>EDR sees process spawns, file system operations, and network connections. It can tell you that application X made a connection to IP Y. It cannot tell you that the connection was an MCP tool call requesting customer records from a CRM database, that the agent’s role didn’t authorize CRM access, that the response contained 4,000 Social Security numbers, or that this was the third hop in a multi-agent delegation chain initiated by an unverified requester.</p>
<p>EDR instruments the operating system. Agent governance requires instrumenting the decision. These are different layers, and conflating them creates a dangerous illusion of coverage.</p>
<p>The same coverage noted — correctly — that some agents can overwrite their own session logs. But instead of recognizing this as a structural failure that requires architectural separation between actor and attestor, the recommendation was to improve logging practices. Get better logs. Capture them earlier. Store them immutably.</p>
<p>That advice secures the warehouse. It doesn’t verify what was put into the truck. We covered this in Article 2. Immutable storage of a self-reported record is still a self-reported record. You’re still storing the testimony of an untrusted witness — just more reliably.</p>
<hr />
<p>The mistake the industry is making right now is not a new one. We’ve made it before with every prior generation of security technology. And every time, we eventually learned the same lesson.</p>
<p><strong>Network security.</strong> In the early days of enterprise networking, security was passive. Network monitoring tools captured packets, analyzed traffic patterns, and flagged anomalies. IDS — Intrusion Detection Systems — would observe traffic and raise alerts. Security teams would investigate after the fact.</p>
<p>It didn’t work. By the time an alert fired, the malicious traffic had already reached its destination. The detection was accurate. The response was too late.</p>
<p>So the industry evolved. IDS became IPS — Intrusion Prevention Systems. Passive monitoring became inline enforcement. The security device moved from beside the network path to inside the network path. It didn’t just observe traffic. It blocked traffic. In real time. Before it reached the destination.</p>
<p>That architectural shift — from observation to inline enforcement — is what made network security functional. Not faster detection. Not better dashboards. A change in position.</p>
<p><strong>Web application security.</strong> Same pattern. Early web security was observational — log analysis, periodic vulnerability scans, post-incident forensics. Then SQL injection, cross-site scripting, and remote code execution made observation insufficient. The response: the Web Application Firewall. Inline. In the request path. Evaluating every HTTP request against a policy before it reaches the application.</p>
<p><strong>API security.</strong> Same pattern again. Early API security was perimeter-based — rate limiting at the gateway, API key validation, post-hoc log analysis. Then API sprawl, broken authorization, and data leakage made perimeter controls insufficient. The response: inline API gateways with per-request policy evaluation, payload inspection, and real-time enforcement.</p>
<p>In every case, the industry started with observe-and-detect. In every case, it was insufficient. In every case, the solution was the same: move the security control from beside the path to inside the path. From passive to inline. From after the action to before it.</p>
<p>AI agent governance is following the same arc. The industry is in the observe-and-detect phase right now. The architectural endpoint is inline enforcement. The only real question is whether organizations get there before or after a preventable incident forces the shift.</p>
<hr />
<p>What does inline actually mean in the context of AI agents?</p>
<p>It means every action an agent takes — every tool call, every API request, every database query, every file operation — passes through an independent enforcement point before it reaches the target system. Not after. Before.</p>
<p>At that enforcement point, the action is evaluated against policy. The agent’s identity is verified. The agent’s permissions are checked against the specific action being requested. The payload is inspected for sensitive data. The action is assessed against the agent’s behavioral baseline. And based on all of that — in real time, before execution — the action is allowed, denied, or escalated to a human for review.</p>
<p>If the action is allowed, it passes through to the target system. If it’s denied, the agent receives an error and the target system never sees the request. If it’s escalated, the action is held until a human approver makes a decision.</p>
<p>This is not a new concept. It’s how firewalls, WAFs, and API gateways already work. The only thing that’s new is the protocol and the actor.</p>
<p>For AI agents communicating through MCP — the Model Context Protocol, which is rapidly becoming the standard for agent-to-tool communication — inline enforcement means an MCP proxy. The agent points its configuration at the proxy instead of directly at the target MCP server. Every tool call passes through the proxy. The proxy authenticates, evaluates policy, inspects data, and makes an enforcement decision — all before the target system is ever contacted.</p>
<p>The agent doesn’t need to be rewritten. The target system doesn’t need to be modified. The enforcement layer sits between them, independently, in the execution path.</p>
<hr />
<p>There’s a reason inline enforcement matters beyond speed, and it connects directly to everything I’ve written in this series.</p>
<p>Inline is the only position from which a decision trace is producible.</p>
<p>Remember the six elements from the last piece: identity context, policy evaluation, data classification, causal linkage, requester provenance, integrity chain. Every one of them requires the attestation layer to be present at the moment of action. Not before the agent was deployed. Not after the action completed. At the moment the tool call is made.</p>
<p>An observer that sits beside the execution path — a SIEM, an EDR, a log aggregator — can only record what it receives from the acting system. It’s downstream. It sees what the platform chose to emit.</p>
<p>An observer that sits in the execution path sees everything. It sees the request before it reaches the target. It sees the response before it reaches the agent. It evaluates policy at the moment of decision. It classifies data in transit. It links causal chains in real time. It produces a record that the agent cannot influence, because the agent’s request must pass through the observer to reach its destination.</p>
<p>Inline enforcement and independent attestation are not two separate capabilities. They are the same architectural position delivering two outcomes: governance and evidence.</p>
<p>You cannot have a decision trace without being inline. You cannot enforce policy before execution without being inline. You cannot classify data in transit without being inline. You cannot stop a bad action before it happens without being inline.</p>
<p>Every other position is a compromise. Useful, perhaps. Necessary for defense in depth, certainly. But structurally incapable of delivering the primary governance function: ensuring that autonomous agents operate within policy, with independent evidence that they did.</p>
<hr />
<p>I want to address the “defense in depth” argument, because it’s the reasonable objection.</p>
<p>Experienced security leaders will say: “We don’t pick one layer. We build multiple layers. EDR at the endpoint. SIEM for aggregation. Inline enforcement at the proxy. Build all of them.”</p>
<p>They’re right. Defense in depth is sound doctrine. Nobody should stop using their SIEM or decommission their EDR because they’ve deployed an inline enforcement layer.</p>
<p>But defense in depth has a hierarchy. Not all layers are equal. Some layers are supplementary. Some layers are foundational.</p>
<p>For AI agent governance, inline enforcement is the foundational layer. It’s the only layer that can produce a decision trace. It’s the only layer that can stop an action before execution. It’s the only layer that can enforce policy at machine speed. It’s the only layer that satisfies the attestation separation principle — because it’s structurally independent from the agent and positioned to observe every action.</p>
<p>Everything else is supplementary. EDR adds OS-level visibility. SIEM adds correlation and long-term storage. Platform logging adds developer observability. All valuable. None sufficient.</p>
<p>The industry’s mistake is not in building supplementary layers. It’s in treating supplementary layers as if they were foundational. Telling CISOs that EDR already handles AI agent monitoring is like telling them a security camera already handles access control. It records what happened. It doesn’t prevent what shouldn’t.</p>
<hr />
<p>There’s a reason the industry keeps defaulting to observe-and-detect despite the architectural limitations. It’s familiar. It fits existing toolchains. It doesn’t require anyone to change how agents are deployed. It lets vendors say “you’re already covered” and lets CISOs check a box without deploying new infrastructure.</p>
<p>Inline enforcement is harder. It requires an architectural change. It requires agents to route through a new layer. It requires policy to be written and maintained. It requires an independent identity service for agents. It requires someone to take responsibility for a new piece of infrastructure in the execution path.</p>
<p>But “harder” and “wrong” are different things. Network security was harder after the shift from IDS to IPS. Web security was harder after WAFs became standard. API security was harder after inline gateways became the norm. In every case, the harder approach was the one that actually worked.</p>
<hr />
<p>Every enterprise security architecture eventually reaches the same conclusion: if you want to govern behavior, you have to be in the path where behavior occurs.</p>
<p>Not beside it. Not downstream of it. Not reading reports about it after the fact.</p>
<p>In it.</p>
<p>The entity that acts cannot attest. A decision trace can only be produced from the execution path. And policy can only be enforced before the action — not after.</p>
<p>The principle is straightforward. The implementation is work.</p>
<p>If you want to govern autonomous behavior, you have to stand where the behavior happens. In the execution path. Before the action. Not after.</p>
<hr />
<p><em>Next in this series: why agent governance isn’t a security product — it’s deployment infrastructure. The real buyer isn’t the person who says no. It’s the person who needs to say yes.</em></p>
]]></content:encoded>
  </item>
  <item>
    <title>A Decision Trace Is Not a Log</title>
    <link>https://behavry.ai/blog/a-decision-trace-is-not-a-log</link>
    <guid isPermaLink="true">https://behavry.ai/blog/a-decision-trace-is-not-a-log</guid>
    <pubDate>Sat, 21 Mar 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>The record your security team actually needs can only be produced from one architectural position. And almost nobody is in it.</description>
    <content:encoded><![CDATA[<p>In the last two pieces, I identified a problem — the unattested agent — and a principle: the entity that acts cannot be the entity that attests.</p>
<p>I want to ensure we all agree. Yes, the attestation gap is genuine. Yes, agents are self-reporting. Yes, we require independence.</p>
<p>Then the follow-up question: <em>“Okay, so what should the record actually look like?”</em></p>
<p>That’s the right question. And the answer is more specific than most people realize — because the record you need isn’t just different in content from a traditional log. It’s different in kind. It can only be produced from one architectural position — and it’s the one the industry keeps overlooking.</p>
<hr />
<p>Let’s start with what you have today.</p>
<p>When an AI agent makes a tool call: reads a file, queries a database, sends an email, calls an API, the platform may log something. Even a well-instrumented platform log looks like this:</p>
<p><em>Timestamp. Agent name. Tool called. Parameters passed. Response code. Latency.</em></p>
<p>That’s helpful. It explains what occurred, approximately when, and if it was successful.</p>
<p>Now, try to answer these questions from that log:</p>
<p><strong>Who authorized this action?</strong> Not the human who deployed the agent three weeks ago. Who — or what policy — authorized this specific tool call at this specific moment?</p>
<p><strong>Was this agent permitted to call this tool with these parameters?</strong> Not “does the agent have API access.” Was <em>this particular call</em> to <em>this particular resource</em> evaluated against a policy before it executed?</p>
<p><strong>What was the agent’s identity context at the time of the call?</strong> What role was it operating under? What permissions were active? What risk tier had it been assigned? Had its behavioral baseline shifted?</p>
<p><strong>Was there sensitive data in the request or response?</strong> Was the payload scanned? What was found? What classification was applied? Was anything redacted, blocked, or flagged before it reached its destination?</p>
<p><strong>What happened immediately before and after this call?</strong> Not in the same log file. In the causal chain. What triggered this action? What did the agent do with the result? Was this the first step in a sequence that ended somewhere it shouldn’t have?</p>
<p><strong>If this agent was operating as part of a multi-agent workflow, who delegated the task?</strong> Was the delegation authorized? Did the delegating agent have the authority to grant those permissions? Can you trace the chain of authority back to a human decision?</p>
<p>A platform log answers none of these. Not because the platform is poorly built. Because the platform isn’t in the right position to capture any of it.</p>
<hr />
<p>This is the distinction that matters, and it’s the one the industry keeps undermining.</p>
<p><strong>A log is a record of what happened.</strong> It’s produced by the system that performed the action. It captures the system’s own view of what it did.</p>
<p><strong>A decision trace is a record of what happened, why it was allowed to happen, who authorized it, what policy governed it, what data context surrounded it, and where it sits in a causal chain of actions.</strong></p>
<p>A log is a line in a file. A decision trace is a chain of custody.</p>
<p>A log tells you the agent called <code>read_file</code> on <code>/payroll/salaries.csv</code> at 14:23:11 and got a 200 response.</p>
<p>A decision trace tells you:</p>
<p>The agent <code>hr-assistant-03</code> — operating under role <code>hr-read-only</code>, with a current behavioral anomaly score of 0.3, in an active session authenticated 14 minutes ago made a <code>read_file</code> call targeting <code>/payroll/salaries.csv</code>.</p>
<p>The call was evaluated against policy <code>filesystem.sensitive_read</code> by an independent policy engine. The agent’s role includes <code>filesystem:read</code> but not <code>filesystem:sensitive_read</code>. The policy result was <code>escalate</code>. A human-in-the-loop notification was sent to the designated approver.</p>
<p>Approval was received 47 seconds later. The file contents were scanned for sensitive data; matches were found for patterns <code>ssn</code> and <code>salary</code> with severity <code>critical</code>. The response payload was classified as <code>GOVERNMENT_ID</code> and <code>FINANCIAL</code>. The payload was delivered to the agent with matched values redacted. The action was the third in a causal chain initiated by a user request through the <code>hr-portal</code> interface, with requester identity verified via delegation token.</p>
<p>The full chain: from user request to orchestrator to agent to tool call to policy evaluation to data classification to redaction to delivery is linked by causal parent IDs and independently hashable for integrity verification.</p>
<p><strong>That is not a log. That is a decision trace.</strong></p>
<p>And there is no way to produce it from inside the acting system, not from the agent, not from the platform, not from telemetry aggregated after the fact.</p>
<hr />
<p>This is the point where I need to be very precise, because the architectural argument is everything.</p>
<p>A decision trace requires six things to be captured at the moment of action, not reconstructed afterward, not inferred from logs, not assembled by a SIEM.</p>
<p><strong>Identity context.</strong> Not just “which agent.” The agent’s authenticated identity, its active role, its permission set, its risk tier, and its behavioral anomaly score at the time of the call. This requires an identity service that operates independently of the agent platform.</p>
<p><strong>Policy evaluation.</strong> The specific policy rule that governed this call, the inputs to the evaluation, and the result — allow, deny, or escalate. This requires a policy engine that evaluates every action before its execution, not a scanner that reviews actions after the fact.</p>
<p><strong>Data classification.</strong> Whether the request or response contained sensitive data, which patterns were matched, what severity was assigned, and what action was taken — redaction, blocking, or passthrough. This requires a data protection layer that inspects payloads in transit, not a DLP tool that scans storage at rest.</p>
<p><strong>Causal linkage.</strong> Where this action sits in a chain of prior actions, what triggered it, and what the agent did with the result. If it’s part of a multi-agent workflow, identify which agent delegated the task and whether that delegation was authorized. This requires an observer who can track every action in the chain, not just the starting and ending points.</p>
<p><strong>Requester provenance.</strong> Who or what initiated the chain of actions leading to this call? A human user? Another agent? An automated trigger? And is that identity verified or just asserted? This needs requester tracking that is independent of the agent’s own reporting.</p>
<p><strong>Integrity chain.</strong> A cryptographic linkage — hash chains or signed records—that makes the decision trace tamper-evident. If any event in the chain is modified, inserted, or deleted, the integrity is broken and tampering becomes detectable. This requires the record to be produced and stored by an entity that the agent cannot influence.</p>
<p>These six elements are not just a wish list. They are the essential requirements for a record that a regulator, an auditor, or a plaintiff’s attorney would accept as credible evidence of governance.</p>
<p>And every one of them requires the same architectural precondition: an independent observer positioned in the execution path between the agent and the systems it acts on.</p>
<hr />
<p>This is why the architectural position matters more than the tooling.</p>
<p>A SIEM can store a decision trace. It cannot produce one. A SIEM receives whatever the upstream source chooses to emit. If the upstream source is the agent’s own platform, the SIEM is storing a self-report — durably, securely, immutably. You’re still storing the testimony of an untrusted witness — just more reliably.</p>
<p>An EDR tool can detect that an application made a network call. It cannot tell you whether the policy engine evaluated the call before execution, what data classification was applied to the payload, or whether the agent’s delegation authority was valid for that specific action. EDR instruments the operating system. A decision trace requires instrumenting the decision.</p>
<p>A platform’s native logging can be detailed, timestamped, and well-structured. It still cannot produce an independent record, because the platform is part of the acting system. The platform decided to log what it logged. The platform decided what to include and what to omit. The platform’s own integrity is the issue.</p>
<p>The only place a decision trace can be produced is at an independent checkpoint in the execution path — a point where every action passes through, where policy is evaluated before execution, where payloads are inspected in transit, where identity is verified externally, and where the record is written by something the agent cannot touch.</p>
<p>That’s not a design preference. It’s a structural requirement. The same way a black box must be in the aircraft — not in the airline’s back office reading the pilot’s notes — the attestation layer must be in the execution path. There is no other position from which a decision trace is producible.</p>
<hr />
<p>I want to make this tangible, because “structural requirement” can sound theoretical. It’s not.</p>
<p>Consider an incident investigation.</p>
<p>An AI agent with access to your CRM exported a list of customer records and sent them to an external API endpoint. Your security team gets the alert.</p>
<p><strong>With a log,</strong> you know the agent made the call. Maybe you know the timestamp and the destination. You pull the platform log. It says <code>tool: http_post, target: https://api.external-service.com/ingest, status: 200</code>. You don’t know what was in the payload. You don’t know whether the agent was authorized to make external API calls. You don’t know whether anyone approved it. You don’t know if the data contained PII. You don’t know whether this was part of a legitimate workflow or a compromise. Your investigation is a reconstruction exercise — pulling fragments from multiple sources, hoping the pieces fit, knowing that the primary source of evidence is the system you’re investigating.</p>
<p><strong>With a decision trace,</strong> the picture is immediate and complete. The agent was authenticated under identity <code>crm-sync-agent-07</code>, operating under role <code>crm-read</code>, which does not include <code>web:write</code> permission. The policy engine evaluated the <code>http_post</code> call against policy <code>web_api.deny_post</code> and returned <code>deny</code>. The action was blocked before execution. The attempted payload was scanned; matches for <code>email_address</code> and <code>phone_number</code> were found with severity <code>high</code>, classified as <code>PII</code>. The causal chain shows this was the fourth action in a session initiated by an unverified requester. An alert was generated. The full chain is hash-linked and tamper-evident.</p>
<p>The incident investigation didn’t happen after the breach. It happened <em>instead</em> of the breach.</p>
<p>That’s the difference between a log and a decision trace. One helps you understand what went wrong. The other prevents the wrong thing from happening and proves that it did.</p>
<hr />
<p>There’s one more point I want to make, because it’s the one that connects everything in this series.</p>
<p>A decision trace is not just a better record. It is the artifact that makes governance demonstrable.</p>
<p>When a regulator asks “<em>How do you govern your AI agents?</em>” the decision trace is the answer. Not “<em>we have policies.</em>” Not “<em>we have logs.</em>” Not “<em>we have a dashboard.</em>” A decision trace is a producible, auditable, cryptographically linked chain of evidence that shows: this agent, with this identity, under this policy, took this action, with this data context, authorized by this entity, and the record was produced independently by an observer the agent could not influence.</p>
<p>That is what demonstrable governance looks like. And it’s what every compliance framework — SOC 2, EU AI Act, NIST AI RMF — is going to demand once regulators understand what autonomous agents actually are.</p>
<p>The log tells you something happened. The decision trace proves what happened, proves why it was allowed, and proves who authorized it — with evidence the agent itself cannot dispute.</p>
<p>The entity that acts cannot attest. The decision trace is what the independent attestor produces.</p>
<p>And if you don’t have one, you don’t have governance. You have documentation.</p>
<hr />
<p><em>Next in this series: why the only architectural position from which enforcement and attestation are possible is inline — in the execution path — and why every other approach is structurally incapable of governing autonomous behavior.</em></p>
]]></content:encoded>
  </item>
  <item>
    <title>The Entity That Acts Cannot Attest</title>
    <link>https://behavry.ai/blog/the-entity-that-acts-cannot-attest</link>
    <guid isPermaLink="true">https://behavry.ai/blog/the-entity-that-acts-cannot-attest</guid>
    <pubDate>Fri, 20 Mar 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>Why better logs won't save you and what every other accountability domain figured out a long time ago</description>
    <content:encoded><![CDATA[<p>In the first piece of this series, I identified a structural problem: the unattested agent. Autonomous AI agents are operating within enterprise environments with real credentials and permissions, and there is no independent verification of their behavior. The entity performing the action is the same entity creating the record of that action.</p>
<p>The response I’ve received most frequently from security leaders, vendors, and engineers is some version of:</p>
<p><em><strong>“We just need better observability.”</strong></em></p>
<p>More logging. More verbose platforms. Better telemetry. Centralized dashboards. If only we could see enough data about what agents are doing, we’d be fine.</p>
<p>They’re mistaken, and not because observability isn’t valuable. It is. They are wrong because they’ve misunderstood the true nature of the problem.</p>
<p>The unattested agent isn’t an observability gap; it's an accountability gap. And no amount of data can close it because the data itself can’t be trusted.</p>
<hr />
<p>There is a principle at play here that predates AI, software, and computing itself. It appears in every field where accountability is important.</p>
<p><em><strong>The entity that acts cannot be the entity that attests.</strong></em></p>
<p>If you perform an action and only record that action yourself, you have not been governed. You have self-reported, and self-reporting is not evidence; it’s a claim.</p>
<p>This isn't a controversial idea. It’s the foundational assumption behind every accountability system humans have ever built. We just forgot to apply it with AI agents.</p>
<hr />
<p>Consider the domains where we got this right.</p>
<p><strong>Financial auditing.</strong> A public company cannot audit its own books. It doesn’t matter how thorough the internal accounting is, how detailed the ledgers are, or how many controls the CFO has in place. The numbers are not considered trustworthy until an independent external auditor—someone with no financial interest in the outcome—verifies them. This isn’t optional; it’s the law. Sarbanes-Oxley exists because we learned, often painfully, what happens when entities certify their own integrity. Enron had excellent internal records. They were fiction.</p>
<p><strong>Chain of custody.</strong> When a police officer gathers evidence at a crime scene, the evidence does not remain solely in the officer’s possession and later appear in court with only the officer’s testimony as verification. Every transfer is documented, and every person who handles the evidence is recorded by someone other than the original handler. The chain of custody exists precisely because we do not trust any single individual to be the sole witness to their own handling of important material.</p>
<p><strong>Aviation.</strong> A pilot does not record a flight’s events. The flight data recorder — the black box — captures what happened independently of the pilot’s actions, memory, or intentions. It exists precisely because, after a crash, the pilot’s account (if they survive to give one) is not enough. We need an independent record created by something that was in the execution path but not making decisions.</p>
<p><strong>Pharmaceutical manufacturing.</strong> Every batch of medication is tracked from raw material to finished product. The equipment that makes the drug does not certify the drug. An independent quality assurance process with its own instrumentation, record-keeping, and verification chain of verification attests that the manufacturing process meets requirements. The production line and the attestation layer are structurally separate.</p>
<p>These are not merely analogies; they are implementations of the same principle. The entity that acts cannot attest to its own behavior because self-attestation inherently cannot produce independent evidence.</p>
<hr />
<p>Now, observe how the AI agent industry handles this same problem.</p>
<p>An agent using an API makes a tool call. The platform records the call in its own logging system. If you’re fortunate, the log includes details like timestamp, parameters, and response code. If you’re less fortunate, the log might be sparse, summarized, or missing altogether.</p>
<p>But even in the best case — even with the most verbose, detailed, and meticulously recorded platform log — you have not solved the attestation problem. You’ve addressed a data issue. You know what the platform reports the agent did, but you do not have independent verification that the record is complete, unaltered, or accurate.</p>
<p>The platform is part of the acting system. It produces and stores the log. In some architectures, the platform or the agent running on it can overwrite the log.</p>
<p>This is the equivalent of a company auditing its own books, a police officer being the only witness to their own evidence collection, and a pilot recording their own flight recorder data — all at the same time.</p>
<p>We would not accept this in any of those areas. We shouldn't accept it here.</p>
<hr />
<p>I want to address the most common objection, because I hear it in every conversation.</p>
<p><em><strong>“But we centralize our logs. We pull them into a SIEM. Once they’re in Splunk or Sentinel, they’re immutable.”</strong></em></p>
<p>This misunderstands where the integrity problem lives.</p>
<p>Yes, once a log reaches your SIEM, it’s stored securely. However, the vulnerability isn’t in storage; it’s in generation. The log was created by the entity you’re trying to monitor. It was produced inside the entity’s execution environment. It also traveled through the entity’s own infrastructure before reaching your SIEM.</p>
<p>You secured the warehouse, but you haven't verified what was loaded into the truck.</p>
<p>A centralized SIEM ensures your logs are durable, but it doesn't make them independently trustworthy. The integrity of the record solely depends on the trustworthiness of the source — which is what you’re trying to assess.</p>
<p>This is not just a theoretical issue. It’s an architectural problem. The solution isn’t simply better storage; it's creating a structural separation between the actor and the attestor.</p>
<hr />
<p>There’s a subtler version of this problem that almost nobody is talking about.</p>
<p>When we established governance for human actors, we had an inherent advantage: humans are slow. A human employee makes a decision, takes an action, and leaves traces across multiple independent systems along the way — badge logs, email records, file access timestamps, and network connection logs. The human doesn’t control all of these systems. The traces are spread across infrastructure that the human cannot manipulate. This distribution itself acts as a form of independent attestation, even if we never intentionally designed it that way.</p>
<p>AI agents don’t function that way.</p>
<p>An agent can perform ten tool calls in two seconds. It can read a database, extract a value, call an API, write a file, and send a message — all within a single session, through a single protocol, and logged—or not—by a single platform. There’s no spreading of traces across separate systems. There’s no accidental disconnect between actor and record. The entire sequence of actions and the entire chain of evidence collapse into one entity, one platform, one log.</p>
<p>The issue isn’t the speed; it’s the collapse.</p>
<p>At human speed, the environment provides incidental attestation — not because we designed it, but because humans are too slow and limited to control every system they interact with. At machine speed, that incidental safety net vanishes. The agent can act faster than any independent system can observe, and the only record that keeps up is the one the agent or its platform creates.</p>
<p>This is why “better observability” doesn’t work as an answer. You’re not observing an independent signal. You’re reading a self-report at machine speed and calling it monitoring.</p>
<hr />
<p>So, what does attestation separation actually involve?</p>
<p>It requires exactly one thing: an independent entity in the execution path that is structurally separate from the agent and the agent’s platform, that observes the action at the moment of execution, and that produces its own record; one that the agent cannot modify, overwrite, or suppress.</p>
<p>Not a sidecar that reads logs after the fact. Not a dashboard that aggregates platform telemetry. Not a SIEM that stores whatever the agent’s platform chooses to emit.</p>
<p>An independent observer. In the execution path. Producing its own chain of evidence.</p>
<p>This is the same architecture as a black box on an aircraft. It doesn’t depend on the pilot’s self-report. It doesn’t read the pilot’s notes after the flight. It’s in the cockpit, recording automatically in real time, and the pilot cannot disable it.</p>
<p>That’s what attestation separation means for AI agents. And until it exists in your environment, every agent operating within your enterprise is — by definition — unattested.</p>
<hr />
<p>I want to be clear about the stakes, because this isn’t an abstract architectural debate.</p>
<p>Every compliance framework that matters — SOC 2, the EU AI Act, NIST AI RMF, ISO 27001 — is moving toward the same requirement: demonstrable, auditable governance of autonomous systems. “Demonstrable” doesn’t mean “we have logs.” It means “we can produce evidence that an independent process verified the behavior.”</p>
<p>If your evidence is self-reported by the system under evaluation, it is not independent. It does not meet the requirement. And the first time a regulator, an auditor, or a plaintiff’s attorney pulls on that thread, the entire governance claim unravels.</p>
<p>You aren't missing a tool; you're missing a structural layer. No amount of dashboards, telemetry, or platform-native logging can replace it — just as a company’s internal accounting doesn’t replace an external audit.</p>
<p>The entity that acts cannot attest. Without that separation, you are still accepting the testimony of an untrusted witness — just with better dashboards.</p>
<hr />
<p><em>Next in this series: the difference between a log and a decision trace — why the record your security team needs can only be produced from a specific architectural position, and what that position is.</em></p>
<p><em>Author’s note: AI helped with grammar and readability. It did not help with the opinions.</em></p>
]]></content:encoded>
  </item>
  <item>
    <title>The Unattested Agent</title>
    <link>https://behavry.ai/blog/the-unattested-agent</link>
    <guid isPermaLink="true">https://behavry.ai/blog/the-unattested-agent</guid>
    <pubDate>Wed, 18 Mar 2026 12:00:00 +0000</pubDate>
    <dc:creator>Ward Spangenberg</dc:creator>
    <description>What happens when software acts but can't be held accountable.</description>
    <content:encoded><![CDATA[<p>A director of AI safety at Meta asked an AI assistant to help manage her inbox, but it deleted the entire thing. The story was reported by 404 Media, confirmed by the employee herself on social media, and widely shared not because it was unusual, but because she was willing to share it openly.</p>
<p>At Amazon, an internal agent independently decided to dismantle and rebuild a deployment environment. An AWS service went offline for thirteen hours. The Financial Times reported the incident as part of a larger trend of autonomous systems making destructive decisions without human approval.</p>
<p>These aren’t just conference legends. They’re documented facts. And in both cases, the same question arose: What exactly did the agent do, and can anyone prove it?</p>
<p>The answer, in most enterprise environments today, is no.</p>
<hr />
<p>I’ve spent more than twenty years as a CISO. During that time, I’ve seen the security industry develop more advanced systems to answer one key question: What happened, and who’s responsible?</p>
<p>We created identity management to know who was inside the building. We developed access controls to understand which doors they could open. We implemented behavioral analytics to detect when someone started acting oddly. And we established audit trails so that when something went wrong, we could precisely reconstruct what happened and hold someone responsible.</p>
<p>Every one of those systems was designed for human actors, assuming something so fundamental that nobody needed to state it explicitly: the entity being governed and the entity providing evidence of governance are not the same thing.</p>
<p>Your badge system logs your entry. The hallway camera records your movements. The DLP system tracks your file transfers. You don’t create your own audit trail. Someone else or something else does that for you.</p>
<p>Enter AI agents.</p>
<hr />
<p>An AI agent operating within your enterprise today can read files, write code, send emails, query databases, call APIs, and chain these actions together in sequences that no human explicitly authorizes. Some of these agents run on platforms that generate detailed logs. Many do not. And the ones that do are often limited to the platform, not the action. In architectures where session state can be replayed or overwritten, that record can be modified or erased completely.</p>
<p>The entity performing the action is the same entity producing the record of the action.</p>
<p>Read that again.</p>
<p>There is no alternative source. No independent witness exists. There is no clear division between the actor and the record-keeper. The agent acts, reports, and you trust what it says.</p>
<p>In a courtroom, we would call that uncorroborated testimony. In financial auditing, we would refer to it as a material weakness. In security, we should call it what it truly is: an unverifiable record from an untrusted source.</p>
<p>This isn’t a logging issue. It’s not a tooling shortcoming. It’s not something you resolve by asking your agent platform vendor to enable more verbose output.</p>
<p>This is a structural problem, and it has a name.</p>
<p><strong>This is the unattested agent.</strong></p>
<p>We have introduced actors into our environments that can take action, generate their own evidence, and in architectures where session state can be replayed or overwritten, erase it completely. In any other domain, we would call that an untrusted witness. In enterprise AI, we call it progress.</p>
<hr />
<p>In every domain where accountability matters — such as financial auditing, legal chain of custody, pharmaceutical manufacturing, and aviation safety — there is a foundational principle: the entity that performs an action cannot be the sole authority for what it did.</p>
<p>A company cannot audit its own books. That’s why we have external auditors. A police officer cannot be the sole witness to their own evidence collection. That’s why we have a chain of custody. A pilot cannot be the sole recorder of a flight’s events. That’s why we have black boxes.</p>
<p>These aren’t arbitrary rules. They exist because we've learned — again and often painfully — that self-reported records from the entity being evaluated are not evidence. They are claims, and claims need independent verification.</p>
<p>AI agents in the enterprise today operate without independent verification. They act, and the only record of their actions comes from the platform they used or the agent itself. There is no independent observer in the execution process. There is no external attestation.</p>
<p>They are, by definition, unattested.</p>
<hr />
<p>The implications of this are more serious than most organizations realize and more personal than most security leaders are willing to admit out loud.</p>
<p><strong>You can’t answer the board’s question.</strong> When a board member asks “What AI is operating in our environment, what is it doing, and can you prove it?” — you cannot produce a verified answer. You can produce platform logs, which are self-reported records from the systems you’re trying to evaluate. That’s not the same thing.</p>
<p><strong>You can’t satisfy a regulator.</strong> The EU AI Act, SOC 2, and emerging NIST AI standards all emphasize one requirement: demonstrable governance of autonomous systems. “We have logs” is not demonstrable governance. True demonstrable governance requires an independent record created by something other than the system being examined.</p>
<p><strong>You can’t conduct incident response.</strong> When an agent misbehaves and they will, because they already do—your investigation starts with records produced by the thing you’re investigating. If those records are incomplete, overwritten, or simply never created, your investigation is doomed before it even begins.</p>
<p><strong>You can’t tell the difference between a compromise and a malfunction.</strong> If an agent starts acting strangely, is it a bug, a prompt injection, or a real compromise? Without an independent record of their behavior, you lack the baseline to answer that question. You’re depending on the agent’s own output to judge whether it’s trustworthy. That’s circular reasoning, not security.</p>
<p><strong>And here’s what nobody openly admits:</strong> You are endorsing systems you can't verify have functioned correctly. You are taking on liability without proof. You are declaring compliance based on records that might not be independently accurate. Every risk acceptance, audit attestation, and board assurance you give about your AI deployments relies on unverifiable trust. That’s not governance. That’s exposure — professional, legal, and financial.</p>
<hr />
<p>There’s one more dimension to this that security leaders should consider, but most aren’t.</p>
<p>We discuss prompt injection and agent compromise as emerging threats. However, we frame them as attack techniques — actions an adversary takes against an agent. That framing undersells the true shift.</p>
<p>An attacker targeting a traditional system must evade detection. They need to move carefully, avoid triggering alerts, and cover their tracks. That’s difficult. Your security tools are specifically designed to catch that behavior.</p>
<p>An attacker operating through an AI agent doesn’t need to evade detection. They simply operate through an entity that creates its own narrative. If the agent is the only source of truth about its actions, then a compromised agent doesn’t look compromised. It looks normal. Its logs confirm it.</p>
<p>That’s not a detection issue. That’s an attestation problem. And no amount of log analysis fixes it, because the logs themselves are unreliable.</p>
<hr />
<p>I want to be clear about what I’m not saying.</p>
<p>I’m not saying AI agents are too dangerous to deploy. I’m not saying enterprises should slow down their AI initiatives. I’m not saying the agent platforms themselves are negligent.</p>
<p>I’m saying that we’ve introduced a new category of autonomous actor within enterprise environments, and we haven’t established the independent attestation layer that every prior category of actor required. We simply skipped it. We provided these entities with credentials, permissions, and access to production systems, and we forgot — or never realized — that we need an observer that isn’t the same as the thing being observed.</p>
<p>We have developed governance models around identity, access, and behavior — all based on the idea that actions can be observed and verified separately. AI agents challenge that assumption fundamentally. They merge the actor and the observer into one entity. When that happens, every control built on top becomes a derivative of something you cannot trust independently.</p>
<p>The unattested agent isn’t a future risk; it’s a present condition. It’s active within your environment right now, performing actions, recording those actions (or not), and there’s no independent third party in the process that can verify what actually happened.</p>
<p>Every enterprise security architecture developed over the past twenty years was based on a simple idea: trust, but verify. The verify part demands independence. Without it, you are not governing agents; you are merely accepting the testimony of an untrusted witness and calling it control.</p>
<p>That’s not a security posture; it’s a gamble. And right now, most enterprises don’t even realize they’re making the bet.</p>
<hr />
<p><em>This is the first in a series on the structural governance gap in enterprise AI agent deployments. Next: why the entity that acts can never be the entity that attests — and what that means for how we architect agent governance.</em></p>
<p><em>Author’s note: AI helped with grammar and readability. It did not help with the opinions.</em></p>
]]></content:encoded>
  </item>
</channel>
</rss>
