# Notes of the week: the harness spreads, agents after go-live and Kubernetes for agents

- URL: https://baeke.info/2026/11/16/notes-of-the-week-the-harness-spreads-agents-after-go-live-and-kubernetes-for-agents/
- Author: Geert Baeke
- Published: November 16, 2026
- Topics: ai, azure, kubernetes, foundry, agents, aks, mcp, a2a

This week's [Notes](https://baeke.info/notes/) keep coming back to the agent harness. Microsoft explains why it matters for trust, Copilot Studio agents can now call harness agents over MCP and A2A, and even document extraction gets its own agentic loop. The second thread is what happens after an agent goes live: evaluations that feed an optimizer, and durable state so a crash doesn't cost you the work or the tokens. On the Kubernetes side, the pieces to run agents and self-hosted models on AKS are taking shape, with some assembly still required.

These are the notes behind the post, newest first:

![The Notes page on baeke.info, with the newest note at the top: A2A with Copilot Studio and the Copilot harness](https://baeke.info/_astro/notes.BiMvNgNW_Z24ehs9.webp)

## The harness shows up everywhere

Last week the Microsoft Copilot harness arrived in Foundry Agent Service as a preview. This week's [Microsoft Mechanics episode with Jeff Hollan](https://www.youtube.com/watch?v=4vCbQMUVV-I) explains what it does and why you'd want it. A harness wraps the model with five parts: the agent loop, context management, skills and tools, subagents, and memory. The demo makes the case well. A prompt agent on the simple Responses API loop gives up on "forecast next quarter's spend and make me an executive PDF". The same agent definition on the Copilot harness plans, pulls data, loops, and comes back with a PDF and a forecast file.

A few other details from the episode:

- You can bring your own harness as a hosted agent. Jeff shows the same agent written with the Claude Agent SDK, and Hermes, OpenClaw and custom harnesses are supported too. Each session gets its own VM-isolated sandbox with zero idle cost.
- Hosted agents can use your own virtual network with no public egress, your own container registry, and more regions (North Central US, East US, Japan East, Southeast Asia, Sweden Central).
- Toolboxes put curated tools behind one MCP-compatible endpoint. Tool search only loads the tool descriptions a task needs, which Microsoft measured at more than 60% fewer tokens with 50 tools and more than 97% with 1,000.

⚠️ **Important:** Microsoft points out that the token savings come from tool search. A toolbox on its own doesn't give you them.

Harness agents also become something other agents call. The Copilot Studio team shows how to [call Microsoft Copilot harness agents over MCP and A2A](https://microsoft.github.io/mcscatblog/posts/call-ghcp-harness-agents-mcp-a2a/). A standard Copilot Studio agent adds the harness agent as an MCP tool (OAuth 2.0 with an Entra app registration and the `MCS.InvokeAsMCP` permission), and harness agents call each other over A2A through the target's agent card. Since the A2A channel only speaks A2A 1.0 and the standard agent's form expects the 0.x card, standard agents can't use A2A yet.

⚠️ **Important:** both channels are in preview, and the agent you call has to live in an Early release environment.

The same loop idea reaches document processing. [Agentic mode in Azure Content Understanding](https://devblogs.microsoft.com/foundry/when-one-pass-isnt-enough-agentic-mode-in-azure-content-understanding/) (preview) wraps the model in a "document-native harness" with tools to navigate text and tables, inspect visuals, calculate and validate. You still define a schema and get fields back. The examples are the kind of thing a single pass gets wrong: a table that spans two pages of a 137-page bulletin, or a log table across 19 pages where the agent counts the actual rows instead of trusting event IDs with gaps. You switch it on with `"workflow": "agentic"` in the analyzer config (API version `2026-06-01-preview`). It uses more tokens and takes longer, and Microsoft's advice is to start with standard mode and compare both on your own files.

The harness is turning into the default unit for agents on Microsoft's platform. If you build agents on Azure, the question becomes which harness you pick and what you put in it, like your skills and a toolbox, with network and identity rules around it.

## What happens after go-live

Both the Mechanics episode and a Foundry blog post spend time on what happens after you deploy. The post on [closed-loop evaluations in Microsoft Foundry](https://techcommunity.microsoft.com/blog/azure-ai-foundry-blog/improve-production-agents-with-closed-loop-evaluations-in-microsoft-foundry/4569762) describes a scheduled loop:

- turn live traces into reviewed datasets
- let Agent Optimizer (`azd ai agent optimize`) generate and rank candidate configurations, with model choice limited to an approved list
- promote a winner only after gated evaluations in CI/CD and canary traffic at 5%, then 25%

Release criteria live outside the configuration the optimizer can change, and a held-out regression suite keeps it from overfitting. The worked example is a refund agent, with custom code evaluators that catch repeated write calls and claims about a status the agent never checked. In the episode, Jeff runs the optimizer against a private benchmark built from real tasks, and every evaluation result links back to its trace.

⚠️ **Important:** Agent Optimizer is in preview, and the numbers in the blog post are illustrative.

Keeping an agent running counts as much as making it better. The [Durable Task extension for Microsoft Agent Framework](https://techcommunity.microsoft.com/blog/appsonazureblog/durable-task-extension-for-microsoft-agent-framework-is-now-generally-available/4571100) is now GA, for .NET and Python. Durable agents keep session state outside the worker, so another worker can continue a conversation. Durable workflows run agent calls, activities and external events as orchestrations, and Agent Framework graph workflows run that way too. You host it on Azure Functions or yourself, with Durable Task Scheduler as the recommended backend and its dashboard showing sessions, token usage and timelines.

I like two things here. Completed agent calls aren't re-run during replay, so recovery doesn't pay for the same inference twice. And a human-in-the-loop wait (24 hours in the example) doesn't need a running worker. Last week's Foundry resilience feature restarts work from the original input and leaves the bookkeeping to you; with durable agents the framework does that bookkeeping.

⚠️ **Important:** saving the session reference is your job. The post says it plainly: serialization alone does not save it.

## Kubernetes as an agent platform, some assembly required

[Agent Substrate v1.0.0](https://www.cloudnativedeepdive.com/agent-substrate-v1-0-0-on-aks-installation-and-configuration/) was released on November 5. It runs agents as Actors on Workers, with gVisor sandboxes and snapshots for suspend and resume. Version 1.0 brings rolling upgrades, the `ate.dev/v1` API, an install from published images, and a router that only admits SPIFFE IDs you list. Michael Levan's write-up shows it on AKS, and that takes work: the setup tool assumes GKE or Kind, so he applies a patch, uses an ACR attached to the cluster and stores snapshots in an in-cluster S3-compatible store. A provider interface for the setup tool is planned for v1.1.

The [Azure Blob Storage plugin for Agent Substrate](https://github.com/agent-substrate-plugins/objectstore-azure-blob) fills one of those gaps by storing snapshots in Blob Storage, with a SHA-256 check on every file. It authenticates with Entra workload identity only, so you never hand it account keys or SAS tokens, and it doesn't fall back to the node's managed identity, which I like.

⚠️ **Important:** the plugin has no releases yet and needs the `substrate.objectstore.v1` API from Substrate's main branch, which no release included as of October 28. Its README also says any caller can read or write every snapshot in the configured containers.

For the models themselves, Application Gateway for Containers got an [inference gateway](https://learn.microsoft.com/en-us/azure/application-gateway/for-containers/inference-gateway) (preview) for models you host on Kubernetes. It implements the Gateway API Inference Extension: an `HTTPRoute` points to an `InferencePool`, a managed processor reads the `model` field from the OpenAI-compatible request body, and an endpoint picker you provide (the llm-d router is the full-featured one) chooses a pod based on load and prefix cache. You also get weighted rollouts across pools, model rewrites such as a 90/10 split between two LoRA adapters, priority bands, and WAF in front of your GPUs.

⚠️ **Important:** it only routes to self-hosted models on Kubernetes, and JWT validation with `AuthPolicy` isn't supported on `InferencePool` routes yet.

If you'd rather run sandboxed agents and model routing on your own cluster than use Foundry, these projects build that on open standards. It's early, and on AKS you still glue some parts together yourself 🤷

## Wrapping up

The harness is becoming the thing you build an agent on, and your own work moves to what surrounds it in production: evaluations that feed an optimizer, and state that survives a crash. If you spot any errors or have questions, feel free to reach out!
