<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Ian Daily</title>
    <description>The latest articles on DEV Community by Ian Daily (@iandaily).</description>
    <link>https://dev.to/iandaily</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4196686%2F58dbe7ce-8f61-410c-a21a-c9913230eea6.png</url>
      <title>DEV Community: Ian Daily</title>
      <link>https://dev.to/iandaily</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/iandaily"/>
    <language>en</language>
    <item>
      <title>Your Agent Is Logged In as You</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:56:39 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/your-agent-is-logged-in-as-you-39e9</link>
      <guid>https://dev.to/mutageniclabs/your-agent-is-logged-in-as-you-39e9</guid>
      <description>&lt;p&gt;Open the audit log of any system your agent touched last week. Your name is on every line.&lt;/p&gt;

&lt;p&gt;Not the agent's. Yours. The GitHub commit is authored by you. The calendar invite came from you. The API call carried your token, the file was written by your user, the email went out from your address. If something in that list was wrong — sent to the wrong person, deleted from the wrong folder, retried three times against a non-idempotent endpoint — the record says a human did it, and the human is you.&lt;/p&gt;

&lt;p&gt;This is not a misconfiguration. It is how nearly every agent stack in production works today, and almost nobody has decided it should be that way. It is simply the path of least resistance: the agent needed access, you had access, so it borrowed yours.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the borrowing happens
&lt;/h2&gt;

&lt;p&gt;Look at where an agent's authority actually comes from and the pattern is the same at every layer.&lt;/p&gt;

&lt;p&gt;At the shell, the agent runs as your Unix user. It inherits your home directory, your SSH keys, your &lt;code&gt;sudo&lt;/code&gt; rights, your cloud CLI sessions. Anything you can do from a terminal, it can do, and the process table shows your UID.&lt;/p&gt;

&lt;p&gt;At the API layer, it holds your OAuth token. You clicked "Allow" once, in a consent screen that offered two options — everything or nothing — and the agent has been presenting that token ever since. The service on the other end cannot tell the difference between you and the thing acting as you. By design, it is not supposed to.&lt;/p&gt;

&lt;p&gt;In the browser, it drives your logged-in session. Cookies, saved passwords, the tabs you left open. To every site it visits, it &lt;em&gt;is&lt;/em&gt; you.&lt;/p&gt;

&lt;p&gt;Each of these is defensible in isolation. The agent has to run as something; it has to authenticate as something. But stack them and you have built a system in which a non-human actor performs consequential actions across a dozen systems while every one of those systems records a person.&lt;/p&gt;

&lt;h2&gt;
  
  
  What breaks
&lt;/h2&gt;

&lt;p&gt;The first thing that breaks is the question "who did this?" — which sounds academic until you are asking it at two in the morning.&lt;/p&gt;

&lt;p&gt;A production incident happens. Something was changed. The change log names an engineer. The engineer says, truthfully, that they did not make that change; they were asleep; they had an agent running a maintenance task. Now you have a record that is &lt;em&gt;wrong&lt;/em&gt; in the most load-bearing field a record has, and no way to know how many other entries in the log share the defect. Every incident review that follows starts with an investigation into whether the people named in the logs were actually there.&lt;/p&gt;

&lt;p&gt;The second thing that breaks is revocation. When the agent does something it shouldn't — and we have written about why &lt;a href="https://magenticos.com/blog/instructions-are-not-controls/" rel="noopener noreferrer"&gt;instructions are a weak control&lt;/a&gt; against that — the correct response is to pull its access. But it doesn't have any. It has yours. Revoking the token revokes you. Rotating the key locks you out. The only way to take authority away from the agent without taking it away from yourself is to have given it separate authority in the first place, and you didn't, because nothing offered to.&lt;/p&gt;

&lt;p&gt;The third thing is scope. Because the agent borrows your identity, it borrows &lt;em&gt;all&lt;/em&gt; of it. You did not give it permission to read your email so it could schedule a meeting; you gave it your Google session. The task needed one calendar write. The token grants everything you have ever been allowed to do. We've argued that &lt;a href="https://magenticos.com/blog/capability-based-security-for-ai-agents/" rel="noopener noreferrer"&gt;authority should be granted per capability&lt;/a&gt;, narrow and typed; identity borrowing is the exact opposite — it is the maximally broad grant, made by default, to an actor that cannot be distinguished from you afterward.&lt;/p&gt;

&lt;p&gt;The fourth thing is blame, and it is the one people feel first. When the record says you did it, you did it. Organizations run on their records. A compliance regime that asks "which individual authorized this transfer?" gets your name. A security review that asks "who accessed this data?" gets your name. Agents have been added to the system and accountability has not moved an inch — it still lands entirely on the human whose credentials happened to be lying around.&lt;/p&gt;

&lt;h2&gt;
  
  
  The delegation problem has a name, and a partial answer
&lt;/h2&gt;

&lt;p&gt;None of this is new to identity people. Acting on someone's behalf is an old problem with real solutions. The OAuth token-exchange specification, &lt;a href="https://www.rfc-editor.org/rfc/rfc8693" rel="noopener noreferrer"&gt;RFC 8693&lt;/a&gt;, defines a way to mint a token that says "this actor is acting for this subject," so a downstream service can see both parties. NIST's &lt;a href="https://pages.nist.gov/800-63-4/" rel="noopener noreferrer"&gt;digital identity guidelines&lt;/a&gt; are built around the idea that a &lt;em&gt;subject&lt;/em&gt; is a distinct thing that can be identified, authenticated, and held to account.&lt;/p&gt;

&lt;p&gt;The machinery for "the agent is a principal, acting on behalf of a person, with authority the person delegated" exists. So why does almost no agent stack use it?&lt;/p&gt;

&lt;p&gt;Because every piece of it is optional, and it lives in the wrong place. It lives in each service, each API, each integration — which means it exists only where some team happened to build it, in whatever shape they happened to choose. One SaaS product has service accounts with scoped permissions; the next has a single personal token. The shell has no concept of "a process acting for a user" beyond &lt;code&gt;sudo&lt;/code&gt;'s one-line log entry. The browser has no concept of it at all. An agent that wants to be properly attributed has to negotiate a different arrangement with every system it touches, and the default when no arrangement exists is: borrow the human.&lt;/p&gt;

&lt;p&gt;Attribution, like &lt;a href="https://magenticos.com/blog/agent-actions-need-receipts/" rel="noopener noreferrer"&gt;receipts&lt;/a&gt;, is a property you get from the &lt;em&gt;structure&lt;/em&gt; of a system or you don't get at all. You cannot ask the agent to log who it is — that is an instruction, and instructions are not controls. You cannot rely on each downstream service to have built delegation — most haven't, and the agent's task doesn't wait for them to. The property has to be produced by whatever layer sits between the agent and every consequential action it takes, so that it is true everywhere, by construction, without anyone remembering to arrange it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the correct arrangement looks like
&lt;/h2&gt;

