A production engineer asking “which of our wells are underperforming, and why” is a question that's easy to ask and expensive to answer. Answering it well means pulling sensor data, cross-referencing maintenance and inspection records, running the analysis, and writing it up: usually a multi-day exercise. This is the kind of question Atlas AI, the agentic AI layer in the Cognite Industrial AI and Data Platform, is built to take on: an agent that can pull the data, run the analysis itself, and hand back a cited draft in minutes instead of days.
For that to work, the agent needs to do more than talk. It needs to run code.
Agents need somewhere to run code
An agent that can only produce text is limited to what fits in its context window. Give that same agent a terminal and its capabilities change completely. It can list a directory, find a log, run a Python script, call an API, and use the result to decide its next step, all without that intermediate output ever passing through the model itself. Most of the coding agents people use today, from CLI tools to IDE assistants, work this way: a small set of building blocks (read a file, run a command, execute code) turns a language model into something that can actually get things done.
That pattern is powerful, and it's also why "where does this code actually run" has turned into a real infrastructure question of its own. The moment an agent can execute arbitrary, model-written code, you need somewhere for that code to run that isn't your laptop, your production host, or your customer's browser tab. That somewhere has to start almost instantly, remember what it was told to remember, and vanish cleanly the moment nobody's using it. Most agent tasks occur in bursts: idle for long stretches, then busy for a brief time.
Isolation is the actual hard part
None of this is new. Sandboxed code execution has existed for as long as people have run untrusted code. What's new is the shape of the problem once an agent – rather than a human – is the one deciding what code to run and when.
At Cognite, our agents act on live customer data in Cognite Data Fusion (CDF). That means the code an agent writes has to run somewhere with real access to real customer data – which turns "isolate the sandbox" from a nice-to-have, into the entire point.
A few properties fall out of that directly:
- One customer's agent session must never be able to see another customer's data, files, or running processes, even under a bug or an adversarial prompt.
- The sandbox needs to start in about the time it takes to think of the next step, not the time it takes to provision a VM.
- The state has to survive between steps. An agent's file system, installed packages, and running processes from five minutes ago should still be there when it comes back, without paying for a live VM in between.
- Because this is industrial data, not toy data, the whole thing needs to sit inside the same deployment, network, and compliance boundaries as the rest of Cognite Data Fusion. It can't be an exception.
Why we couldn't just pick a sandbox vendor
There is no shortage of companies offering isolated sandboxes with an API right now. On paper, it looks like a solved problem: pick a vendor, call their API, move on.
In practice, we ran into a narrower set of constraints than a typical sandbox evaluation. Cognite Data Fusion runs across multiple clusters, in multiple regions, on more than one cloud provider, often to satisfy a specific customer's data residency or geofencing requirements. A sandbox has to live inside the same region and, in some cases, the same private network boundary as the CDF project it's serving. That rules out most general-purpose sandbox providers outright. They run in their own regions, on their own cloud, and routing sensitive customer data through a third party's infrastructure would defeat the whole point of the isolation we were trying to build.
What we needed was a sandbox capability that could live inside the same cloud accounts, networks, and regions we already operate in, so isolation is a property of our own deployment, not a hop through someone else's.
What we built for our Azure-hosted clusters
Azure Container Apps Sandboxes, which reached public preview this summer, fit that shape well: hardware-isolated microVMs, sub-second startup, snapshot-based suspend and resume, and the ability to deploy directly into our own subscriptions, regions, and virtual networks. Because it's a first-class Azure resource rather than a third-party service, a sandbox for one of our Azure-hosted CDF clusters can sit inside the exact network boundary that cluster already requires.
We partnered with the Azure Container Apps team early, ahead of their public preview, to build against this primitive. As Kelvin Sundli, product manager for Atlas AI, put it in Microsoft's announcement:
"It gives every Atlas AI agent a safe, sandboxed workspace (file system, terminal, code execution) on a customer's live data in Cognite Data Fusion. [...] Sandboxes make it practical: aligned feature set, per-customer isolation, pause/resume across multi-day investigations, scale-to-zero economics."
This post is about the Azure piece specifically: the part of Cognite Data Fusion that runs on Azure, for customers whose clusters live there. Cognite Data Fusion also runs on other clouds, AWS and GCP, where similar work is happening separately.
Keeping the blast radius small
Getting isolation from the platform is one thing. Making sure our own service doesn't give that isolation back is another, and it's the part we spent the most time on.Neither the sandbox nor the agent itself ever sees a customer's credentials. The service that creates and talks to a sandbox holds the credentials on the agent's behalf; the sandbox itself only ever receives the specific command it was asked to run. If a piece of agent-written code tries to read a credential out of its own environment, there's nothing there to find.
Network access from inside the sandbox is controlled the same way. Rather than giving a sandbox open internet access and hoping the code behaves, outbound traffic from the sandbox is restricted by default, and only the specific destinations a task actually needs are reachable. An agent script that tries to reach somewhere it has no reason to go simply can't.
A design choice: sandbox as a tool, not a home
Once you have a sandbox capability, there's a real architectural decision to make: does the agent's own orchestration loop run inside the sandbox, or does the agent live outside it and use the sandbox as one tool among several?

