2
4 Comments

The first AI-agent boundary you write will probably be wrong

A counterexample in a public discussion changed how I think about AI-agent boundaries. The person said the boundaries written up front were all incomplete; the stop points that lasted were added after something went through that should not have.

That suggests the durable artifact is not only the first brief. It is the amendment history—and whether adding one rule after an incident is cheap enough that someone will actually do it.

I think that creates two separate requirements:

  1. An approval should be bound to one exact scope and expire when a material input changes.
  2. The boundary itself should be easy to amend when a real failure exposes a missing rule.

For example:

  • approving an email draft is not approving the send;
  • approving a $20 purchase is not approving any amount;
  • approving a migration plan is not approving a production migration;
  • approving access to redacted test data is not approving access to customer data.

A useful approval record should therefore say:

  1. the exact action being approved;
  2. who owns the final decision;
  3. the maximum downside accepted;
  4. what evidence must come back;
  5. which changes immediately void the approval;
  6. which incident or new fact caused the rule to be amended.

If the audience, cost, permissions, data access, target, or reversibility changes, the old “yes” should expire. If a live failure reveals a missing stop condition, adding that condition should not require rebuilding the whole system.

I still have not observed someone using my own brief in a live agent run, so I cannot claim that this design changes behavior yet.

For people running AI agents: which boundary did you add only after something slipped through? And where does that rule live so the next session actually sees it?

Please keep examples redacted—no credentials, customer data, source code, or production details.

on August 14, 2026
  1. 1

    This is exactly the distinction I keep coming back to: approval is a claim over a specific state, not a permanent yes.

    If the balance, target, permissions or policy changes, the approval should die with that state. The hard part is making those dependencies explicit without revalidating the entire world.

    I ended up building FreshCtx around that idea: https://github.com/Hyperwise-LLC/freshctx

  2. 1

    This is very close to a problem I’m working on with OpsWatch.

    One thing I keep coming back to is that an approval record tells you what the agent was allowed to do, but it still doesn’t independently prove what actually happened afterwards.

    I’d be interested in separating those into two artefacts: the approval boundary before execution, then an independent evidence check after execution against the intended outcome.

    Have you thought about what would count as sufficient external evidence for that second part — rather than relying on the agent or execution system’s own success state?

  3. 1

    The first AI-agent boundary you write will always be wrong—that’s the pain every builder feels when security rules break in production. That’s a real opportunity: a dynamic, self-adjusting boundary tool that learns from real agent behavior, not static configs. We’re exploring this. What’s the biggest failure mode you’ve hit—over-permissioning or false positives blocking legit actions?

  4. 1

    The amendment-history point is particularly interesting. A boundary can look complete on paper and still be missing the condition that only a real failure exposes. I’d be curious what you learn once you see people actually using the brief in live agent runs.