&lt;p&gt;Strip the problem to its shape and the arrangement is not mysterious.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The agent is its own principal.&lt;/strong&gt; It has an identity distinct from any human's. Logs that record it, record &lt;em&gt;it&lt;/em&gt;. When it runs as a process, the process belongs to the agent; when it holds a credential, the credential names the agent.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Every action carries two names.&lt;/strong&gt; The agent that acted, and the human on whose behalf it acted. Not one or the other — both. "Alice's deploy agent, acting for Alice" is a record you can reason about. "Alice" is a record that is wrong. "deploy-bot-7" with no link back to Alice is a record that cannot be held to anyone.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Authority is delegated, scoped, and separately revocable.&lt;/strong&gt; The human grants the agent specific capabilities, not a copy of themselves. Pulling the agent's authority leaves the human's intact. Narrowing it to one calendar does not require trusting the agent with the inbox.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The arrangement is enforced at the point of action.&lt;/strong&gt; Not in a policy document, not in a system prompt, not in the goodwill of each downstream service. Wherever the agent's intent becomes an effect on the world — a file written, a request sent, a command executed — that seam is where identity is attached and scope is checked. If every consequential action has to pass through one mediating layer anyway, that layer is where attribution belongs, because it is the only place that sees every action.&lt;/p&gt;

&lt;p&gt;That last point is why we think this is an operating-system problem, not an application one. Applications can each solve it for themselves, and a few have. But the agent doesn't live in one application. It lives on the machine and reaches into all of them. The only layer with the same reach is the one underneath.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where we are, honestly
&lt;/h2&gt;

&lt;p&gt;MagenticOS is in alpha, and the rule we hold ourselves to is that aspiration and shipped capability never share a sentence. So, plainly: the thesis above is the thesis we are building toward — every consequential action passes a typed broker, so the broker is where an action picks up its actor and its scope. What the alpha ships is the runtime, that broker, and a reference shell. What the full arrangement looks like across a whole distro is later work, and we will say so when it is real rather than when it is designed.&lt;/p&gt;

&lt;p&gt;In the meantime the diagnostic is free and worth running on whatever you have. Pick one system your agent touched this week. Open its log. Find the action. Read the name on it.&lt;/p&gt;

&lt;p&gt;If the name is yours, you don't have an agent identity problem someday. You have one now, and your records are already wrong.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/your-agent-is-logged-in-as-you/" rel="noopener noreferrer"&gt;magenticos.com/blog/your-agent-is-logged-in-as-you&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>identity</category>
      <category>agents</category>
    </item>
    <item>
      <title>What Is an Agent-Native Operating System?</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:56:00 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/what-is-an-agent-native-operating-system-61a</link>
      <guid>https://dev.to/mutageniclabs/what-is-an-agent-native-operating-system-61a</guid>
      <description>&lt;p&gt;"AI operating system" has quietly become one of the most overloaded phrases in software. It&lt;br&gt;
gets stuck on chat apps, on developer frameworks, on browser extensions, on anything with a&lt;br&gt;
language model somewhere inside it. So it's worth being precise about what an &lt;em&gt;agent-native&lt;/em&gt;&lt;br&gt;
operating system actually is — because the distinction isn't marketing, it's architectural,&lt;br&gt;
and it changes what the software can promise you.&lt;/p&gt;

&lt;p&gt;The one-line version: &lt;strong&gt;AI as the OS, not AI on the OS.&lt;/strong&gt; In an agent-native OS, the agent&lt;br&gt;
&lt;em&gt;is&lt;/em&gt; the interface you log into, and the traditional desktop — the compositor, the window&lt;br&gt;
manager, the app model, the tray of background daemons — is gone, not decorated. This post&lt;br&gt;
lays out what that means, how it differs from the AI features being bolted onto everything&lt;br&gt;
else, and why the operating-system layer is the right place for it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with what today's OS is actually for
&lt;/h2&gt;

&lt;p&gt;Look at where a modern desktop spends its budget — RAM, CPU, attention, attack surface. Almost&lt;br&gt;
all of it goes to helping &lt;em&gt;a human&lt;/em&gt; drive &lt;em&gt;a fleet of applications&lt;/em&gt; with a mouse and keyboard:&lt;br&gt;
a compositor to draw overlapping windows, a window manager to arrange them, an application&lt;br&gt;
model so programs can be launched and switched, and a constellation of background services to&lt;br&gt;
keep it all humming. For forty years that was exactly right. The human was the intelligence in&lt;br&gt;
the loop; the machine's job was to render windows and get out of the way.&lt;/p&gt;

&lt;p&gt;An agent inverts that arrangement. The agent is now the thing doing the driving — perceiving,&lt;br&gt;
deciding, acting. But it's being asked to drive through an interface built on the assumption&lt;br&gt;
that a careful human is at the wheel. That mismatch is the whole reason "put an AI in the&lt;br&gt;
sidebar" never quite feels like the future: you've added an intelligent driver to a car&lt;br&gt;
designed to be driven by hand, and left all the manual controls in place.&lt;/p&gt;

&lt;h2&gt;
  
  
  The three things that make an OS "agent-native"
&lt;/h2&gt;

