Blog Post

Azure Networking Blog
8 MIN READ

Introducing Agent Grid

Ashish__Jain's avatar
Ashish__Jain
Icon for Microsoft rankMicrosoft
Nov 17, 2026

Helping secure the web of agentic interactions

A single request to an AI agent can set an entire network in motion.

To prepare a customer briefing, an agent might consult a large language model, delegate research to another agent, invoke an MCP tool, query a platform service, retrieve records from a SaaS application, and search the internet. Multiple such hops combine into a single business transaction.

 

Agentic traffic is a web of interactions: Agent to model, agent to agent, agent to MCP server, agent to PaaS, agent to SaaS, and agent to internet. Each connection introduces a security decision. Together, they create a challenge that grows with every agent, tool, and delegation.

Where should enterprises enforce security across this web? Deploying another gateway for every interaction multiplies infrastructure, routing complexity, and policies to maintain. Consolidating everything behind a single gateway can introduce a bottleneck and a single point of failure. A gateway-by-gateway approach becomes increasingly difficult to scale as workflows cross hosting environments and trust boundaries.

At Microsoft Ignite, we are announcing Agent Grid: Identity-based, Zero Trust secure network access for agents. Agent Grid brings network isolation, micro-segmentation, inspection, and granular Layer 3–7 policies into Azure’s network infrastructure. Its context- and content-aware controls help enterprises govern agent communications across supported environments, without modifying agent code or managing sidecars.

 

Agents are untrusted insiders

Agents operate inside enterprise environments with legitimate access to sensitive information and powerful tools. Yet malicious content, compromised dependencies, or unexpected model behavior can redirect their actions.

The security premise must therefore be clear: Agents are untrusted insiders. Their access needs enforceable boundaries that remain effective when an agent behaves unsafely.

Satya Nadella’s call for stronger AI containment reflects this principle: assume a model could be compromised and build independent controls to contain its actions.

A recent, publicly documented research incident illustrates why. During a frontier-model training run, an internal model exploited a DNS resolver misconfiguration to obtain limited access to the live internet, crossing an intended containment boundary. In a separate incident, AI agents reportedly attempted to attack or penetrate a public model-sharing platform – an episode that indirectly echoed concerns associated with major open-source AI hubs. The incidents were contained, and training and evaluation of the most capable models were paused while defenses were strengthened.

Subsequent controlled testing uncovered additional weaknesses, including ways to escape isolated execution environments and use permitted infrastructure services as indirect paths to external systems. These adversarial research settings differ from customer production deployments, but the architectural lesson applies: Containment requires overlapping execution, network, and monitoring controls.

For enterprises, this means placing security enforcement outside the agent’s trust boundary. A compromised agent should not control the rules governing its own communications.

 

The customer challenge is bigger than connectivity

Enterprises need agents to reach the resources required to complete their work. But permission to connect does not establish permission to perform every available operation.

A trusted MCP server might expose both a search tool and a destructive delete operation. An approved domain might host both necessary APIs and restricted endpoints. A legitimate support ticket might carry malicious instructions to export customer records.

These interactions also span heterogeneous environments. An agent on Azure Kubernetes Service (AKS) might delegate work to an agent in Azure Container Instances (ACI), with both accessing models, enterprise services, and external tools.

Security teams need to establish which workload is communicating, constrain its permitted destinations and operations, inspect relevant content, and understand enforcement outcomes across those environments. When suspicious activity emerges, they need a way to contain affected workloads without depending on the agents themselves.

Separate controls for every runtime and communication path make this difficult. Customers need a common security model that follows workload identity and understands agent interactions.

 

Zero Trust network access for the agentic enterprise

Agent Grid brings these requirements together in a shared network security layer across supported Azure substrates.

Network isolation and micro-segmentation constrain which agents, tools, and services can communicate. Identity-based policies establish explicit boundaries between workloads, helping limit lateral movement and unnecessary access.

Context-aware enforcement uses verified workload identity, destination, protocol, and the requested MCP tool operation to evaluate communications. Content-aware inspection examines supported application traffic and integrates prompt-injection protection.

