Short answer: buyers now ask what your AI agent can do, not only what it says. Expect questions on which tools and systems the agent can reach, whose permissions it uses, which actions need a human to approve them, how you cap its steps and spend, how you stop it, what it logs, and how it treats untrusted content. Answer each one with the real setting: a tool list, a permission scope, an approval rule, a budget limit, a kill switch and a sample audit log line. If a control does not exist yet, say so, with an owner and a date.
This guide covers the agent-specific questions that follow the usual AI section of a security questionnaire. For the standard groups (training on customer data, retention, subprocessors, tenant isolation) read how to answer the AI section of a security questionnaire first. Here we add the questions that appear once your product can take actions. This is engineering guidance, not legal advice.
Why does an agent change the questionnaire?
A chat feature returns text, and a person decides what to do with it. An agent chooses a tool, calls it, reads the result and chooses the next step. It may send an email, update a record, run a query or call another service, with no person in the loop for each step. So the risk moves from what the model says to what the system does.
OWASP names this risk Excessive Agency (LLM06:2025 in the OWASP Top 10 for LLM Applications). It describes it as the vulnerability that lets damaging actions happen in response to unexpected, ambiguous or manipulated model output, whatever caused the model to misbehave. It gives three typical root causes: excessive functionality, excessive permissions and excessive autonomy. The sections below follow those three, then add budgets, a stop switch and logs.
What new questions do buyers ask about AI agents?
The ten groups below are typical, not quoted from any one form.
| Group | Typical question | What the buyer is checking | Evidence to attach |
|---|---|---|---|
| Action inventory | Typical question: What actions can the agent take in our systems? | What the buyer is checking: The agent cannot do more than the feature needs | Evidence to attach: Tool list with read or write and the system each touches |
| Identity | Typical question: Whose credentials does the agent use? | What the buyer is checking: It acts as the requesting user, not as a shared super-user | Evidence to attach: Auth flow diagram; scope list; token settings |
| Permissions | Typical question: Can the agent access data the user cannot? | What the buyer is checking: No privilege gain through the agent | Evidence to attach: Permission test results |
| Approval | Typical question: Which actions need human approval? | What the buyer is checking: High-impact steps are gated | Evidence to attach: Approval rule list; product screenshot |
| Budgets | Typical question: How do you limit cost, loops and volume? | What the buyer is checking: A stuck or hijacked agent stops early | Evidence to attach: Limit settings; alert rules |
| Stop control | Typical question: Can you switch the agent off, and how fast? | What the buyer is checking: A way to contain an incident | Evidence to attach: Kill switch design; last drill record |
| Audit trail | Typical question: Is every agent action logged and exportable? | What the buyer is checking: You can reconstruct what happened | Evidence to attach: Redacted log sample; admin export |
| Untrusted input | Typical question: What if a document or web page tells the agent to act? | What the buyer is checking: Injected content cannot trigger actions | Evidence to attach: Test results; tool policy |
| Third-party tools | Typical question: Which external tools or MCP servers can it call? | What the buyer is checking: No unvetted code in the loop | Evidence to attach: Approved server list; review record |
| Incidents | Typical question: What counts as an agent incident, and who tells us? | What the buyer is checking: AI is in your incident plan | Evidence to attach: AI section of the IR plan; contact route |
What can your agent do, and how do you show it?