&lt;p&gt;An agent-native OS isn't a desktop with an assistant added. It's a different set of primitives.&lt;br&gt;
Three properties separate the real thing from the retrofit.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. The agent is the surface, not a feature.&lt;/strong&gt; You log in from your display manager into the&lt;br&gt;
OS itself and talk to the agent. There's no launcher, no grid of app icons, no "open the&lt;br&gt;
assistant" step — because there's nothing else to open. The agent is what you're using. That's&lt;br&gt;
the literal meaning of &lt;em&gt;agent-native&lt;/em&gt;: the agent is native to the system, not hosted by it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Delivery windows replace application windows.&lt;/strong&gt; When the agent does work, it renders that&lt;br&gt;
work into typed panes, cards, and streams it opens, fills, and closes as it goes — &lt;a href="https://magenticos.com/blog/delivery-windows-vs-application-windows/" rel="noopener noreferrer"&gt;delivery&lt;br&gt;
windows&lt;/a&gt;, not application windows you operate.&lt;br&gt;
You're watching work be delivered, not driving a toolbar. The unit of the interface shifts from&lt;br&gt;
"an app you run" to "a result the agent produces."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Authority is brokered, not ambient.&lt;/strong&gt; This is the deepest difference and the easiest to&lt;br&gt;
miss. On a normal OS, a program acts with the &lt;em&gt;ambient authority&lt;/em&gt; of whoever launched it — if&lt;br&gt;
you can do it, the program can do it, up to and including a raw shell and &lt;code&gt;sudo&lt;/code&gt;. That's&lt;br&gt;
tolerable when a careful human is deciding what runs. It's the whole problem when the thing&lt;br&gt;
deciding is a probabilistic model that can be wrong or manipulated. An agent-native OS instead&lt;br&gt;
routes every consequential action through a typed &lt;a href="https://en.wikipedia.org/wiki/Capability-based_security" rel="noopener noreferrer"&gt;capability&lt;br&gt;
broker&lt;/a&gt; with a default-deny policy:&lt;br&gt;
the agent presents a token for exactly the authority a task needs, and holds nothing more. The&lt;br&gt;
shell never bypasses it. (&lt;a href="https://magenticos.com/blog/agent-trust-belongs-in-the-operating-system/" rel="noopener noreferrer"&gt;Why that belongs in the OS, not the&lt;br&gt;
app.&lt;/a&gt;)&lt;/p&gt;

&lt;h2&gt;
  
  
  What you get when those three hold
&lt;/h2&gt;

&lt;p&gt;Those primitives aren't ends in themselves — they're what make a set of otherwise-unreasonable&lt;br&gt;
promises actually keepable:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Inspectable.&lt;/strong&gt; Every plan, tool call, approval, and result is logged, timestamped, and
&lt;a href="https://magenticos.com/blog/inspectable-by-default-ai-agents/" rel="noopener noreferrer"&gt;replayable&lt;/a&gt;. Agent work stops being write-only.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Trustworthy.&lt;/strong&gt; No raw shell, no raw sudo; consequential actions pass the broker. Least
privilege and containment are properties of the system, not promises of an app.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Local-first.&lt;/strong&gt; The default is a model on your own machine, with hosted models on tap rather
than &lt;a href="https://magenticos.com/blog/local-first-ai-off-the-critical-path/" rel="noopener noreferrer"&gt;on the critical path&lt;/a&gt; — so your files and
context don't have to leave to get work done.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Durable.&lt;/strong&gt; Sessions survive a reboot. The record of what happened is still there tomorrow.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Notice that every one of those is a statement about the &lt;em&gt;environment&lt;/em&gt; the agent runs in. You&lt;br&gt;
cannot bolt them onto an app, because the app doesn't control the environment — the OS does.&lt;br&gt;
That's the argument for doing this at the operating-system layer instead of as one more&lt;br&gt;
assistant in one more sidebar.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it differs from the things it gets confused with
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;An AI assistant / copilot&lt;/strong&gt; is an application that runs &lt;em&gt;on&lt;/em&gt; your OS and helps you drive
other applications. Useful, but it inherits the desktop's assumptions and its ambient
authority. Agent-native means there's no "other applications" tier to drive.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An agent framework or SDK&lt;/strong&gt; is a toolkit for developers to build agents. It's a library,
not the system you log into. An agent-native OS is the runtime and the surface, not the
scaffolding.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A chat app with tools&lt;/strong&gt; is a conversation with function-calling attached. It has no OS-level
authority model, no durable session at the system level, and no replaceable desktop — the
three things that define the category.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If a product keeps the app model and adds intelligence, it's AI &lt;em&gt;on&lt;/em&gt; the OS. If it deletes the&lt;br&gt;
app model and makes the agent the system, it's AI &lt;em&gt;as&lt;/em&gt; the OS. Only the second is agent-native.&lt;/p&gt;

&lt;h2&gt;
  
  
  Being honest about the phase
&lt;/h2&gt;

&lt;p&gt;Categories get oversold, so here's the phase-honest version. Building this is staged. The&lt;br&gt;
alpha replaces your &lt;em&gt;desktop session&lt;/em&gt; — you log into the agent-native OS instead of GNOME or&lt;br&gt;
KDE — while your machine keeps its kernel. It ships the runtime, the typed broker, a reference&lt;br&gt;
agentic shell, and a display-manager session entry, as a package on Debian/Ubuntu. The later,&lt;br&gt;
larger step is a full distribution with the compositor and desktop stack gone at the image&lt;br&gt;
level. We're building it in the open, in Rust, under Apache 2.0, and we'd rather describe the&lt;br&gt;
destination precisely than pretend we're already standing on it.&lt;/p&gt;

&lt;p&gt;So: an agent-native operating system is one where the agent is the surface, delivery windows&lt;br&gt;
replace application windows, and authority is brokered instead of ambient — which together make&lt;br&gt;
an inspectable, trustworthy, local-first, durable system possible. It's for people who'd rather&lt;br&gt;
drive their machine through an agent than through a grid of app icons. Everything else in this&lt;br&gt;
blog is a closer look at one of those pillars.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;MagenticOS is built by Mutagenic Labs, LLC. Open source, Apache 2.0.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/what-is-an-agent-native-operating-system/" rel="noopener noreferrer"&gt;magenticos.com/blog/what-is-an-agent-native-operating-system&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>os</category>
      <category>architecture</category>
      <category>agents</category>
    </item>
    <item>
      <title>The Sandbox Is the Wrong Unit for AI Agents</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:55:24 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/the-sandbox-is-the-wrong-unit-for-ai-agents-5ad7</link>
      <guid>https://dev.to/mutageniclabs/the-sandbox-is-the-wrong-unit-for-ai-agents-5ad7</guid>
      <description>&lt;p&gt;Every serious agent product now ships with a sandbox. Container, VM, namespace, seccomp profile, a browser in a browser. The pitch is the same everywhere: the agent runs &lt;em&gt;in there&lt;/em&gt;, so whatever it does, it can't hurt you.&lt;/p&gt;

&lt;p&gt;That claim is true in exactly the way it was true for the programs sandboxes were built for, and false in the way that matters for agents. An AI agent sandbox protects the host from the process. It does not protect you from the agent's decisions, because the decisions are the product, and the sandbox was never designed to see them.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a sandbox was built to answer
&lt;/h2&gt;

&lt;p&gt;Process isolation answers one question well: &lt;em&gt;what can this program touch?&lt;/em&gt; Namespaces decide which filesystem, network, and process tree the program sees. Seccomp decides which system calls it may make. A container image decides which binaries exist at all. Draw the box, drop the program in, and the box holds regardless of what the program does inside it.&lt;/p&gt;

