Calendar changes take seconds to undo. Shopping through capped virtual cards limits the blast radius by design. Software and infrastructure live inside sandboxes, branches, and pull requests, so mistakes get caught before they ship or can be rolled back. Investments stay safe when ring-fenced in a separate, capped sub-account. Email, once sent, cannot be unsent, which is why it needs architectural containment, not just a careful agent.
People often think the question is how capable an agent is. Can it write good code, book the right flight, answer an email the way I would? But capability is only the surface question. The deeper one is what happens when the agent gets it wrong and whether getting it wrong costs you anything you can't get back.
I keep returning to this test: can the action be undone, is the blast radius capped, and is there a record of what happened? If the answer to all three is yes, I feel comfortable handing it to an agent. If any answer is no, I slow down. This isn't a technology question. It's a risk question, and it has been for as long as humans have delegated anything to anyone.
Why is reversibility the right test for agent delegation?
An agent's mistake is only as bad as the ability to fix it. That's the whole idea. A wrong calendar entry is an inconvenience. A sent email is a permanent record.
This is why so much of the anxiety about AI agents is misplaced. We worry about whether the agent is smart enough. We should be worrying about whether the action it's about to take can be reversed. Intelligence and reversibility are different axes entirely. Conflating them leads to bad decisions. You end up trusting a capable agent with an action that was never safe to delegate, regardless of how well it performs.
Five domains cover most of what people actually want agents to handle. Here's how they stack up.
Domain 1: Software & Infrastructure, the gold standard of verifiability & reversibility
Coding, databases, cloud infrastructure, browser automation. This entire stack was built around one idea: nothing is permanent until a human says it is.
That's why software engineers are the most comfortable delegating to agents. It's not because AI writes flawless code, and code is a verifiable output. The infrastructure around the code was designed for exactly this problem, letting many hands touch something without any single mistake becoming permanent.
The reversibility story here runs deep:
- Git branches and pull requests mean every agent-proposed change sits in a diff, waiting for review. GitHub Copilot, for example, can research a repository, plan changes, implement them in a sandboxed cloud environment, and open a pull request, but nothing merges until a human approves. GitHub's own documentation is blunt: "Copilot can produce incorrect or suboptimal code, including code that contains security vulnerabilities. Review and test the output before using it in production." That's not a disclaimer. That's the design assumption.
- Copy-on-write database clones (Neon is the clearest example here) let an agent work against a full, real snapshot of your database without touching the production copy. The clone is disposable. The production database is untouched until you deliberately promote changes.
- Ephemeral microVM sandboxes like E2B, Boat and Browserbase give agents a live execution environment, running code, browsing the web, interacting with UIs, inside an ephemeral container that gets wiped when the session ends. The agent never touches your real environment.
- Short-lived credential proxies like OneCLI, Nango, and Composio mean the agent never sees raw API keys or OAuth tokens. It operates through a scoped proxy that expires, can be revoked, and logs everything. No standing access, no long-lived credentials sitting in a prompt.
The pattern is consistent: everything happens in a sandbox until a human approves the final gate to production. Remove that infrastructure and the same AI-assisted work would be exactly as risky as an unreviewed email. The safety isn't in the model — it's in the architecture around the model.
Domain 2: Calendar management, low-stakes and fluid
Calendar management is the easy one. A calendar event is a proposal, not a commitment. You can edit it, move it, delete it, restore it. Mistakes take seconds to undo. The blast radius is small and contained to your own schedule.
The nuance worth naming: an invite sent to an external attendee notifies them immediately, and that notification can't be pulled back any more than an email can. So keep agent-managed calendar actions to your own calendar and internal holds, not outbound invitations to people outside your organization. If the changes stay internal, delegate freely. If the agent is sending invitations on your behalf to external people, you might want to hold off.
Domain 3: Shopping. Safe because the infrastructure contains the risk
Shopping is a reasonable candidate for delegation, but only because of a specific mechanism, virtual card infrastructure that was designed exactly for this.
The model is straightforward: an agent requests a virtual card through a payments API, with a per-transaction dollar cap, merchant category restrictions, and an expiration window attached. It completes the purchase. The card deactivates or gets reused according to policy. Every transaction is logged.
That's the whole reversibility test satisfied at once: capped blast radius, a form of reversibility through refunds and card controls, and a full audit trail. The agent never touches your real account details.
OpenCommerce is a useful marker of where this category is heading — shopping as a delegated, card-capped, logged transaction with passkey or Face ID sign-off required before anything clears. The credential isolation is structural, not just policy. Visa's Intelligent Commerce initiative and Mastercard's Agent Pay follow the same logic: a virtual card issued specifically to an agent, with spending caps and merchant restrictions attached by design.
The drawbacks are real. Single-use cards break recurring payments and subscriptions. Card-present acceptance has gaps. Reconciliation gets complicated. This works best for discrete purchases under a defined cap, not for managing ongoing subscription relationships.
Domain 4: Investments and trading. Risky by nature, safe only by design
Trading is risky. I don't think it helps to pretend otherwise. Money, markets, and irreversibility are the whole point of the activity, and no agent changes that. What changes is whether you stay in control of how much of that risk you take on. A tightly contained agent is of no use to someone like Goldman Sachs. An uncontained one carries extreme risk. Neither end works, so the useful ground is in between: an agent with real room to act, inside limits you set yourself.
The most common way to set those limits is to ring-fence the agent inside a cash-only, capped sub-account that is structurally separate from your main savings. Interactive Brokers' approach to AI partitions is the clearest example. It is a dedicated account with its own balance, its own permissions, and no path to the accounts that actually matter. The agent can trade within that partition. It cannot reach the rest.
The guardrails don't remove the risk. They cap the damage. Most trades in liquid markets can be unwound quickly, and losses are real, but they stop at whatever you've allocated to the sub-account, not your entire portfolio. You decide the size of the bet before the agent places a single trade. Outside that perimeter, the answer is no. An agent with access to your main brokerage account, without hard sub-account isolation, is exactly the kind of uncapped blast radius I'd stay away from, however well the model performs.
Think about it this way. Would you hand your entire net worth to an AI agent? Of course not. You would reach for the sub-account, the spending cap, the hard limits on what it can touch. I wonder why we don't apply the same instinct to email, which under the wrong circumstances can be just as risky, if not more.
Domain 5: Email, the unsolved problem (now with a solution)
Drafting an email is reversible. You can write it, delete it, rewrite it ten times. Sending it is the one action on this entire list with no undo button that matters. Once it's in someone's inbox, it's a fact in the world, read, forwarded, quoted, archived, regardless of how fast you hit "recall."
That's one half of the problem. The other half is access.
The standard way to give an agent access to your email is OAuth. And raw OAuth is all-or-nothing: the agent gets access to your entire inbox, your entire sent history, and the ability to send on your behalf with no distinction between a low-stakes newsletter reply and a sensitive client thread. The blast radius isn't just one sent email. It's every thread the agent can read and every message it can send.
This is the email problem. And it's been genuinely unsolved, until architectural containment gets applied to email the same way it gets applied to code, sandboxes, and virtual cards.
That's what Clam does. Instead of raw OAuth, Clam gives agents scoped MCP access, the agent sees only what it needs to see, nothing more. Credentials are isolated so the agent never holds standing access to your full account. Policy rules are deterministic and enforced outside the model, "Always under policy" — not "the model will probably do the right thing". And a human approval gate sits between the agent and anything irreversible: nothing leaves your outbox until you say so.
It's the same architecture that makes software delegation safe, sandboxed access, scoped credentials, human gate before the irreversible action, applied to email. Draft with the agent. Review the draft. You press send.
A simple way to sort agent tasks
Putting this together, I think of agent delegation across five domains and three tiers.
🟢 Green: delegate now
- Software and infrastructure inside sandboxes, branches, and pull requests
- Calendar management (your own calendar and internal holds)
- Shopping and travel booking through capped virtual cards with credentials sign-off
🟡 Yellow: proceed with the right architecture
- Investments and trading, inside a ring-fenced, cash-only sub-account with hard separation from main savings
🔴 Red: keep a human in the loop, or use purpose-built containment
- Email: draft with an agent, but use Clam's approval gates before anything leaves your outbox
The question isn't whether AI agents are capable enough yet. Increasingly, they are. The question is whether the action they're about to take can be undone, contained, and traced. For four of these five domains, the infrastructure exists. For email, it finally does too.
Sokratis
Your Inbox, safely shared with agents.
Share your inbox with your first agent in minutes and see every action it takes.