Start with an action inventory. List every tool the agent can call, whether it reads or writes, and which system it touches. A buyer cannot judge an agent you have not described. OWASP's first mitigations are to minimise the extensions an agent can call, minimise what each one can do, and avoid open-ended ones such as "run any shell command" or "fetch any URL".
- Weak: "The agent has access to the tools it needs to help users."
- Strong: "The agent can call six tools: search tickets (read), read a ticket (read), draft a reply (writes a draft only), add an internal note (write), change ticket status (write, needs approval) and look up an order (read). It cannot send messages, delete records, run code or browse the web. The tool list is fixed per release and in the attached table."
- Evidence: the table of tools, the code or config that registers them, and the date of the last review.
Remove tools you dropped during development. OWASP lists a forgotten, still-available plugin as excessive functionality.
Whose permissions does the agent use?
This is the question that separates a safe agent from a dangerous one. If the agent calls your own API with a shared service account, any user who can talk to it can reach everything that account can reach. OWASP lists two related failures: a tool that connects with more rights than it needs (for example a database identity that can update and delete when it only needs to read), and a per-user tool that uses a generic high-privilege identity.
The fix is the same in both cases: run each action as the requesting user, with the least privilege the task needs, and enforce the check in the downstream system, not in the prompt. OWASP calls this complete mediation: every request an agent makes is validated against security policy by the system that owns the data, rather than trusting the model to decide what is allowed.
- Weak: "The agent respects user permissions."
- Strong: "The agent never holds its own credentials for customer data. Each tool call is made with the signed-in user's session token, so the API applies the same role checks as in the app. Tenant ID comes from the session, never from model output. A test in CI checks that user A's agent session cannot read user B's records."
- Evidence: an auth flow diagram, the list of scopes each tool requests, and the cross-user test names with a recent passing run.
If your agent connects through MCP servers, the MCP security guidance adds two points worth knowing. Passing a client's token straight through to a downstream API without validating it ("token passthrough") is forbidden by the MCP authorization specification, partly because it blurs the audit trail. It also recommends a progressive, least-privilege scope model over asking for broad scopes up front. We cover the wider risk in MCP server security risks. Retrieval is a related case: the agent must only fetch what the user may see, which we cover in permission-aware RAG.
Which agent actions need human approval?
Buyers do not expect a person to approve every step. They expect a clear line: reads and drafts run freely, while actions that are hard to undo, cost money, message people outside the tenant or change access wait for a person. OWASP's mitigation list includes requiring user approval for high-impact actions, applied either in the tool itself or in the downstream system.
| Action type | Example | Typical control |
|---|---|---|
| Read-only | Example: Search records, summarise a document | Typical control: Runs freely, logged |
| Reversible write | Example: Save a draft, add an internal note | Typical control: Runs, shown to the user, undo available |
| Hard to reverse | Example: Delete, send externally, change permissions | Typical control: Needs approval from the user or an admin |
| Money or contract | Example: Refund, purchase, sign | Typical control: Approval plus a hard cap; some teams keep these out of the agent entirely |
Make the approval real. A gate that sits only in the prompt is not a control. Put it in the tool code or the downstream API, record who approved, and show the approver what will happen. Public templates such as the Common Paper AI Addendum v1.0 include a clause on human oversight for regulated decisions (section 1.2), so your counsel should read the buyer's terms.
How do you cap what an agent can spend and do?