&lt;p&gt;That model has an assumption baked so deep that nobody says it out loud: &lt;strong&gt;the program's behaviour is fixed before it runs.&lt;/strong&gt; You know what &lt;code&gt;ffmpeg&lt;/code&gt; does. You know what the payment worker does. The sandbox exists because you don't fully trust the &lt;em&gt;implementation&lt;/em&gt;, so you bound the blast radius of bugs and of hostile input. The intent is not in question; the code's fidelity to the intent is.&lt;/p&gt;

&lt;p&gt;An agent inverts that. The implementation is fine. The intent is decided at runtime, one step at a time, by a model reading whatever landed in its context. The agent that was supposed to summarize a folder decides, three steps in, that the summary would be better if it also emailed the folder to the person it thinks asked for it. Nothing in that sequence is a bug. Nothing escaped. The sandbox held perfectly, and it held around the wrong thing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The failure mode is not escape
&lt;/h2&gt;

&lt;p&gt;Look at the agent incidents people actually report. The duplicate purchase after a timeout. The repository force-pushed over. The calendar cleared because "reschedule" was read as "remove." The support reply that promised a refund the policy doesn't allow. The file shared with the whole org instead of one person.&lt;/p&gt;

&lt;p&gt;Not one of these is a sandbox escape. Every one of them was a permitted action, taken by a process inside its box, using credentials that were legitimately available to it, doing something the box was never asked to prevent. Isolation was never the control that would have caught them, because isolation controls &lt;em&gt;reach&lt;/em&gt;, and these were failures of &lt;em&gt;judgment within reach&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;That is the quiet compromise: we have accepted "it can't get out" as a proxy for "it won't do the wrong thing," when the two are not even about the same layer. The first is a property of the process. The second is a property of each action.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the box is the wrong size
&lt;/h2&gt;

&lt;p&gt;Try to fix this with the sandbox and you find out why it is the wrong unit.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It is all-or-nothing per process.&lt;/strong&gt; A sandbox grants the process a set of reach at start-up. Either the network is there or it isn't; either the directory is mounted or it isn't. An agent that needs to read one file to plan and write one different file to finish does not have a per-process shape. Its needs are per-step, and they are not known before the process starts. So the box gets drawn around the union of everything the agent &lt;em&gt;might&lt;/em&gt; need, which is the same thing as not drawing a box.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It has no notion of intent.&lt;/strong&gt; The sandbox sees a &lt;code&gt;connect()&lt;/code&gt; and a &lt;code&gt;write()&lt;/code&gt;. It cannot distinguish the email the user asked for from the email the agent decided to send. Both are the same syscall on the same socket. The information that would separate them, what the user requested and what the agent is trying to accomplish, exists only in the agent's context, which the sandbox cannot read and should not trust anyway.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It does not know who is acting.&lt;/strong&gt; Inside the box there is one process identity. It does not carry "on behalf of whom" or "under which task." So there is nothing to revoke when a task ends, nothing to scope when a task begins, and nothing in the record afterwards that says which decision produced which side effect. The box's own logs, if any, say a process did a thing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It leaks around the edges by design.&lt;/strong&gt; Agents are useful precisely because they touch the systems we care about: mail, calendars, repositories, payment APIs, the actual filesystem. The sandbox that genuinely prevented all of that would be a sandbox around a toy. So every real deployment punches the holes the agent needs, and the holes are where the incidents happen.&lt;/p&gt;

&lt;p&gt;None of this means sandboxes are bad. They are still the right answer to their own question. Run agent tool code in one; keep the blast radius of a bad dependency small. But defence-in-depth around the process is not the same as a control on the action, and calling the first the second is how teams end up with an incident report that says "the sandbox worked" on the same page as "the customer was charged twice."&lt;/p&gt;

&lt;h2&gt;
  
  
  The unit that fits is the action
&lt;/h2&gt;

&lt;p&gt;If the agent's behaviour is decided one step at a time, then the boundary has to be checkable one step at a time. The unit of isolation for an agent is not the process. It is the &lt;strong&gt;action&lt;/strong&gt;: this operation, on this resource, on behalf of this principal, under this task, right now.&lt;/p&gt;

&lt;p&gt;That reframing changes what the questions are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Not &lt;em&gt;"can this process reach the network?"&lt;/em&gt; but &lt;em&gt;"may this action send this message to this recipient?"&lt;/em&gt;
&lt;/li&gt;
&lt;li&gt;Not &lt;em&gt;"is the directory mounted?"&lt;/em&gt; but &lt;em&gt;"may this task write this file, and is that write the one the plan said it would make?"&lt;/em&gt;
&lt;/li&gt;
&lt;li&gt;Not &lt;em&gt;"which user is the process running as?"&lt;/em&gt; but &lt;em&gt;"which task is asking, on whose authority, and will the record show it?"&lt;/em&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Answering those requires three properties that a per-process sandbox structurally cannot supply. &lt;strong&gt;Authority has to be typed and granted per action&lt;/strong&gt; rather than per process, default-deny, so that "read one file" and "send one email" are different grants rather than the same open door. &lt;strong&gt;Every action has to pass through a single point that can see the request&lt;/strong&gt;, not the syscall, so that intent-level checks are even possible. And &lt;strong&gt;the point that mediates the action has to write the record&lt;/strong&gt;, so that what happened is attributable to a task and a decision, not to a process ID.&lt;/p&gt;

&lt;p&gt;Those are operating-system responsibilities. Not because the OS is the only place they &lt;em&gt;could&lt;/em&gt; live, but because it is the only place that sees every action regardless of which app, framework, or model produced it. A framework can add a permission prompt to its own tool calls. A model provider can add a refusal. Neither sees the action the other one took, and neither is still in the loop when the agent shells out to a script that does the real work. The layer beneath all of them is.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this looks like from the outside
&lt;/h2&gt;

&lt;p&gt;Picture the same "summarize a folder" task in an arrangement where the action is the unit. The task starts with authority to read that folder and write one summary file, and nothing else. Three steps in, the agent decides to email the folder. That decision is not blocked by a rule in a prompt; there is simply no grant that covers it, so the action cannot be issued. If the user wants it, the grant is a deliberate, visible act, scoped to that task, and it expires when the task does. Afterwards the record shows the reads, the one write, and the attempted send that had no authority, each tied to the task that produced it.&lt;/p&gt;

&lt;p&gt;Nothing about that requires the model to be better behaved. It requires the surrounding system to stop treating the process as the thing it trusts or distrusts, and start treating each action as the thing it decides about.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where we are with it
&lt;/h2&gt;

