Microsoft and Nvidia Unveil Unified AI Computing Stack for smooth AI Agent Deployment

At Microsoft Build 2026, Microsoft and Nvidia just made the loudest joint statement yet about where agentic AI is heading — and the path from demo to deployment got meaningfully shorter.

The headline: a unified accelerated computing stack. RTX Spark laptops and desktops claim 2x faster agentic inference on Windows. The DGX Station for Windows handles models up to 1 trillion parameters at up to 1 petaflop. On the software side, both vendors shipped isolation: Nvidia's OpenShell secure runtime and Microsoft's eXecution Containers, branded MXC. And Microsoft Foundry Agent Service, first introduced at GTC 2026, reached general availability on the same stage.

Three years of GPU-acceleration discussions between the two firms just turned into a shipping stack. Jensen Huang and Satya Nadella were both on stage for it. Here's what's actually on the table, and the parts worth wiring into your pipeline today.

The stack, in five pieces

Read it as five layers, not one blob:

• RTX Spark — Windows laptops/desktops running real agent inference on-device.
• DGX Station for Windows — workstation tier for trillion-parameter models.
• OpenShell (Nvidia) + MXC (Microsoft) — sandboxed runtimes so the agent can't escape its bounds.
• Microsoft Foundry Agent Service — the production plumbing, now GA.
• GitHub Copilot + GPU-accelerated Microsoft Fabric — the integration surface most developers hit first.

Foundry is the piece that flips agent work from science project to product. GA means you can deploy production-grade agents from the same control plane you'd use to deploy a web app.

RTX Spark: local inference stops being a punchline

"Local AI" used to mean small models, slow first tokens, the occasional kernel panic. RTX Spark changes the math. The article pegs it at 2x faster agentic inference versus the prior generation on Windows — vendor-supplied, but credible directionally after watching the RTX 40 → 50 cycle.

What it enables in practice: a developer with a current-gen RTX laptop can iterate against a real agent model without queueing against a shared cluster. Latency drops from "wait for the spinner" to "wait for the model." For agent loops that call tools and re-plan mid-turn, that gap is the difference between a fluent demo and a flaky one.

The hardware targets are laptops and desktops — not data centers. So the deployment story writes itself: design and test locally, push production-grade to DGX or Azure, keep latency-sensitive paths on-device.

DGX Station for Windows: when a laptop isn't enough

DGX Station is for enterprises that need to run, fine-tune, or evaluate models with up to 1 trillion parameters at up to 1 petaflop of AI compute. A petaflop is a quadrillion floating-point operations per second — national-lab class, until quite recently.

Healthcare, finance, scientific research: these are the buyers who needed this box two years ago and finally have a vendor-supported Windows path to it. Expect to see it referenced in the next round of agent benchmark papers, and inside the procurement plans of every Fortune 500 IT department that needs "on-prem" and "one trillion params" in the same sentence.

OpenShell and MXC: the sandboxes that actually matter

Agentic systems execute code. That code reaches files, networks, and other processes. The two announcements that matter most for shipping teams aren't the chips — they're the sandboxes.

OpenShell (Nvidia) is a secure runtime. eXecution Containers, branded MXC (Microsoft), is Microsoft's container-isolated environment for agents. Both isolate agent code from the host system. Your agent can shell out, read files, hit APIs, and you don't burn the laptop every time the prompt template misbehaves.

This is the piece most "just wire up an LLM" stacks skip. Without OS-level isolation, every agent deployment turns into a security review of arbitrary code execution. With it, the blast radius shrinks to a container you can snapshot, replay, and tear down. That's why both vendors are shipping the runtime in the same announcement as the hardware — agents aren't safe enough to put on a laptop without it.

How to actually use this today

If you want to start poking at the stack now:

# 1. Pull the Microsoft Foundry Agent Service SDK (GA since Build 2026, June 1-3)
npm install @azure/ai-foundry-agents

# 2. Stand up a sandboxed agent shell via MXC (eXecution Containers)
az container create \
  --resource-group agents-rg \
  --name mxc-agent-shell \
  --image mcr.microsoft.com/agents/mxc-runtime:latest \
  --cpu 4 --memory 8Gi \
  --restart-policy OnFailure

// 3. Define an agent that runs inside that sandbox
import { AgentClient } from "@azure/ai-foundry-agents";

const agent = await AgentClient.create({
  name: "code-reviewer",
  model: "gpt-4o",
  sandbox: "mxc-agent-shell",           // isolated via eXecution Containers
  tools: ["file_read", "shell", "git_diff"],
  policy: { max_runtime_seconds: 60 },  // bounded execution
});

const review = await agent.run({
  prompt: "Review PR #482 for error-handling regressions.",
});

Local RTX Spark path:

# Confirm your Windows box actually has RTX-class hardware
nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv

# Run a quantised agent model locally via ONNX Runtime + DirectML (Windows)
pip install onnxruntime-directml
python -m agents.local --model onnx://phi-4-mini --device dml

DGX Station path:

# Submit a trillion-parameter eval job against a Foundry-hosted DGX target
az foundry job submit \
  --target dgx-station-windows \
  --model microsoft/phi-5-1t \
  --dataset blob://myevalset \
  --gpus 8 \
  --runtime mxc

The sandboxed MXC runtime and the on-laptop inference path are the two I expect most teams to reach for first. Everything else is worth standing up once you have a real agent, not a demo.

GitHub Copilot and Fabric close the loop

Two integration points worth flagging because they're the part most teams will touch first:

GitHub Copilot now has deeper hooks into the same agent surface. If your team already codes inside Copilot, agent definitions written there can flow into the Foundry Agent Service without a copy-paste migration. Most "agent framework" launches skip the editor-side glue — this one ships it.

GPU-accelerated Microsoft Fabric is the data side. If your agent needs a warehouse view, Fabric on GPU moves the analytics tier out of the slow path. Same acceleration story, different surface area.

What doesn't change when the chip does

Five years from now the RTX tier will be a footnote. The DGX will be a workstation in every decent office. Microsoft Foundry will look like today's Azure App Service — invisible plumbing. The piece that has to stay the same is the surface the user touches — and on a team shipping agents to web, iOS, and Android, that surface is the component the conversation lands on.

OTF is built for that durable layer: the same agent surface across web and mobile, one component, one API. New chips just make the agent faster; they don't change what the user sees when the agent answers. Use the new stack to make the model think. Use a shared component layer to keep what the user sees from splintering across platforms.

What this enables for builders

Three concrete shifts worth planning around:

1. The dev loop gets fast. RTX Spark makes laptop-local iteration against a real agent model something an engineer can do in a single sitting, not a queue ticket against a shared cluster.
2. The deploy path normalizes. Foundry Agent Service GA means laptop prototype to Windows-and-Azure production is one pipeline, not a re-architecture every quarter.
3. Bounded execution becomes default. OpenShell and MXC mean agents can run code without a six-week security review every time the prompt template changes.

Build against the new floor — RTX on the laptop, DGX or Azure when the model gets serious, MXC isolation as the default — and spend the engineering time on the part that doesn't change when the chip does.