You’ve seen the demos. AI agents that book your flights, write your code, manage your calendar. They’re impressive. They’re also terrifying.
Here’s the thing nobody’s talking about: the smartest AI agent is useless if you can’t trust it to stop when you tell it to. We’ve been obsessed with making agents more intelligent—smarter planning, better reasoning, faster execution. But intelligence without a kill switch is just a runaway train with a PhD.
I spent last week digging into a project called Arc—a proposed authority protocol for delegated AI agent actions. It’s not flashy. It’s not another LLM wrapper. It’s something far more important: a standardized way to say ‘no’ to an AI agent.
Arc reduces agent actions to four primitives: delegation, approval, revocation, and audit. That’s it. No fancy orchestration. No complex reasoning layers. Just the fundamental building blocks of trust. And that’s exactly what the industry is missing.
We’ve been building agents that can do anything. We forgot to build agents that can be stopped from doing anything.
The creator of Arc, shuu-beep, put it simply: ‘At this stage, I’m more interested in rejection than adoption.’ That’s the right attitude. We need protocols that are battle-tested, not just popular. We need to think about the second-order effects of autonomous code running in production—the tax agent that accidentally files a fraudulent return, the DevOps agent that deletes the wrong database, the personal assistant that orders 10,000 pizzas because of a misheard command.
These aren’t hypotheticals. Every AI agent is a potential weapon, and the only defense is a reliable undo button.
Arc comes with 14 runnable probes that cover delegation, approval, revocation, audit, and retention. You can run the entire suite with a single command: python3 run_demos.py. It’s open source. It’s practical. And it’s exactly the kind of foundational infrastructure that the AI agent ecosystem needs but nobody is building.
Because here’s the uncomfortable truth: the moat for the agentic future isn’t intelligence—it’s trust. Intelligence is a commodity. Every lab is chasing the same benchmarks. But trust? That’s a competitive advantage. The company that builds the standard ‘kill switch’ protocol will own the future of autonomous systems.
So next time you see a demo of an AI agent doing something amazing, ask yourself: Can I stop it? If the answer is anything but ‘yes, immediately and permanently,’ then that agent isn’t ready for the real world.
Arc is a step in the right direction. But it’s just a start. We need more developers thinking about authority, not just capability. We need more protocols that prioritize safety over speed. And we need to stop pretending that an intelligent agent is a trustworthy agent.
Trust isn’t a feature. It’s the product.
FAQ
Q: Why do we need a separate protocol for AI agent authority? Can't we just use existing authentication and authorization systems?
A: Existing systems are designed for deterministic human or scripted actions. AI agents are probabilistic, autonomous, and can have cascading side effects. They need real-time revocation, granular delegation that can be revoked mid-action, and immutable audit trails that capture the agent's reasoning. Arc fills that gap.
Q: Is this just another layer of overhead that slows down AI agent development?
A: It's a small upfront investment that prevents catastrophic failures. The 14 probes run in seconds. The cost of not having a revocation mechanism is measured in broken production systems, lost data, and destroyed trust. Speed without safety is reckless.
Q: Doesn't this approach limit the autonomy that makes AI agents useful?
A: Autonomy without boundaries is anarchy. The most useful agents are those that can operate independently within well-defined constraints. Arc provides those constraints without micromanaging every action. It's the difference between a leash and a cage.