A confused or hijacked agent can loop, call tools without end or run up a bill, so buyers ask for hard limits. These guardrails are plain engineering. Set the values by risk. The table lists what to configure, not recommended numbers.
| Guardrail | What it limits | Where to enforce it |
|---|---|---|
| Tool allowlist per feature and tenant | What it limits: Which tools the agent can call at all | Where to enforce it: A tool gateway or the orchestrator, outside the prompt |
| Scoped credentials | What it limits: What each tool can touch | Where to enforce it: The downstream system's own authorisation |
| Step limit per run | What it limits: Loops and runaway chains | Where to enforce it: The orchestrator; end the run when reached |
| Time limit per run | What it limits: Stuck calls and long waits | Where to enforce it: The orchestrator and each tool call |
| Token and cost budget | What it limits: Spend per run, per user, per tenant per day | Where to enforce it: The model gateway, with alerts before the cap |
| Rate limit on write actions | What it limits: How much damage can happen per minute | Where to enforce it: The tool or API; OWASP lists rate limiting as damage limitation |
| Approval gate | What it limits: High-impact actions | Where to enforce it: The tool code or downstream API |
| Kill switch | What it limits: Everything, fast | Where to enforce it: A flag checked on every run (next section) |
A budget is also an abuse control. OWASP notes that logging and rate limiting do not prevent excessive agency but limit the damage and give monitoring time to catch it.
Evidence to attach: the limit configuration, an example alert, and a log line showing a run ended by a limit.
Can you switch the agent off, and how fast?
Buyers want containment. A kill switch is a flag the system checks before every agent run and every tool call, so you can stop one tool, one tenant or all agent features without a deploy. It should be tested, not just built.
- Scope levels: global, per tenant, per feature and per tool. A bad tool should be disabled without losing the whole feature.
- Where it is checked: in the orchestrator before each step and in the tool gateway before each call, so a run in progress stops at its next step.
- Who can use it: name the on-call roles, and say whether customers can turn agent features off for their own organisation. Our guide to enterprise readiness for your first big customer covers tenant-level AI settings like this.
- Proof: the date of your last drill and how long it took from decision to full stop.
Only state a time to stop if you have measured it in a drill.
What do you log about agent actions?
An agent audit trail needs more than a chat transcript. The buyer wants to reconstruct who asked for what, which tools ran with which arguments, what came back, and who approved. At the same time they do not want a second uncontrolled copy of their data in your logs.
- Record per tool call: timestamp, run ID, user ID, tenant ID, tool name, a redacted summary of arguments, result status, approval ID and the model version.
- Keep content out: store IDs and hashes, not prompt text or record contents, unless you need them and have a retention rule.
- Make it exportable and tamper-resistant: admins can export their own tenant's agent activity, and logs go to an append-only store with limited write access.
- Retention: state it, and match it to your policy and contracts.
ISO/IEC 42001 touches this at Annex A control A.6.2.8, recording of event logs for AI systems, and at A.6.2.6 on operation and monitoring. Neither tells you which fields to log. The fields above are an engineering choice you should be able to defend.
How do you handle prompt injection and untrusted content in an agent?
An agent reads emails, tickets, web pages and documents. Any of them can contain instructions meant for the model. OWASP's own example is an assistant with a mailbox tool: a crafted incoming email tricks it into scanning the inbox and forwarding sensitive content. Its suggested fixes were a read-only tool, a read-only OAuth scope and a manual review before send. In other words, limit what a successful injection can do.
Do not claim you have solved prompt injection. Say what an injected instruction cannot do: it cannot call tools outside the allowlist, it cannot act with more rights than the user, and it cannot complete a high-impact action without approval.
A strong answer reads like this: "Content from emails, tickets and documents is untrusted data. The agent has no web access, no tool that sends external messages without approval and read-only access to customer records, so even a followed instruction cannot do the harmful action. We run injection test cases each release; results are attached."
What about third-party tools and MCP servers?
If your agent calls external tools, those tools are part of your supply chain. Buyers ask which ones, who approved them and what data they see. Keep an approved list with an owner for each entry, pin versions where you can, review what each server can access, and record the review date. A new tool should go through the same approval as a new subprocessor, because it may see customer data. Our guide to MCP server security risks goes through what to check.
Which frameworks cover AI agents?
No framework was written only for agents, so map your answers to the ones buyers already cite. Mapping is a convenience for the reviewer. It is not a certificate.
| Source | What it gives you for agents |
|---|---|
| OWASP Top 10 for LLM Applications 2025, LLM06 Excessive Agency | What it gives you for agents: Three root causes (functionality, permissions, autonomy) and eight prevention steps, from minimising extensions to requiring approval and complete mediation |
| NIST AI 600-1 (Generative AI Profile, July 2024, voluntary) | What it gives you for agents: Twelve risks including Human-AI Configuration, Information Security and Value Chain and Component Integration, which map to oversight, access control and third-party tools |
| ISO/IEC 42001:2023 Annex A | What it gives you for agents: A.6.2.6 operation and monitoring, A.6.2.8 event logs and A.8.4 communication of incidents. Certification is by accredited bodies, not by Mono |
ISO/IEC 42001 sets no reporting deadline. Your clocks come from your contracts and from law, for example CERT-In's 6 hours for notifiable cyber incidents in India and, from 13 May 2027, the DPDP Rules' 72-hour report to the Board for a personal data breach. As of November 2026, India has no AI-specific incident reporting rule. Define what counts as an agent incident (an action taken outside its allowed scope, a wrong action on customer data, a tool compromise) and who tells the customer. Our post on AI incident response covers the plan.
How should you answer when an agent control is missing?
Agent features are new, and many teams have gaps. Use a three-part "honest no": the fact, the compensating control and the plan. For example: "Approval is enforced for external sends, not yet for status changes. Status changes are reversible, logged and limited to the user's own tickets. Approval for status changes ships next quarter, owned by the Head of Product."
Many gaps are small to fix before you submit: a read-only credential instead of a broad one, a step limit, a tool removed from the allowlist, a log field added. Fixing them turns a no into a yes you can prove. Never answer yes to a control that is only planned.
Where Mono helps
We help teams answer AI security questionnaires, including the agent questions. We list what your agent can reach, find where permissions, approvals, budgets, the kill switch and logs fall short of what you want to claim, fix the engineering behind those gaps, and assemble the evidence so each answer has proof attached. We are an engineering partner, not a certification body or a law firm, so counsel owns contract wording.
Sources: OWASP Gen AI Security Project, "LLM06:2025 Excessive Agency" (genai.owasp.org/llmrisk/llm062025-excessive-agency/). Model Context Protocol, "Security Best Practices" (modelcontextprotocol.io). NIST AI 600-1, Artificial Intelligence Risk Management Framework: Generative AI Profile, 26 July 2024 (nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf). ISO/IEC 42001:2023, Annex A controls A.6.2.6, A.6.2.8 and A.8.4 (docs.modulos.ai/frameworks/iso-42001/annexes-a-d.html, a secondary summary of the ISO annex). Common Paper, AI Addendum v1.0, section 1.2 (commonpaper.com/standards/ai-addendum/1.0/). CERT-In incident reporting directions and DPDP Rules, 2025, Rule 7. Last reviewed 20 November 2026.
FAQ
What new questions do buyers ask about AI agents on security questionnaires?
Buyers ask what actions the agent can take, whose credentials it uses, which actions need human approval, how you limit its steps and spend, whether you can switch it off, whether every action is logged, how it handles untrusted content, and which third-party tools it can call. Answer each with the real setting and attach evidence, such as a tool list, a scope list, a limit configuration and a redacted log sample.
What is excessive agency in an AI agent?
Excessive agency is OWASP's name (LLM06:2025) for the vulnerability that lets damaging actions happen after unexpected, ambiguous or manipulated model output. Its typical root causes are excessive functionality (too many or too broad tools), excessive permissions (tools with more rights than needed) and excessive autonomy (high-impact actions with no approval).
Should an AI agent use the user's permissions or its own service account?
It should act with the requesting user's permissions, using the least privilege the task needs, and the downstream system should enforce the check itself rather than trusting the model. A shared service account lets any user reach whatever that account can reach, through the agent. Show the buyer an auth flow diagram and a test proving one user's agent cannot read another's data.
What guardrails should a production AI agent have?
A production agent should have a tool allowlist, scoped credentials, a step limit and time limit per run, token and cost budgets, rate limits on write actions, approval gates for high-impact actions, an audit log and a tested kill switch. Enforce them in the orchestrator, tool gateway or downstream systems, not only in the prompt.
Does ISO 42001 or NIST AI RMF certify an AI agent?
No. NIST AI RMF and the NIST generative AI profile are voluntary frameworks with no certification. ISO/IEC 42001 is a management system standard certified by accredited certification bodies, and it covers the organisation, not a single agent. You can map your agent controls to either, but a mapping is not a certificate.
How do I answer an agent question when the control does not exist yet?
Say so plainly. State the fact, name any compensating control that exists today, and give the plan with an owner and a date. Do not answer yes to a planned control. Where the fix is small, such as a read-only credential, a step limit or a logging field, make the change before you submit so the answer can be a yes with proof.