&lt;p&gt;We are building toward exactly this arrangement, and we are in alpha. The honest description of the alpha is a runtime with a typed capability layer and a reference shell, running local-first, with the sandbox still present underneath as defence-in-depth rather than as the control. Much of what a mature system would do at the action boundary is still ahead of us, and some of what we have is rough. What is settled is the unit. Draw the box around the process and you have protected the host from the code. Draw it around the action and you have protected the person from the decision. Agents are made of decisions.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/sandbox-is-the-wrong-unit-for-ai-agents/" rel="noopener noreferrer"&gt;magenticos.com/blog/sandbox-is-the-wrong-unit-for-ai-agents&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>architecture</category>
      <category>programming</category>
    </item>
    <item>
      <title>Capability-Based Security for AI Agents</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:54:48 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/capability-based-security-for-ai-agents-57ke</link>
      <guid>https://dev.to/mutageniclabs/capability-based-security-for-ai-agents-57ke</guid>
      <description>&lt;p&gt;Ask yourself what an AI agent on your machine is actually allowed to do. Not what you'd &lt;em&gt;like&lt;/em&gt; it to do — what the system will permit if the agent tries. On almost every setup in use today, the honest answer is: whatever you're allowed to do. The agent runs inside a process that runs as you, and "you" is a very large grant. Capability-based security for AI agents is the argument that this is the wrong trust model at its root — that an agent should start with the authority to do &lt;em&gt;nothing&lt;/em&gt;, and receive narrow, typed, revocable grants for exactly the actions its task requires. It's an old idea in operating systems research. The actor it was waiting for has finally arrived.&lt;/p&gt;

&lt;h2&gt;
  
  
  The app-permission model assumes a human is driving
&lt;/h2&gt;

&lt;p&gt;The permission model everyone actually lives under was designed around two comfortable assumptions: the unit of trust is the &lt;em&gt;application&lt;/em&gt;, and the entity driving it is a &lt;em&gt;person&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;So the questions the system asks are app-shaped and person-shaped. "Allow this app to access your files?" "Allow this app to use the network?" You answer once, usually at install time, usually yes, and the grant persists forever at the granularity of an entire program. From then on, the app operates with what security people call ambient authority — it doesn't present credentials for each action; it simply acts, and the system checks whether &lt;em&gt;you&lt;/em&gt; could have done it. Since you can do nearly everything, so can it.&lt;/p&gt;

&lt;p&gt;This was always a coarse arrangement, but it held together because of the second assumption: a human was in the loop, clicking each button, more or less aware of what was happening. The app's authority was broad, but its &lt;em&gt;actions&lt;/em&gt; were throttled by human attention. The grant was the size of a barn door, and a person walked through it one step at a time.&lt;/p&gt;

&lt;h2&gt;
  
  
  The actor changed. The model didn't.
&lt;/h2&gt;

&lt;p&gt;Now put an agent in the driver's seat and watch both assumptions fail at once.&lt;/p&gt;

&lt;p&gt;An agent is not throttled by human attention — issuing actions at machine speed is its entire value. And an agent is not a fixed program whose behavior you can audit once and trust forever; it's a probabilistic system whose next action depends on its context, which includes text it read five minutes ago from a source you've never vetted. The security community has a growing catalog of what follows — &lt;a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/" rel="noopener noreferrer"&gt;OWASP's Top 10 for LLM applications&lt;/a&gt; puts prompt injection and "excessive agency" near the top, and excessive agency is really just ambient authority wearing its new name.&lt;/p&gt;

&lt;p&gt;The classic term for the resulting failure is the confused deputy: a program with legitimate authority tricked into using it for someone else's ends. Agents are the most confusable deputies ever built. They can be instructed by anything that can get words in front of them. Hand a confusable actor your full ambient authority and you haven't built an assistant-shaped tool; you've built a very fast intern with your keys, your badge, and a habit of taking directions from strangers.&lt;/p&gt;

&lt;p&gt;The industry's current answer is supervision — watch every step, approve every action. That works, at the cost of the thing you wanted, which was delegation. All-or-nothing trust gives you exactly two settings: babysit, or hope. Neither is a security model. Both are coping strategies for a permission system that has no vocabulary for the thing we're now asking it to govern.&lt;/p&gt;

&lt;h2&gt;
  
  
  What capability-based security gets right
&lt;/h2&gt;

&lt;p&gt;Capability systems invert the model's core assumption. Instead of an actor carrying broad ambient authority checked against an identity, authority lives in &lt;em&gt;capabilities&lt;/em&gt;: unforgeable tokens that each designate a specific resource together with specific rights over it. If you hold the capability, you can perform the action. If you don't, there is no action to attempt — the request isn't denied so much as impossible to express.&lt;/p&gt;

&lt;p&gt;Three properties follow, and each one lands directly on the agent problem.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Default-deny.&lt;/strong&gt; An actor begins with nothing. Every authority it holds was explicitly granted, which means the complete answer to "what can this agent do?" is "here is the list of what it was handed" — a list you can read, rather than a subtraction problem over everything your account can reach. Least privilege stops being an aspiration written in a policy document and becomes a structural fact.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Typed grants.&lt;/strong&gt; A capability isn't "disk access." It's &lt;em&gt;append to this log&lt;/em&gt;, &lt;em&gt;read this directory&lt;/em&gt;, &lt;em&gt;send to this address&lt;/em&gt;. The grant carries its own meaning, narrow enough that granting it doesn't require faith. This matters enormously for a probabilistic actor: you don't have to predict everything the model might be talked into wanting. You bound what any of it can &lt;em&gt;touch&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Bounded blast radius.&lt;/strong&gt; When a capability-held agent is confused — and phase-honesty requires saying &lt;em&gt;when&lt;/em&gt;, not &lt;em&gt;if&lt;/em&gt; — the damage is limited to the authority in its hands. Prompt injection against an agent holding read-access to one folder and append-access to one file is an incident. The same injection against an agent holding your ambient authority is a career event.&lt;/p&gt;

&lt;p&gt;None of this is new. Dennis and Van Horn described capabilities for multiprogrammed systems in &lt;a href="https://dl.acm.org/doi/10.1145/365230.365252" rel="noopener noreferrer"&gt;1966&lt;/a&gt;, and capability operating systems have been built, verified, and largely ignored by the mainstream ever since — because for fifty years the mainstream actor was a human, and humans found ambient authority convenient. It was the right design waiting for a problem painful enough to justify it. Autonomous, injectable, machine-speed actors are that problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  This has to live at the OS layer
&lt;/h2&gt;

