The foundation for agents that act: Run code securely, connect to enterprise resources and carry work forward, with the controls your business needs.
From AI that answers to AI that acts
Enterprises didn’t move to the cloud by adopting a turnkey platform on day one. They started with services they could trust, like virtual machines and storage, and expanded from there as new applications and operating models emerged.
AI is following a similar path, but its next step is different in kind: AI is moving from systems that primarily generate answers to agents that can act on a user’s behalf.
Agents generate and execute code, use tools, access enterprise data, and interact with applications and services to complete work. That introduces a new risk and security profile, from prompt injection to credential misuse. Agents also work in bursts. They often pause for decisions, system responses, or external events, then must resume exactly where they left off. And they must operate alongside decades of existing applications and data, not around them.
That calls for a cloud foundation designed around how agents execute, connect, persist, and act, while extending the security, scale, reliability, and governance enterprises already expect from Azure.
Enterprises requirements
As customers move from exploring AI agents to deploying them at scale, a common set of requirements emerges. They want agents that are:
- Isolated, so the code an agent generates cannot reach beyond the boundaries that were set .
- Governed, with a clear identity and access only to the systems and data they are authorized to use.
- Connected to existing applications, data and private networks, so agents can work with information where it already lives.
- Efficient, so an agent waiting for an user’s input or an event does not consume compute it is not using.
- Flexible, with the control that comes from choosing their own models, frameworks and harnesses. Just as often, customers tell us they want to stay in control. Managed AI platforms fit many scenarios and will keep getting better, but many enterprises also want to pick their own models, frameworks and agent harnesses, run agents next to their existing estate and shape the experience around their own processes. They want Microsoft's security and scale without handing over decisions about how their agents behave.
In short, customers want a trusted foundation they can build on, with the flexibility to create what works for their business.
Agentic AI requires a new infrastructure foundation
As we move from generative AI to agentic AI, we're seeing a fundamental shift in what applications demand from the underlying infrastructure.
Traditional applications are relatively predictable. They start, execute, and run within established resource boundaries. AI agents behave very differently. They operate autonomously, execute code, invoke tools, interact with other systems, and frequently pause while waiting for a model response or external event.
That means infrastructure needs to separate state from compute, release resources when they are not needed, and restore execution quickly and reliably. A new set of infrastructure requirements is also emerging that includes isolated execution, elastic compute, durable state, secure identity and connectivity, and consistent policy and observability across every interaction. The infrastructure for agentic AI needs to help agents securely execute, connect, persist, resume, and act at cloud scale.
That is the foundation we are building with Azure Infrastructure for Agentic AI.
Azure infrastructure purpose-built for agents
We are making available a range of Azure infrastructure capabilities that developers need to run agents on Azure. These capabilities deliver the highly secure execution foundation for running agents on Azure. They bring together isolated execution, controlled connectivity, identity and authorization, and persistent state so agents can safely execute code, interact with enterprise resources, and carry work forward across sessions.
The core primitive for agentic c sandboxing is Azure Container Instances (ACI), which provides hardware-isolated micro-VM sandboxes for agent execution. Network isolation and policy-based controls define where agents can connect, Microsoft Entra Agent ID establishes identity and governs what an agent is authorized to access, and Azure Blob and File Storage preserve files, artifacts, and execution state.
Customers can adopt these capabilities in the way that best fits their needs. For faster time to value, Microsoft Foundry provides a fully managed agent experience, and AKS Sandboxes extend agent sandboxing to organizations that operate on Kubernetes. For customers who require greater control, the same capabilities are available directly through Native Azure APIs, allowing them to select their own models, frameworks and agent harnesses and to integrate agents with their existing environment. Each path is built on the same foundation, with consistent isolation, identity, connectivity and lifecycle controls.
Isolate agent execution by design
Agents may run Python, install dependencies, invoke a compiler, drive a browser or chain shell commands. You cannot review that code before it runs, so the boundary around it must hold on its own.
Azure Container Instances provides the isolated execution environment for running agentic workloads on demand. Each sandbox is hardware-isolated and does not share a host kernel with its neighbors, and policy-driven controls decide what it is allowed to do. If an agent is tricked into running something it should not, hardware isolation and policy controls help contain the impact.
Developers can provision an environment, submit work to it, and retrieve results and logs. Model selection and orchestration stay with the developer's own agent logic.
Get to useful work faster
Agents often pause while waiting for another agent, a system response, or an external event. When work resumes, the agent should pick up where it left off, with its packages, browser session, repository, and other state already in place.
Azure is built for fast startup and fast resumption. With snapshot and restore, applications can reuse an environment that's already set up instead of repeating setup each time, even on a different host. We measure performance by how quickly an agent can start doing useful work, including the time it takes to restore saved state.
"As AI agents increasingly generate and execute code in real time, security and isolation become paramount. With Azure Container Instances and Hyper-V isolation, we’ve built a secure, scalable architecture that provides every Cowork session with its own isolated execution environment and tightly controlled network access. This approach enabled us to move from concept to production in just months, without the complexity of managing dedicated infrastructure, while giving us the agility to scale with growing demand." – Mauktik Gandhi, VP, Engineering, Agent 365 and Agent Cloud Foundations
Connect agents to your business, within clear boundaries
To do meaningful work, an agent needs access to the right systems and data. But an agent with unrestricted reach is a risk no security team will accept. Enterprises need both: access, and strict limits on it.
Agent Grid provides secure connectivity through network isolation and policy-based access controls. Infrastructure teams can decide exactly which enterprise APIs, private services and tool endpoints each agent can reach.
Microsoft Entra Agent ID gives every agent a verifiable identity, with authorization and audit built in. Network connectivity and resource authorization are enforced independently, so reaching a database does not automatically grant access to its data. Logs and execution outputs give teams a full record of agent activity, so they can validate results and trace failures to the root cause.
Control the lifecycle, not just the deployment
Agent work comes in bursts. Applications need to hold on to progress, branch into alternatives, free up resources during pauses and resume when there is work to do.
The Azure Infrastructure capabilities we introduced expose lifecycle controls to create, execute, snapshot, clone, hibernate, restore and delete sandboxes. Your application decides when execution pauses and when it resumes; the platform does not guess based on a quiet process.
Figure 2. Application-driven lifecycle
Set up once, explore in parallel. Prepare a repository and its dependencies once, take a snapshot, and clone several sandboxes from it to try different fixes or run evaluations. Connections to external services and mounted storage stay governed separately, because cloning a sandbox does not duplicate them.
Keep the work, release the compute. When an agent is waiting, the application can snapshot and hibernate its sandbox. Sandbox compute is billed only while running, not while hibernated; storage and other services follow their usual charges. Azure Blob Storage persists files, artifacts and saved execution state, so the next session continues from where the last one stopped instead of starting over.
From a task to a finished workflow
Picture a coding agent asked to investigate a failing test.
- The application creates an isolated sandbox, makes the repository available and prepares the tools.
- Agent Grid and Microsoft Entra Agent ID govern where it can connect and what it can access.
- The application takes a snapshot and clones several sandboxes, each trying a different fix and running the tests.
- The application compares the results and carries the best change forward.
- While it waits for a developer's approval, the application hibernates the sandbox, with no compute billed. Once approved, the agent continues from where it stopped.
Data-analysis and automation agents follow the same pattern: reach authorized data, keep the results, release the compute. The platform runs the execution lifecycle, and you stay in control of how the agent behaves.
Build the agent, not the infrastructure around it
Reliable agent applications need execution, connectivity, identity, state and lifecycle management working together. Assembling those pieces should not distract developers from the customer problem their agent is meant to solve.
The latest Azure infrastructure innovations for Agentic AI make these capabilities available across Microsoft Foundry, AKS Sandboxes, and Native Azure APIs, giving developers the flexibility to build agents that act within defined boundaries, preserve their progress, and continue their work when ready.