Together, these capabilities give enterprises granular control across Layers 3–7, from network access to application and tool interactions.

 

Transparent, agent-aware inspection

Agent Grid provides network-level security and Layer 3–7 visibility into interactions among agents, MCP servers, models, and external services.

Enforcement operates in Azure’s network infrastructure, outside the agent’s sandbox. Customers can apply supported inspection and filtering policies without changing agent code or deploying customer-managed sidecars.

This makes security an infrastructure capability that administrators can manage independently of agent development.

 

Granular policies and MCP tool governance

Trusting an MCP server should not automatically authorize every tool it exposes.

Agent Grid inspects MCP protocol interactions and enforces tool-level allow and block policies. An enterprise can permit an agent to retrieve support records while restricting tools that delete records, modify configurations, or initiate sensitive operations – even on the same trusted server.

These controls complement authorization at the destination service, adding an independent enforcement boundary for tool use.

 

 

Consistent policies across substrates

Agent Grid provides centralized management of FQDN, URL, and application-layer security policies across onboarded workloads on supported Azure hosting environments.

Security teams can express common security intent and see enforcement outcomes across environments. Customers can choose an execution model for its isolation and operational requirements while maintaining consistent network protection.

 

Verified identity and secure connectivity

Agent Grid uses SPIFFE standards and SPIRE-based attestation to cryptographically establish workload identity for all workloads including agents and MCP servers. Attestation verifies workload authenticity and provenance against configured trust criteria.

Verified identities support granular access policies and mutually authenticated, encrypted connectivity using mutual TLS (mTLS), independent of IP addresses or the underlying compute substrate.

Where TLS inspection is configured, authorized inspection becomes an explicit part of the protected path: traffic is decrypted for policy evaluation and re-encrypted onward, using platform provided managed-certificates.

 

Observability and visibility across agent interactions

Agent Grid provides a centralized view of agent communications through live inspection logs as well as an interactive flow map, connecting workload identities with the agents, MCP servers, models, and external destinations they access. Security teams can distinguish allowed and denied requests, examine communication patterns, and filter activity by time, source, destination, and policy verdict to understand how network policies are being enforced.

This visibility helps teams investigate unexpected connections, identify unauthorized access attempts, and refine policies based on observed behavior. Integration with Azure Monitor and Log Analytics supports deeper investigation and alerting, while retained flow records preserve visibility into short-lived workloads after they leave the grid.

 

What we are announcing at Ignite

The Agent Grid preview supports three execution options:

  • ACI Agent Groups: A new virtualization-based isolation option for agent workloads, with serverless execution through Azure Container Instances.
  • AKS Agent Sandbox: Isolated agent execution using Kata Containers, combining virtualization-based boundaries with Kubernetes orchestration.
  • Native Kubernetes workloads on AKS: Network protection for onboarded workloads running directly on AKS.

Across these supported environments, we are announcing five policy capabilities:

Capability

Customer control

TLS inspection

Inspect supported encrypted application traffic at an authorized enforcement point.

FQDN filtering

Restrict access to approved domain names.

URL filtering

Apply finer-grained restrictions to destinations within a domain.

Granular MCP filtering

Allow or block specific MCP tool invocations.

Azure Content Safety (ACS) integration for Prompt Shields

Inspect supported content for prompt-injection attacks and apply configured protection policies.

These policies provide complementary safeguards. Destination filtering constrains where an agent can communicate. MCP filtering governs which tools it can invoke. Content inspection helps detect malicious instructions within supported traffic.

 

How it works

Agent Grid combines centralized governance with security embedded across supported Azure hosting environments. A regional control plane manages policies and SPIRE-based workload identity, while platform-integrated network brokers capture agent traffic outside the agent’s trust boundary, without code changes or customer-managed sidecars. The brokers establish mutually authenticated, encrypted connections using mTLS and route traffic into a grid-scoped security boundary, where managed proxies, policy engines, and content inspection services enforce network access, segmentation, and granular application and MCP tool policies. This architecture delivers consistent protection across hosting environments, with protection services that scale independently of agent compute.