&lt;p&gt;Here's the part that can't be papered over with a framework. Capability discipline is only as strong as the layer that enforces it. A capability system implemented inside an agent framework is a polite fiction: the framework can refuse to &lt;em&gt;offer&lt;/em&gt; a dangerous tool, but the process underneath still holds your ambient authority, and anything that escapes the framework's abstractions — a shell command, a subprocess, a clever path — inherits all of it. That's not defense. That's a sign that says "please."&lt;/p&gt;

&lt;p&gt;For grants to mean anything, denial has to be enforced below every route the agent can take, which is the same structural argument we've made about &lt;a href="https://magenticos.com/blog/agent-trust-belongs-in-the-operating-system/" rel="noopener noreferrer"&gt;why agent trust belongs in the operating system&lt;/a&gt;: containment is a property of the environment the actor runs in, not of the actor's good manners. This is the arrangement MagenticOS is built around, and it's already on the public record: every consequential action passes a typed capability broker — no raw shell, no raw sudo. Default-deny isn't a mode you enable. It's the floor.&lt;/p&gt;

&lt;p&gt;Capabilities also compose with the other properties an &lt;a href="https://magenticos.com/blog/what-is-an-agent-native-operating-system/" rel="noopener noreferrer"&gt;agent-native operating system&lt;/a&gt; owes you. A grant you can enumerate is a grant you can audit, which is half of what makes agent work &lt;a href="https://magenticos.com/blog/inspectable-by-default-ai-agents/" rel="noopener noreferrer"&gt;inspectable rather than write-only&lt;/a&gt;: the record of what an agent &lt;em&gt;did&lt;/em&gt; means more when it sits beside the list of what it &lt;em&gt;could have done&lt;/em&gt;. Trust you can state, next to actions you can replay.&lt;/p&gt;

&lt;p&gt;The phase-honest caveat, as always: MagenticOS is in alpha, targeting 2026-12-07, and an alpha is a beginning, not a verdict. The claim in this post is not "we have solved agent security." The claim is that the trust model is decided at the foundation, and we think this is the right foundation — visibly, in the open, where the argument can be checked against the code.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;The app-permission model isn't wrong because anyone blundered. It's wrong because it encodes assumptions — trusted program units, human-speed actions, attention as the throttle — that agents void completely. Patching it with more prompts and more supervision just relocates the problem to your patience.&lt;/p&gt;

&lt;p&gt;Capability-based security replaces the unanswerable question "do you trust the agent?" with one that has an actual answer: &lt;em&gt;what did you hand it?&lt;/em&gt; Default-deny by default, typed grants, blast radius you chose in advance. That question belongs in the operating system, because that's the only layer positioned to enforce the answer. Sixty years after the idea was written down, it finally has its actor.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/capability-based-security-for-ai-agents/" rel="noopener noreferrer"&gt;magenticos.com/blog/capability-based-security-for-ai-agents&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>architecture</category>
      <category>agents</category>
    </item>
    <item>
      <title>The Silent Retry: When an AI Agent Does It Twice</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:53:37 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/the-silent-retry-when-an-ai-agent-does-it-twice-39p0</link>
      <guid>https://dev.to/mutageniclabs/the-silent-retry-when-an-ai-agent-does-it-twice-39p0</guid>
      <description>&lt;p&gt;Your agent was asked to pay an invoice. The payment call hung for thirty seconds and the tool returned a timeout. The agent did what every agent loop is built to do with an error: it tried again. The second call went through in two hundred milliseconds. The agent reported success, the task closed, and everyone moved on.&lt;/p&gt;

&lt;p&gt;Three days later the vendor emailed to ask why they had been paid twice.&lt;/p&gt;

&lt;p&gt;Nothing in that story is a bug in the usual sense. The model reasoned correctly from what it was told. The tool reported honestly that it had stopped waiting. The payment provider processed two valid requests. The failure sits in the gap between those three facts, and it is the most ordinary failure in agent systems today: &lt;strong&gt;AI agent retries treat "I don't know what happened" as "it didn't happen."&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  A timeout tells you one thing
&lt;/h2&gt;

&lt;p&gt;When a call times out, the caller learns exactly one fact: it stopped waiting. It does not learn whether the request reached the other side, whether the other side acted on it, or whether the action completed and only the response was lost. All three are common. The last one, where the work is done and the acknowledgement dies on the way back, is the one that produces the second charge.&lt;/p&gt;

&lt;p&gt;Distributed-systems engineers have a name for this. A request with an unknown outcome is in doubt, and the only safe moves are to find out what happened or to make the second attempt harmless. HTTP itself draws the line: &lt;a href="https://www.rfc-editor.org/rfc/rfc9110#section-9.2.2" rel="noopener noreferrer"&gt;RFC 9110&lt;/a&gt; defines which methods are idempotent, meaning the effect of sending the request twice is the same as sending it once, and notes that only those can be automatically retried after a communication failure. A &lt;code&gt;POST&lt;/code&gt; that creates a payment is not one of them.&lt;/p&gt;

&lt;p&gt;Payments learned this the hard way, which is why mature payment APIs accept an idempotency key. &lt;a href="https://docs.stripe.com/api/idempotent_requests" rel="noopener noreferrer"&gt;Stripe's documentation&lt;/a&gt; describes the arrangement plainly: the client generates a unique key, sends it with the request, and if the connection fails it can repeat the request with the same key without creating a second object. The server remembers the first outcome and returns it again.&lt;/p&gt;

&lt;p&gt;That fix exists because people had already been burned, one duplicate charge at a time. Agents are now reproducing the original burn across every tool that has not yet learned the lesson.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why agents make it worse
&lt;/h2&gt;

&lt;p&gt;Retrying an ambiguous request is not new. What agents change is who does the retrying, and how little they know when they do it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The retry moved up a layer.&lt;/strong&gt; In a hand-written integration, a developer decides per endpoint whether a retry is safe, and usually decides wrong only once. In an agent, the retry decision is made by a loop that sees an error string. The loop does not know whether the tool behind it charges cards or reads files. "Error, try again" is a reasonable default for reading a web page and a dangerous one for sending money, and the loop applies it to both.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The model can retry by rephrasing.&lt;/strong&gt; Even when the framework does not retry, the model often will. It reads "request timed out," concludes the action failed, and issues the same action again with slightly different arguments. Those different arguments defeat whatever duplicate detection the downstream service had, because to the service it is a new request. An agent that helpfully adds "(resending)" to an email subject has just guaranteed that no deduplication will catch it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Retries stack.&lt;/strong&gt; The HTTP client retries. The tool layer retries. The framework retries the tool call. The model retries the step. Each layer is individually sensible and nobody owns the product of them. Four layers of three attempts each is up to eighty-one requests for one intended action, and the logs for each layer show a single, well-behaved retry.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The record says success.&lt;/strong&gt; The final, successful attempt is the one that gets reported. The first attempt, the one that also succeeded, appears nowhere in the agent's account of what it did. This is why the silent retry is silent: the system's own story of the task is internally consistent and wrong. We wrote about the general version of this in &lt;a href="https://magenticos.com/blog/what-completed-means-agent-task-verification/" rel="noopener noreferrer"&gt;what "completed" means&lt;/a&gt;; the retry is its sharpest case, because the agent is not hiding anything. It genuinely does not know.&lt;/p&gt;

