top of page
Search

How to Secure AI Agents: 7 Ways to Limit What They Can Touch

Nov 5
6 min read
How to Secure AI Agents: 7 Ways to Limit What They Can Touch
How to Secure AI Agents: 7 Ways to Limit What They Can Touch

A chatbot that gives a wrong answer wastes someone's time. An AI agent that takes a wrong action can delete a record, send an email to a customer, or change a configuration in a live system. The difference is that agents are connected to real tools, and what they can do is limited only by what they have been allowed to touch.


That shift changes where security effort should go. Much of the early conversation about AI risk focused on the quality of the output: hallucinations, bias, accuracy. For agents, the more useful question is what the damage could be if the output is wrong, whatever the reason.


This post sets out seven practical ways to answer that question by limiting what an agent can reach and do. It is written for business and technology leaders who need to decide how much access to give agents, and what controls to expect from the teams building them.


Why Limiting Access Is the Core Control

OWASP, the security community behind the widely used lists of top application risks, names a risk called excessive agency for applications built on large language models. It describes three causes: the agent has more functionality than it needs, more permissions than it needs, or more autonomy than it needs. The mitigation guidance follows directly. Minimise the tools an agent can use, limit its permissions, and require human approval for high-impact actions.


The reason this matters is that you cannot fully prevent an agent from producing a bad output. It might hallucinate, misread an ambiguous instruction, or be manipulated by hidden instructions inside content it reads, an attack known as prompt injection. What you can control is how much harm a bad output is able to cause. An agent that can only read a small set of records, and can only propose changes for a person to approve, has a small blast radius. An agent with broad write access to production systems does not.


1. Give Every Agent Its Own Identity

Agents often start life using a developer's credentials, a shared service account, or an API key pasted into a configuration file. This makes it impossible to tell who did what, and it means the agent inherits every permission its borrowed identity has.


Give each agent its own identity, registered and owned like any other non-human account. Tie it to a named owner, a purpose, and a review date. When something goes wrong, you can see exactly what that agent did, revoke its access without affecting anyone else, and show an auditor a clean record.


2. Give It Only the Tools the Task Needs

Most agent frameworks make it easy to connect many tools at once. That convenience is where excess functionality creeps in. A summarising agent that can read email does not need the ability to send it. A reporting agent does not need access to a system that can change data.


Use a default-deny approach. Start with no tools and add only the specific ones the task requires. Review each one and ask whether the agent could do its job without it.


Be particularly careful with third-party tools and connectors. Community-built components are easy to install and not always reviewed or maintained. Treat them like any other third-party software: vet them before use, restrict where they run, and keep an inventory.


3. Make Access Read-Only and Narrow by Default

Within each tool, scope the permissions as tightly as possible. Read-only should be the starting point, and write access should be the exception that needs a reason.


The same applies to data. An agent answering questions about orders does not need the full customer table with payment details. Limit it to the fields and records the task requires, and keep sensitive data out of its reach unless the use case truly depends on it. Narrow data access also limits what can leak if an agent is manipulated into revealing what it can see.


4. Require Human Approval for High-Impact Actions

Some actions should never happen without a person confirming them: deleting data, changing configurations, sending external communications, moving money, or modifying production systems. OWASP's guidance calls out human approval for exactly this kind of sensitive or destructive operation.


The word that matters is approval, not notification. A system that performs the action and then asks someone whether it was fine is an audit log, not a control. Real approval pauses the action, presents what the agent proposes to do, and only proceeds once a person has said yes.


Tier your actions. Low-risk reads can run freely. Moderate-risk actions might need sampling or after-the-fact review. High-impact actions need approval every time. This keeps agents useful without removing the safety net where it counts.


5. Enforce Authorisation in the Systems, Not in the Prompt

It is tempting to control an agent by writing instructions into its prompt: only do this, never do that. Prompts are guidance for a model, not security boundaries. A model can misread them, forget them in a long task, or be talked out of them by manipulated input.


The reliable approach is to enforce permissions in the systems the agent connects to, so that an unauthorised action is refused no matter what the model decides. If the agent should not be able to delete records, the system should reject a delete request from that identity, not depend on the agent choosing not to ask. OWASP guidance makes this point directly: authorisation belongs in downstream systems, not in the model's judgment.


6. Treat Everything the Agent Reads as Untrusted

Agents read emails, web pages, documents, tickets, and chat messages. Any of that content might contain instructions written by someone who wants the agent to do something it should not, such as forward sensitive data or take an action on their behalf. This is indirect prompt injection, and it works because the model cannot reliably tell the difference between data it is reading and instructions it should follow.


You cannot filter your way out of this entirely, so design on the assumption that it will sometimes work. Keep untrusted content clearly separated from instructions where you can. Limit what an agent that reads outside content is permitted to do, so a manipulated agent has little to abuse. And be especially cautious about combining three things in one agent: access to sensitive data, exposure to untrusted content, and the ability to send information out. An agent with all three is the one most likely to leak something.


7. Log Everything, Set Limits, and Keep a Way to Stop It

Even with strong controls, you need to be able to see what agents are doing and intervene quickly.

Log every action. Record which agent called which tool, with what input and what result. Without this, investigating an incident is guesswork, and proving to a regulator or customer what happened is impossible.

Set limits. Rate limits and usage budgets cap how much an agent can do in a given period. If an agent enters a loop or is hijacked, limits turn a runaway into a contained event.


Be able to stop it. Every production agent needs a documented way to pause or disable it quickly, and someone with the authority and the access to use it at any hour. Agents do not keep business hours, so the ability to respond should not either.


Questions Worth Asking Your Team

For leaders reviewing an agent project, these questions quickly show how mature the controls are.


  • Does each agent have its own identity, with a named owner?

  • What is the full list of tools and data it can reach, and why is each one needed?

  • Which actions require human approval, and does approval actually pause the action?

  • Are permissions enforced in the connected systems, or only described in the prompt?

  • What happens if the agent reads malicious content?

  • Can we see everything it did, and can we switch it off within minutes?

If the team cannot answer these clearly, the agent is not ready for access to anything important.


Securing Agents Is an Ongoing Operations Job

None of these controls is a one-time setup. Permissions drift, new tools get added, and agents get new tasks. Keeping the boundaries tight means regular reviews, monitoring, and a team that can respond when something looks wrong.


That operational side is where Dygital9 works. We design, build and operate AI platforms and the infrastructure beneath them, with 24/7 network and security operations across 34+ countries and 5 continents. For organisations moving agents from pilot into production, the practical question is not only how to configure the controls on day one, but who is watching them on day 200.


 
 
 

Comments


logo1.3.png

Dygital9 is a global enterprise technology and digital innovation company dedicated to solving business challenges and driving digital transformation for our customers and partners.

  • Instagram
  • Facebook
  • LinkedIn

EXPLORE

CONTACT

Newport Beach, CA, 92662

NEWSLETTER

Sign up for our latest news & articles. We won’t give you spam mails.

Thanks for subscribing!

© 2026 by Dygital9 Inc. All Rights Reserved.

bottom of page