MEHO is an open-source governance backplane for AI agents acting on infrastructure.
When AI agents can act on real infrastructure — drain a node, rotate a credential, restart a service — you need mor
Just found this article while browsing, so a bit late, but it has aged well:) and the line about moving from output validation to execution control is the sentence I keep quoting to people who still think a system prompt is a guardrail. One thing I would add is that “execution control” turns out to split into two quite different designs once you try to build it. One is behaviour-based, as you describe: watch what the agent does, classify it, escalate on drift. The trouble is that it needs a baseline and a judge, and the judge is usually another model. The other is to never let the agent author actions in the first place: it chooses from a fixed set of pre-defined operations, each with a known risk level, and a plain rule decides whether a given identity may run that operation, with no model in the decision. The second is slower to build but it is the only one I have seen that an auditor can actually read. The other gap I noticed is credentials. The agent incidents that made the news this year were mostly not drift; the PocketOS case in April was an agent finding an API token in an unrelated file and using it. If the agent never holds a credential and the platform fetches it per call under the operator’s identity, a whole class of these disappears regardless of how the agent behaves. Would you count that as part of execution control, or as a separate layer? And where would you put the line for irreversible operations: human approval every time, or a standing grant for a narrow class?
This is exactly right. The shift from output validation to execution control is the core realization I've had while building agent tools. You can't just filter what the model says; you have to constrain what the system does.
I'm 12, I don't own a laptop, and I build everything on a $150 Android phone using Termux. Because of those constraints, I couldn't rely on heavy enterprise frameworks, so I ended up attacking this exact "behavior-based security" problem from two sides.
First, I built KAVLR. It's a fail-closed terminal leash that puts execution control at the shell level. Before the OS runs a command, KAVLR checks a Postgres policy engine for known bad binaries (like curl). If the command is unknown, it sends it to a Constitutional AI (Llama 3 via Groq) to grade the semantic intent. If the score is below 90, it fails closed.
The craziest test was when I tried to run rm -f to uninstall my own CLI. The AI intercepted it, recognized it as a destructive filesystem action, gave it a 0/100, and blocked its own deletion. The system literally developed self-preservation because it was designed to be paranoid.
Second, I built HYNA-Stage. To handle the blast radius of a bad decision, it spins up ephemeral Firecracker MicroVMs in about 5 seconds. If the agent goes rogue or drifts, the whole VM just evaporates when the TTL hits zero. No persistence, no lateral movement, no complex rollback.
You mentioned that "system-level policy enforcement" and "human escalation boundaries" are becoming mandatory. How do you handle the latency of continuous evaluation in live workflows? If an agent is trying to execute a task with real-world consequences, how do you ensure the security layer doesn't become the bottleneck that forces humans to click "Approve" 50 times a minute?
This hits close to home. We already see internal tools slowly gaining more autonomy through workflow chaining. The scary part is not direct attacks but the slow erosion of safeguards you describe. How do you prevent that drift in practice?
That drift is exactly the hardest problem to detect. In practice you need execution-level monitoring instead of static controls. You don’t block once, you observe continuously. The moment optimization starts competing with governance, your system needs to surface that conflict automatically. Otherwise drift is inevitable.
Most teams I work with cannot even explain what their automation is doing across systems today. Adding autonomous agents on top feels like adding blindness on steroids.
That’s a very accurate way to phrase it. If execution paths are already opaque today, autonomy amplifies that opacity at machine speed. That’s why auditability and runtime observability stop being “nice to have” and become survival requirements.
Exactly. Autonomous AI is basically distributed decision-making on top of distributed systems. The same failure patterns apply, but now decisions are adaptive instead of deterministic. That combination is what makes the risk profile so different.
That’s exactly the problem. The industry framed agents as productivity toys. In reality they are execution engines. Language matters, because it shapes how seriously risk is taken.
The line is not technical, it’s contractual and regulatory. As soon as an autonomous system can create irreversible outcomes without a human checkpoint, you’re in high-risk territory. Everything below that line can usually be contained. Everything above it needs formal governance and escalation.
We're a place where coders share, stay up-to-date and grow their careers.
Just found this article while browsing, so a bit late, but it has aged well:) and the line about moving from output validation to execution control is the sentence I keep quoting to people who still think a system prompt is a guardrail. One thing I would add is that “execution control” turns out to split into two quite different designs once you try to build it. One is behaviour-based, as you describe: watch what the agent does, classify it, escalate on drift. The trouble is that it needs a baseline and a judge, and the judge is usually another model. The other is to never let the agent author actions in the first place: it chooses from a fixed set of pre-defined operations, each with a known risk level, and a plain rule decides whether a given identity may run that operation, with no model in the decision. The second is slower to build but it is the only one I have seen that an auditor can actually read. The other gap I noticed is credentials. The agent incidents that made the news this year were mostly not drift; the PocketOS case in April was an agent finding an API token in an unrelated file and using it. If the agent never holds a credential and the platform fetches it per call under the operator’s identity, a whole class of these disappears regardless of how the agent behaves. Would you count that as part of execution control, or as a separate layer? And where would you put the line for irreversible operations: human approval every time, or a standing grant for a narrow class?
This is exactly right. The shift from output validation to execution control is the core realization I've had while building agent tools. You can't just filter what the model says; you have to constrain what the system does.
I'm 12, I don't own a laptop, and I build everything on a $150 Android phone using Termux. Because of those constraints, I couldn't rely on heavy enterprise frameworks, so I ended up attacking this exact "behavior-based security" problem from two sides.
First, I built KAVLR. It's a fail-closed terminal leash that puts execution control at the shell level. Before the OS runs a command, KAVLR checks a Postgres policy engine for known bad binaries (like
curl). If the command is unknown, it sends it to a Constitutional AI (Llama 3 via Groq) to grade the semantic intent. If the score is below 90, it fails closed.The craziest test was when I tried to run
rm -fto uninstall my own CLI. The AI intercepted it, recognized it as a destructive filesystem action, gave it a 0/100, and blocked its own deletion. The system literally developed self-preservation because it was designed to be paranoid.Second, I built HYNA-Stage. To handle the blast radius of a bad decision, it spins up ephemeral Firecracker MicroVMs in about 5 seconds. If the agent goes rogue or drifts, the whole VM just evaporates when the TTL hits zero. No persistence, no lateral movement, no complex rollback.
You mentioned that "system-level policy enforcement" and "human escalation boundaries" are becoming mandatory. How do you handle the latency of continuous evaluation in live workflows? If an agent is trying to execute a task with real-world consequences, how do you ensure the security layer doesn't become the bottleneck that forces humans to click "Approve" 50 times a minute?
This hits close to home. We already see internal tools slowly gaining more autonomy through workflow chaining. The scary part is not direct attacks but the slow erosion of safeguards you describe. How do you prevent that drift in practice?
That drift is exactly the hardest problem to detect. In practice you need execution-level monitoring instead of static controls. You don’t block once, you observe continuously. The moment optimization starts competing with governance, your system needs to surface that conflict automatically. Otherwise drift is inevitable.
Most teams I work with cannot even explain what their automation is doing across systems today. Adding autonomous agents on top feels like adding blindness on steroids.
That’s a very accurate way to phrase it. If execution paths are already opaque today, autonomy amplifies that opacity at machine speed. That’s why auditability and runtime observability stop being “nice to have” and become survival requirements.
This reminds me of distributed systems all over again. Everything works fine until small local optimizations cause global failures.
Exactly. Autonomous AI is basically distributed decision-making on top of distributed systems. The same failure patterns apply, but now decisions are adaptive instead of deterministic. That combination is what makes the risk profile so different.
agreed
This makes me rethink how casually we talk about “agents” right now.
That’s exactly the problem. The industry framed agents as productivity toys. In reality they are execution engines. Language matters, because it shapes how seriously risk is taken.
Where do you draw the line between useful autonomy and unacceptable risk?
The line is not technical, it’s contractual and regulatory. As soon as an autonomous system can create irreversible outcomes without a human checkpoint, you’re in high-risk territory. Everything below that line can usually be contained. Everything above it needs formal governance and escalation.