&lt;h2&gt;
  
  
  The incidents you will recognize
&lt;/h2&gt;

&lt;p&gt;The payment is the canonical one, but the shape repeats wherever an action changes the world:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The second email.&lt;/strong&gt; A send times out, the agent sends again, the customer receives two copies of a message that was supposed to be delicate.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The double ticket.&lt;/strong&gt; An issue-creation call hangs, the retry succeeds, and the team now has two tickets whose comment threads slowly diverge.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The overlapping deploy.&lt;/strong&gt; A deploy command times out at the edge while the pipeline is still running. The agent triggers it again. Two rollouts race.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The doubled order.&lt;/strong&gt; A procurement agent re-submits a purchase order. The supplier, reasonably, ships both.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The quiet duplicate row.&lt;/strong&gt; An insert times out; the retry inserts again. Nobody notices until a report sums the column.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of these needs a malicious prompt or a confused model. They need one slow network call and a loop that equates silence with failure.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the arrangement should be
&lt;/h2&gt;

&lt;p&gt;The fix is not "never retry." Networks fail, and an agent that gives up on the first timeout is useless. The fix is to stop letting the retry decision be made by the component that knows the least. A correct arrangement has a few properties, and none of them depends on the model being smarter.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Every consequential action has an identity before it runs.&lt;/strong&gt; The intent to pay this invoice, once, is a thing with a name that exists before the first attempt and survives every subsequent one. Attempts are attempts &lt;em&gt;of&lt;/em&gt; that action, not new actions. This is the idempotency key generalized: not a header one API happens to support, but a property every world-changing action carries regardless of which tool performs it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;"Unknown" is a first-class outcome.&lt;/strong&gt; An action is not in two states, succeeded or failed. It is in at least three: done, not done, and in doubt. A timeout produces in doubt. In doubt is not an error to be retried; it is a question to be answered, and the answer comes from the world, not from trying again.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Resolving doubt means reconciling, not re-issuing.&lt;/strong&gt; The correct response to "I don't know if the payment went through" is to look: query the payment, search the sent folder, list open tickets with that title. Only when the check says the action did not happen is a new attempt safe, and the new attempt carries the same identity as the first. If the check cannot be done, the right move is to stop and tell a person that the outcome is in doubt, rather than guessing in the expensive direction.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Retry policy depends on the kind of action, not on the error string.&lt;/strong&gt; Reading is retryable. Writing a file to a known path is usually retryable. Sending, paying, deploying and deleting are not, unless the target provably deduplicates. That classification belongs to the action, decided once, and it must not be overridable by a model that read "timed out" and felt it should try harder.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Every attempt is on the record.&lt;/strong&gt; Not just the one that succeeded. If the first attempt left no trace in the agent's account of the task, the task's history is fiction. &lt;a href="https://magenticos.com/blog/agent-actions-need-receipts/" rel="noopener noreferrer"&gt;Receipts for agent actions&lt;/a&gt; only work if the duplicate gets a receipt too.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this is not a framework fix
&lt;/h2&gt;

&lt;p&gt;Each of these properties can be bolted onto one framework, for its own tools. Plenty of good teams are doing exactly that, and it helps. But the silent retry is a cross-layer problem, and a fix that lives in one layer inherits the blind spots of that layer.&lt;/p&gt;

&lt;p&gt;A framework can deduplicate its own tool calls. It cannot see that the model shelled out to a script that called the same API. A tool can carry an idempotency key. It cannot stop the model from calling a different tool that achieves the same effect. A model provider can tell the model to be careful with retries. As we argued in &lt;a href="https://magenticos.com/blog/sandbox-is-the-wrong-unit-for-ai-agents/" rel="noopener noreferrer"&gt;the sandbox piece&lt;/a&gt;, an instruction is not a control, and "be careful" is the softest instruction there is.&lt;/p&gt;

&lt;p&gt;The place where action identity, outcome state, and retry policy can be enforced for every action, whichever app, framework or model produced it, is the layer that every action passes through. That is the operating-system layer. Not because the OS is a magical place for logic to live, but because it is the only place that sees the second attempt and can recognize it as the first one again.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to do on Monday
&lt;/h2&gt;

&lt;p&gt;You do not need a new operating system to stop the worst of this. Today:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Inventory your agent's world-changing tools&lt;/strong&gt; and mark which ones are safe to retry. Most teams have never written this list down.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Turn off automatic retries on the unsafe ones&lt;/strong&gt; at every layer you control, and make a timeout on those surface as "in doubt," not as an error.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Use idempotency keys wherever the downstream service supports them&lt;/strong&gt;, and generate the key once per intended action, not once per attempt.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Give the agent a way to check&lt;/strong&gt; before it re-tries: a read tool for every write tool that matters.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Log every attempt&lt;/strong&gt;, including the ones that look like failures.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are patches, and they will drift as tools get added. That is the argument for moving the guarantee down a layer. But a patch that stops the second invoice this quarter is worth more than an argument.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where we are with it
&lt;/h2&gt;

&lt;p&gt;We are building an operating system in which every action has an identity and an honest outcome, and in which "in doubt" is a state the system tracks rather than a string the model interprets. We are in alpha, and we are not going to claim we have closed every path to a duplicate. What we are sure of is the shape of the problem. A timeout tells you that you stopped waiting. Any system that treats it as more than that will, eventually, pay twice.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/the-silent-retry-ai-agents/" rel="noopener noreferrer"&gt;magenticos.com/blog/the-silent-retry-ai-agents&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>architecture</category>
      <category>programming</category>
    </item>
    <item>
      <title>Agent Actions Need Receipts</title>
      <dc:creator>Ian Daily</dc:creator>
      <pubDate>Tue, 17 Nov 2026 16:53:36 +0000</pubDate>
      <link>https://dev.to/mutageniclabs/agent-actions-need-receipts-4dmc</link>
      <guid>https://dev.to/mutageniclabs/agent-actions-need-receipts-4dmc</guid>
      <description>&lt;p&gt;Twice this month, our own build logs taught us the same lesson from different directions.&lt;/p&gt;