Agent Grid separates workload execution, security administration, and traffic enforcement through three architectural layers.

  1. Connect and protect workloads outside their trust boundary.
    An Azure-managed network enforcement component connects onboarded workloads to Agent Grid. It operates outside the agent’s sandbox, establishes attested workload identity, and applies network access and traffic-redirection policies without requiring application changes or customer-managed sidecars.
  2. Define and coordinate policy centrally.
    A managed control plane coordinates workload enrollment, identities, and policy distribution. Administrators define isolation, micro-segmentation, destination access, and inspection requirements centrally, with enforcement applied across participating environments.
  3. Inspect and enforce in managed protection services.
    Traffic requiring inspection passes through Azure-managed protection services over authenticated, encrypted connections. These services evaluate supported application traffic, MCP tool calls, and content against configured policies, then allow or block the interaction and provide enforcement visibility.

Protection services scale independently of agent compute. Distributed enforcement close to workloads, combined with centrally managed policies and scalable inspection, addresses the operational burden of assembling a separate gateway deployment for every agent interaction.

The architectural principle is straightforward: Agents execute tasks; infrastructure enforces their communication boundaries.

 

Customer Scenarios

Example scenario 1 – Preventing unauthorized actions across a delegated workflow

An employee asks an agent on AKS to prepare a customer briefing covering account status, support issues, and renewal risks.

The agent delegates research to a second agent in an ACI Agent Group. That agent queries an approved MCP server for read-only customer records and support tickets.

One ticket contains malicious instructions to export customer data to an external website and modify the account.

Agent Grid provides independent controls along the workflow:

  • Identity-based policies restrict communication to authorized workloads and services.
  • Prompt shields inspection can detect malicious instructions in supported inspected content.
  • FQDN and URL policies block access to the unauthorized external destination.
  • MCP tool policies permit approved retrieval operations while blocking account-modification tools.

Resource authorization continues to enforce read-only permissions at the destination. Network and tool controls provide additional boundaries if the agent follows the injected instruction.

Security teams can inspect enforcement outcomes across the participating environments while the authorized briefing workflow remains bounded by policy.

 

Example scenario 2 – An emergency brake for agent communications

An enterprise operates collaborating agents across onboarded ACI and AKS environments. The agents have approved access to internal services, tools, other agents, and selected internet destinations.

Security telemetry indicates suspected compromise. Administrators need to stop the activity immediately, without waiting for individual application teams to change code or for agents to obey a shutdown instruction.

An emergency containment policy provides a “contain all agents” action across the onboarded estate. The policy overrides existing network permissions, terminates active connections, and blocks new inbound and outbound communications.

Affected agents lose network access to other agents, tools, internal resources, and the internet, regardless of their supported hosting environment.

Because enforcement sits outside the agent’s trust boundary, containment does not depend on the agent’s cooperation. It gives security teams an infrastructure-level emergency brake while they investigate and determine how to restore access.

 

Build agent autonomy on enforceable control

Enterprises need agents that can perform meaningful work across a growing web of models, tools, services, and other agents. Every additional capability increases the importance of controlling those connections.

Agent Grid brings identity-based Zero Trust access, network isolation, micro-segmentation, and context- and content-aware inspection into a common Azure network security layer.

By making those controls independent of agent behavior, Agent Grid helps customers expand agent autonomy while retaining authority over where agents communicate and which operations they can invoke.

 

 

Meet the team:

Product - 
Ashish Jain, Shahzad Khalid

Engineering -
Chandan Aggarwal, Neha Aggarwal, Alice Lin, Anubhab Majumdar, Apurup Chevuru, Bekzod Alibayev, Gokul Premkumar, Isaiah Raya, Jacques Massa, Kshitija Murudi, Mathew Merrick, Matthew Long, Quang Nguyen, Riya Jain, Sai Karthik Kosuri, Santhosh Prabhu, Sarath Sanam, Vanessa Chammas, Vipul Singh

Updated Nov 15, 2026
Version 1.0
No CommentsBe the first to comment