Agent Harness GA: Microsoft Ships the 2026 Agent Runtime

[Alex]: Hey everyone, welcome back to the Nerd Level Tech AI Cast—your favorite spot for all things nerdy, techy, and occasionally, a little too caffeinated. I’m Alex.

[Jamie]: And I’m Jamie! The non-caffeinated one, but don’t worry, I’ve got all the curiosity you need. Today’s episode is titled: “Agent Harness GA: Microsoft Ships the 2026 Agent Runtime.” So Alex, what are we getting ourselves into?

[Alex]: Oh, this one’s a biggie. Microsoft just took their Agent Framework harness to General Availability—which in non-corporate speak means, “It’s finally stable, you can actually use it in production without living in fear.” [Chuckles] It’s all about how you turn a plain language model into a full-blown agent.

[Jamie]: OK, so for folks who hear “agent harness” and think, like, dog leashes for robots—what are we actually talking about?

[Alex]: [Laughs] It’s less about walking your AI and more about controlling it so it doesn’t eat your slippers. Think of the agent harness as this runtime wrapper around a language model. The model by itself just spits out text—no memory, no tool use, no real “doing” anything. The harness is all the engineering glue: it manages context, tracks what tools the agent can call, handles approvals, and keeps logs. It’s the difference between a parrot and an intern who can actually get stuff done.

[Jamie]: So, it’s like giving your language model a to-do list, a brain, and some manners?

[Alex]: Exactly. And maybe a helmet. [PAUSE] Here’s the wild part: a research group at MBZUAI recently looked at leaked Claude Code, and get this—over 98% of the code was harness infrastructure. Only about 1.6% was actual “AI decision logic.”

[Jamie]: Wait, so we’re all obsessed with the model, but the harness is doing most of the heavy lifting?

[Alex]: Spot on. The research basically says, “Hey, swapping out the model is easy—the real work, and most of the complexity, is in the harness.” That’s where permissions, context management, and all the governance lives. And it’s not just Microsoft—AWS and Databricks are on the same train, arguing that as models get interchangeable, the harness decides how good—or safe—your agent actually is.

[Jamie]: So when people say “the AI did it,” they should really be blaming the harness?

[Alex]: [Laughs] The harness is the unsung hero—or villain, depending how you set it up.

[Jamie]: OK, so what actually shipped with this Microsoft harness? Like, what’s new in the box?

[Alex]: Good question! So, out of the box, you get automatic function invocation—that’s the tool-calling loop. It can remember chat history, compact context so you don’t overflow memory, manage persistent to-do lists, save files, discover skills, even do web search. And telemetry is on by default—so you can trace every step your agent takes.

[Jamie]: That sounds pretty robust. But you know there has to be a “but” coming, right?

[Alex]: [PAUSE] Always a “but.” Four big features didn’t make the stable cut yet: background agents that delegate tasks to other agents, direct file access, auto-looping until a task’s complete, and running shell commands. Basically, everything that makes an agent truly autonomous—and a little scary—is on hold until Microsoft gets more feedback.

[Jamie]: Let me guess—the “don’t let your agent nuke your filesystem” clause?

[Alex]: Exactly! [Laughs] It’s the “let’s not accidentally wipe out production” safety net. Microsoft’s being cautious—those features are alpha, opt-in only, and they flash warnings when you enable them. The idea is to keep things safe and get more real-world feedback before unleashing true agent autonomy.

[Jamie]: OK, so let’s talk deployment. If I want to run my agent somewhere, what’s this “Foundry hosted agents” thing?

[Alex]: That’s the other half of the puzzle. Foundry lets you package your agent code as a container, and then Microsoft runs it for you on their infrastructure. Each session is isolated in its own sandbox with a persistent filesystem. So, your agent can go to sleep, wake up, and remember what it was doing—without running up a huge compute bill. It scales to zero when idle and wakes up when needed.

[Jamie]: So, like, cloud hibernation for agents? That’s pretty neat.

[Alex]: Pretty much. Sessions get their own virtual machine sandbox, and you only pay for what you use. The cool part is, it’s framework-agnostic. You don’t have to use Microsoft’s SDK—you can bring your own code, or use other agent frameworks like LangGraph, Semantic Kernel, or even your own homebrew setup.

[Jamie]: Let’s talk money for a second—because someone’s got to pay the cloud bill. How does billing work?

[Alex]: It’s all usage-based—per vCPU-hour and per GiB-hour, by region. If you oversize your agents, your bill multiplies by the number of concurrent sessions. But when your agent’s asleep, you’re not paying. [PAUSE]

[Jamie]: OK, now the nerdy question: What about tool integration? Can I just bolt on whatever tools I want?

[Alex]: Sort of. In Foundry, you can’t add tools directly to the agent definition—you have to provision them through a Toolbox endpoint. And you can’t do traffic splitting between versions yet—so it’s one version per endpoint.

[Jamie]: So, no A/B testing your agent’s sarcasm level just yet.

[Alex]: [Laughs] Not unless you spin up two endpoints and juggle the traffic yourself.

[Jamie]: Now, I heard something about coding-agent connectors being more about governance than just integrations. What’s that about?

[Alex]: Yeah, that’s a growing trend. Microsoft’s Agent Framework can plug into the GitHub Copilot SDK or the Claude Agent SDK, and they all follow the same rules for identity, safety, and observability. All the telemetry from these agents lands in the same dashboards, so you have one control panel for everything. AWS is doing something similar with Loom—they’re even stricter about runtime code generation, pushing config into pre-written harness code.

[Jamie]: So, the question isn’t “can my agent do this,” but “who’s allowed to run what, under which policies, and how do I keep an eye on it?”

[Alex]: Exactly. The harness is where the governance happens now. And the way you set up your harness decides how safe—or rogue—your agents can be.

[Jamie]: OK, last one. There was a benchmark floating around comparing Microsoft’s Agent Framework and GitHub Copilot SDK. What’s the story there?

[Alex]: Ah, yes—so Microsoft’s own architect ran both harnesses side by side. Same model, same tasks. They both got to the same answers, but here’s the kicker: Agent Framework stopped itself after 40 loops, while Copilot SDK just… kept going up to 300 before anyone stopped it. That’s a harness-level safety feature—it literally puts the brakes inside the loop, rather than relying on the host to hit “stop.”

[Jamie]: So, one agent’s got a built-in emergency brake, and the other’s like, “Wheee, infinite loops are fun!”

[Alex]: [Laughs] It’s the difference between a self-driving car that stops at red lights and one that just hopes you’re paying attention.

[Jamie]: [PAUSE] Well, that’s a wrap for this deep-dive into agent harnesses, runtime drama, and the unsung heroes behind the scenes.

[Alex]: Thanks for tuning into Nerd Level Tech AI Cast! If you liked this episode, drop us a review, share it with your AI-curious friends, or just shout “harness!” in your next team meeting and see who panics.

[Jamie]: We’ll be back next week with more nerdy goodness. Until then, keep your agents in check—and your harnesses tight! [Outro music fades out]