&lt;p&gt;First: we spent days believing a piece of our publishing pipeline was untested, because the verification run that proved it worked had been recorded only inside the artifact it verified. Nothing wrote it to a log anyone reads. The work was done; the record didn't exist; so operationally, the work didn't exist. We made decisions on stale information for two days.&lt;/p&gt;

&lt;p&gt;Second, the mirror image: we discovered our deploy scripts had been shipping content to production for weeks without appending a single line anywhere. Every deploy had happened. None of them had &lt;em&gt;recorded&lt;/em&gt; happening. When we later needed to know what was live and when it got there, the honest answer was: unknown by construction.&lt;/p&gt;

&lt;p&gt;Neither of these involved an AI agent misbehaving. They involved something more basic, and more embarrassing for a team building an agent-native operating system to admit: actions without records. We're telling the story anyway, because the lesson generalizes to every team wiring agents into real systems this year, and most of them are about to learn it the way we did.&lt;/p&gt;

&lt;h2&gt;
  
  
  An action without a record is a rumor
&lt;/h2&gt;

&lt;p&gt;Here's the uncomfortable property of side effects: they don't testify. A file got written, an email got sent, a deploy went out, and unless something wrote a durable record at the moment it happened, the only evidence is the world itself, which you'd have to go inspect, if you even knew to look.&lt;/p&gt;

&lt;p&gt;Humans paper over this constantly. We remember what we did. We recognize our own work when we see it. A human operator asked "did the deploy go out?" has a memory to consult.&lt;/p&gt;

&lt;p&gt;An agent doesn't get that courtesy, and neither does anyone supervising one. When an agent performs a hundred actions a day, "what happened?" is answerable only from records. If the records are partial, your knowledge is partial in ways you can't detect, because missing records look exactly like nothing happened. That's the trap: an incomplete audit trail doesn't feel incomplete. It feels like a quiet day.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this gets worse with agents, specifically
&lt;/h2&gt;

&lt;p&gt;Traditional software has this problem too, which is why &lt;a href="https://en.wikipedia.org/wiki/Audit_trail" rel="noopener noreferrer"&gt;audit trails&lt;/a&gt; and &lt;a href="https://www.ncsc.gov.uk/collection/10-steps-to-cyber-security/the-10-steps/logging-and-monitoring" rel="noopener noreferrer"&gt;logging discipline&lt;/a&gt; are decades old. But agents sharpen it in three ways.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agents act on inference.&lt;/strong&gt; A script does what it was told; if you have the script, you mostly know what it did. An agent decides what to do from context, which means you cannot reconstruct its actions from its instructions. The record of what it actually did is the &lt;em&gt;only&lt;/em&gt; source of truth about what it did.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agents span systems.&lt;/strong&gt; A single agent task might touch the filesystem, two APIs, an email account, and a calendar. Each of those systems keeps its own partial logs in its own format with its own retention. Nobody's logs tell the whole story, and stitching them after an incident is archaeology.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agents run when you're not looking.&lt;/strong&gt; The whole point is delegation. But delegation without records is abdication: if you weren't watching and nothing wrote it down, the action is unsupervised in the strongest sense, unreviewable even in hindsight.&lt;/p&gt;

&lt;p&gt;Put those together and the audit trail stops being a compliance artifact and becomes the substrate of trust. You can only extend an agent more authority if you can review what it did with the authority it had. No receipts, no review; no review, no earned trust; no earned trust, and you're stuck supervising forever, which was the thing delegation was supposed to end.&lt;/p&gt;

&lt;h2&gt;
  
  
  Receipts are a systems property, not a habit
&lt;/h2&gt;

&lt;p&gt;The tempting fix is discipline: tell the agent to log what it does. We've written before about why &lt;a href="https://magenticos.com/blog/instructions-are-not-controls/" rel="noopener noreferrer"&gt;instructions are not controls&lt;/a&gt; — an instruction to log is exactly as reliable as everything else that depends on a model choosing to comply, and the failure mode is silent.&lt;/p&gt;

&lt;p&gt;The reliable version puts the receipt where the action is. If every consequential action flows through one mediating layer, that layer can write the record &lt;em&gt;as a side effect of performing the action&lt;/em&gt;, not as a separate step that might be skipped. The action and its receipt become one event. Nothing downstream has to remember; nothing has to be trusted to confess. This is the same architectural instinct behind &lt;a href="https://magenticos.com/blog/inspectable-by-default-ai-agents/" rel="noopener noreferrer"&gt;inspectability by default&lt;/a&gt;: properties you care about should be produced by the structure of the system, not by the good behavior of its parts.&lt;/p&gt;

&lt;p&gt;And receipts change what "done" means. We've argued that &lt;a href="https://magenticos.com/blog/what-completed-means-agent-task-verification/" rel="noopener noreferrer"&gt;completion needs verification&lt;/a&gt; — an agent saying "completed" is a claim, not a fact. Records are what make verification cheap: checking a claim against a ledger is fast; checking it against the world is an investigation. Our two build-log incidents were both, at bottom, verification failures caused by ledger failures. The information existed. It just wasn't anywhere a checker would look.&lt;/p&gt;

&lt;h2&gt;
  
  
  The standard we now hold ourselves to
&lt;/h2&gt;

&lt;p&gt;Out of those two incidents came a rule we've adopted internally, and it's blunt: &lt;strong&gt;a verification recorded only inside the artifact it verifies is not a record, and a deploy that doesn't append to the ledger didn't happen.&lt;/strong&gt; Best-effort, never able to fail the action it records, written at the moment of the action, in the place where questions get asked.&lt;/p&gt;

&lt;p&gt;We're in alpha, and honesty about rough edges is part of the deal: we got this wrong in our own operations while designing a system whose thesis is that it should be impossible to get wrong. That's not a contradiction; it's the motivation. Every hour we spent reconstructing what our own scripts had done was an hour spent living in the world we're building MagenticOS to end — a world where the answer to "what happened on this machine?" is a shrug and some grep.&lt;/p&gt;

&lt;p&gt;The machine should know what happened on it. Every consequential action, one ledger, receipts by construction. If you're wiring agents into systems that matter, don't wait for your own two incidents. Decide now that actions without records don't count as actions.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://magenticos.com/blog/agent-actions-need-receipts/" rel="noopener noreferrer"&gt;magenticos.com/blog/agent-actions-need-receipts&lt;/a&gt;. Drafted with AI assistance and reviewed by the author before publication.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>observability</category>
      <category>security</category>
      <category>agents</category>
    </item>
  </channel>
</rss>