Running the agent's own loop inside the sandbox is tempting: one environment, one lifecycle, nothing to coordinate across a network boundary. But it also means the sandbox now has to be trusted with the orchestrator itself, including whatever credentials, prompts, and control logic drive the agent's behavior. Every sandbox becomes a place that has to be trusted with the agent's own configuration, on top of its code execution.
We went the other way. The agent orchestrator stays outside the sandbox, as a service we run and control directly. When the agent needs to execute code, it creates a sandbox, submits a command, and polls for the result, treating the sandbox the same way it would treat any other tool: a narrow, well-defined capability with no more access than the task requires. It only ever sees the command it was asked to run and a scoped-down way to reach the data it needs, never the agent's own decision-making logic.
This isn't a pattern we invented. Many agent harnesses, including the one we use internally, support deep integration with a remote sandbox as a first-class mode: once an agent is pointed at one, it can automatically read and write files there, offload large tool responses to it, and pick up project-specific skills from inside it, all without the agent's own orchestration loop ever running on that machine.

Create returns before the sandbox is actually ready, the caller polls until it's live, then submits and polls again for the execution result. The project and user a sandbox belongs to come from the caller's own CDF credentials, not from an argument, so there's no separate "which project" step to get wrong. That's the whole interface from the orchestrator's side: create, submit, poll. Nothing about the agent's prompts, model, or credentials ever crosses into the sandbox.
That separation keeps the trust boundary simple. If we want to change how the agent reasons, swap models, or add new tools, none of that touches the sandbox. And if a piece of agent-written code turns out to misbehave, the blast radius is exactly one sandbox, not the orchestrator coordinating every other session.
It also makes the system more recoverable. Because the agent's own state and decision-making live in the orchestrator– not the sandbox– a sandbox that crashes, gets evicted, or times out doesn't take the agent down with it: the orchestrator just starts a new sandbox and picks up where it left off.
The orchestrator keeps running as its own long-lived service, outside the sandbox. Only the sandbox is disposable, and that's on purpose.
That's the same trade-off that lets someone ask which wells are underperforming and actually get an answer in minutes: an agent that can act, running somewhere that can't touch anything but its own task.
Conclusion:
Back to the production engineer asking which wells are underperforming: an AI agent is only useful if it can do the work, and it can only do that work safely if the code it runs can’t reach anything beyond its task. This approach keeps customer data inside the customer’s own region and network, keeps each customer’s work separate from everyone else’s, and never hands the agent a customer’s credentials. The result is answers in minutes instead of days, without compromising the security industrial data demands.

