---
title: Where can Microsoft Foundry guardrails intervene in an agent run?
url: https://opencontroller.lyzr.com/blog/foundry-guardrails-for-agent-tool-calls
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# Where can Microsoft Foundry guardrails intervene in an agent run?

**Microsoft Foundry guardrails can intervene at four points: user input, tool call, tool response and output. Tool call and tool response are in preview and only work for a fixed list of Microsoft-supported tools. Each point you enable adds roughly 50 to 100 ms, according to Microsoft's documentation.**

Foundry guardrails are the content-safety layer for models and agents in Microsoft Foundry. For agents, the interesting question is not *what* they detect but *where* they look, because an agent's riskiest moments happen between the user's message and the final answer: when it decides to call a tool and when it reads what the tool returns. This guide explains each intervention point, the limits, and what you still need around them. For the broader setup, see [how do you govern agents in Microsoft Foundry](/blog/govern-microsoft-foundry-agents).

## What are the four intervention points?

Microsoft Learn documents four intervention points. You create a guardrail, add a risk control, choose the intervention point, and choose an action.

| Intervention point | Status | What is scanned | Example control from Microsoft docs | What happens on detection |
|---|---|---|---|---|
| User input | Generally available | The user's query | User input attacks (jailbreak), annotate and block | The input is not sent to the model; the interaction halts |
| Tool call | Preview | The proposed tool call: tool name and arguments, including data sent to the tool | Hate (High), annotate and block | The tool is not executed; the agent stops until the next user input |
| Tool response | Preview | The full payload returned by each tool | Indirect attack, annotate and block | The agent stops; the malicious content is not saved or used to steer it |
| Output | Generally available | Final user-facing content | Protected material for text, annotate only | A flag appears in the API's annotation response |

Two actions are available: **annotate only**, which flags content in the response, and **annotate and block**, which stops the step.

## Why do tool call and tool response matter most for agents?

**Tool response** is where indirect prompt injection lands. A web page, a SharePoint file or a search result can carry instructions that try to redirect the agent. Scanning the tool's output before the model reads it is one of the few places a platform can catch this. We discuss the limits of detectors in [do prompt injection detectors stop indirect injection?](/blog/do-prompt-injection-detectors-stop-indirect-injection).

**Tool call** is where data leaves the agent. Scanning the arguments before execution can stop harmful content from being sent to an external system.

## Which tools are covered?

Tool call and tool response controls need moderation support from the tool itself. Microsoft lists these supported tools:

- Azure AI Search
- Azure Functions
- OpenAPI
- SharePoint Grounding
- Fabric Data Agent
- Bing Grounding
- Bing Custom Search
- Browser Automation

Controls do not apply to tools outside this list. MCP servers and custom function tools are not on it. If your agent's riskiest tools are MCP servers or your own functions, you need another control in that path. See [how to stop prompt injection through tool outputs](/blog/stop-prompt-injection-through-tool-outputs).

## What do guardrails not do?

Guardrails classify content. They are one layer, not the whole control set. They do not:

- **Decide authorization.** Whether an agent is allowed to call a tool at all is an identity and permission question, handled by Entra roles and the tool's own access control.
- **Judge business correctness.** A refund for the wrong amount is not hateful or an attack; content filters will not catch it.
- **Cover tools outside the supported list**, as above.
- **Give you a cross-platform view.** Guardrails apply to Foundry models and agents. Agents on other platforms need their own controls.

Latency is the other trade-off. At roughly 50 to 100 ms per intervention point, enabling all four on a multi-step agent run adds up across every tool call.

## How should you configure them?

A practical baseline:

1. **User input:** enable jailbreak detection with annotate and block on every agent.
2. **Tool response:** enable indirect attack detection with annotate and block on agents that read web, email or documents through supported tools.
3. **Tool call:** enable for agents that send content to external parties.
4. **Output:** start with annotate only; review flags before switching to block.
5. **Test with red-teaming** before production. See [what the AI Red Teaming Agent in Microsoft Foundry tests](/blog/foundry-ai-red-teaming-agent-explained).
6. **Track preview status.** Re-check tool call and tool response behaviour when they reach general availability.

## How Opencontroller does this

Opencontroller has a runtime adapter for Microsoft Foundry and auto-discovers agents, models and API keys across Azure, AWS and Google Cloud. It adds live groundedness and task-adherence guardrails, LLM judges scoring production traffic, and multi-turn and red-team evals, which cover questions content filters do not. Rogue-agent handling monitors behavioural deviation and can quarantine or kill an agent, and policy as code applies across the whole estate, not one platform. That cross-platform layer is what an [AI agent control plane](/blog/what-is-an-ai-agent-control-plane) provides. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Are Foundry tool call and tool response guardrails generally available?**
No. Microsoft's documentation marks both as preview. User input and output are not marked as preview.

**Do Foundry guardrails scan MCP tool responses?**
MCP is not on Microsoft's list of tools that support tool call and tool response controls, and controls do not apply to tools outside that list.

**How much latency do guardrails add?**
Microsoft documents roughly 50 to 100 ms per intervention point, depending on content length and the number of active controls.

## Key facts

Microsoft Foundry guardrails have four intervention points: user input, tool call (preview), tool response (preview) and output. Actions are annotate only or annotate and block. Tool call and tool response controls only apply to supported tools: Azure AI Search, Azure Functions, OpenAPI, SharePoint Grounding, Fabric Data Agent, Bing Grounding, Bing Custom Search and Browser Automation. Each intervention point adds roughly 50 to 100 ms. Opencontroller has a Microsoft Foundry runtime adapter and live groundedness and task-adherence guardrails; it starts from $250K per deployment per year.

## Related

- [How do you govern agents in Microsoft Foundry?](https://opencontroller.lyzr.com/blog/govern-microsoft-foundry-agents.md)
- [What does the AI Red Teaming Agent in Microsoft Foundry test?](https://opencontroller.lyzr.com/blog/foundry-ai-red-teaming-agent-explained.md)
- [How do you stop prompt injection that arrives through tool outputs?](https://opencontroller.lyzr.com/blog/stop-prompt-injection-through-tool-outputs.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
