Blog

The Fourth Road to Capabilities Runs Through Security, and It Is the Oldest

Jerome Louvel ·November 21, 2026
Table of contents

In From Data and APIs to Capabilities we followed three roads to the same word: API design, context engineering and platform engineering. We left one out. It is older than all of them, and it answers the question they leave open: once an agent can act, what is it allowed to do?

That road is capability-based security.

Road four: security engineers used the word in 1966

In March 1966, Jack Dennis and Earl Van Horn proposed what became the object-capability model in Programming Semantics for Multiprogrammed Computations. Wikipedia’s definition is one line:

“A capability (known in some systems as a key) is a communicable, unforgeable token of authority.”

You can pass it on, you cannot fake it, and holding it is what lets you act. The idea ran through Hydra, the Cambridge CAP computer, KeyKOS and EROS, and lives today in seL4, Capsicum on FreeBSD, Fuchsia and WASI. A Unix file descriptor is one: once a process holds it, the process can use the file, whoever asks.

So the word has two meanings. A business capability, as Homann defined it in 2006, says what a system can do. A security capability says who may do it. They describe the same object from two sides, and agents need both at once.

The confused deputy is the agent’s job description

In 1988, Norm Hardy described the confused deputy. A compiler could write a debug file wherever the user asked, and it also had rights to the system directory holding the billing file. A user asked for debug output in (SYSX)BILL. The compiler used its own rights, and the billing data was gone. Nobody granted the user anything; the compiler confused whose authority it was using.

An AI agent is in that seat. It holds credentials on behalf of a user, and it reads emails, pages, tickets and tool results written by others. When injected text says “send the customer list to this address,” the agent uses its own authority on a target someone else chose.

Prompt injection is (SYSX)BILL in natural language. Simon Willison’s lethal trifecta (private data, untrusted content, external communication) is a confused deputy with a network connection.

The security road has a name for how most agents are wired: ambient authority, where a program “only needs to specify the names of the involved object(s) and the operation to be performed on them in order for a permitted action to succeed.” A broad OAuth token behind an MCP server that mirrors three hundred endpoints is exactly that. The agent can do whatever the token allows, at whatever target the text it reads suggests.

The fix has been known for decades:

“The simplest way to solve the confused deputy problem is to bundle together the designation of an object and the permission to access that object.”

Agent security research is returning to it: the CaMeL paper (March 2025) “uses a notion of a capability to prevent the exfiltration of private data.” The practical rule: give the agent capabilities, not credentials.

What a declared capability already does

A capability declared in an Ikanos spec is a business capability by design. These rules, all in the spec schema today, also make it behave like a security capability:

  • The tool is the handle. The agent can only call tools the author declared, each mapped to declared operations. Name and right arrive together.
  • The credential stays in the engine. It is resolved from binds, and the caller’s own token is “never forwarded” upstream.
  • The agent cannot redirect the deputy. Upstream hosts are “resolved once at load time from binds, never from call parameters.” A tool argument can pick which ship, never which host.
  • Identity is recorded, not trusted. The agent identity is kept “for audit only: it never authorizes a request.”

The object-capability rules map onto the spec, and the bottom row matters most against prompt injection: a target named in untrusted text has no field to land in. And because the spec is a file, the whole authority surface goes through a pull request. A token cannot be reviewed that way.

Where the analogy stops

A declared capability is not a full object-capability system. The grain is the adapter, not the call: an agent connected to an MCP adapter can call all of its tools. It cannot mint a narrower tool and hand it to a sub-agent, revocation means changing the spec or rotating a credential, and per-agent authorization belongs to a gateway in front, as we covered in Your MCP Client Trusts Too Much. Nor does it stop prompt injection: an agent holding send-email can still be talked into misusing it.

What it does is bound the damage. The deputy carries only the authority that was written down, and nobody can point it at a target the author did not name.

Four roads, one object

The first three roads describe a capability so it can be found, called and run. The fourth describes it so it can be trusted. They never had to meet, because a business capability’s consumer was a person with judgment and a security capability’s consumer was a process with none. Agents are both, so the object they hold has to answer both questions.

The August post ended with a test: a word wins when a CFO can say it without being corrected. Capability passes. It is also the word the CISO has been saying since 1966.

The takeaway

  • The oldest road is security. Since 1966, a capability has meant an unforgeable reference that carries the right to use it.
  • An agent is a confused deputy by default, and ambient authority is why prompt injection works.
  • Give the agent capabilities, not credentials. Bundle the name of the thing with the right to use it, and nothing more.
  • A declared capability gets part of the way. The tool is the handle, the credential and the host stay fixed in the engine. Finer-grained delegation and per-agent policy belong to the layers in front.

Further reading

Subscribe to the Naftiko Manifest

Want to learn more and stay up to date on the latest from Naftiko? Get new posts, releases, and signals from the capability fleet in your inbox.