Microsoft Agent Framework (MAF) shipped python-1.11.0 on July 10, 2026, and buried in a broad release note is the feature the framework has been missing for anyone running agents that live longer than a single request: you can now nudge a running agent mid-turn.
We've covered MAF's progressive MCP disclosure — the discover / load / unload story for keeping your tool budget lean — and that landed here too (PR #6850). But the fresh, load-bearing addition in 1.11 is message-injection middleware, and it changes how you build the long-running agents that used to be awkward.
What message injection actually does#
Before 1.11, an agent turn was a closed box. Once a run started, your options for reacting to something new — a user correction, a webhook firing, a background job finishing — were to interrupt the run or wait for the turn to end and feed the new information into the next one.
Message-injection middleware (PR #6998) opens the box. A tool, or the host application, can enqueue a message into an active run; the framework drains it into the next model call within the same AgentSession. It's not an interrupt into the middle of an inference — it's a queue the agent checks on its next step. That's the right design: the agent stays coherent, and your external event lands on the very next turn instead of after the whole run.
The turn used to be a wall. Now it has a mail slot.
Crucially, PR #7027 wires this into create_harness_agent and the harness console sample specifically — so a running harness agent can be nudged mid-run, which is exactly the shape supervisors and human-in-the-loop flows need.
Where you'll use it#
The pattern this unlocks:
- Human-in-the-loop steering. A reviewer watching a long agent run drops "prioritize the refund path" into the queue; the agent picks it up next step instead of finishing the wrong plan first.
- Event-driven correction. A background job or webhook resolves while the agent works — inject "ticket #4471 just closed" and the agent's next model call sees it.
- Supervisor → worker nudges. An orchestrating agent adjusts a running sub-agent without cancelling and restarting it.
All three were possible before only with clumsy interrupt-and-restart. Now they're a message on a queue.
Skills left experimental#
The other real news: the Skills API graduated out of experimental — "Agent Skills for Python is now released." Two additions make that graduation concrete:
CachingSkillsSourcegained arefresh_interval(TTL) (PR #6977), so a cached skill list expires and re-fetches on a schedule instead of quietly going stale. If your skills come from a remote source that changes, this is the difference between "eventually correct" and "correct."SkillsSourceContext— the invoking agent plus an optional session — is now threaded through the skills pipeline (PR #6895), enabling context-aware filtering and per-key cache isolation. Different agents (or sessions) can see different skill sets and cache them independently.
One caution: the release flags experimental breaking changes on the caching path — caching was refactored into a CachingSkillsSource decorator. If you were on the older experimental caching shape, read the release notes before you bump the version. Everything now promoted to stable is safe to build on.
The read for builders#
Take 1.11 as the release where MAF's three long-standing stories — sessions, skills, and tool budget — all reach production-dependable. Progressive MCP disclosure keeps your context lean, the Skills API is no longer experimental, and message injection finally lets you steer a run without stopping it.
If you're evaluating agent frameworks and you'd deferred MAF because Skills was experimental or because long-running control felt bolted-on, both objections just got answered. The exact signatures live on the python-1.11.0 release page and the linked PRs — start with #6998 and #7027 for injection, #6977 and #6895 for skills.
