[MS] What's new in Microsoft Foundry | September 2026 - devamazonaws.blogspot.com

September's updates help you run agents on a schedule, load tool definitions on demand, and investigate behavior from traces. Routines and Tool Search are now GA; Insights enters public preview, and Model Router gains preview controls. We also expanded the GPT-6 lineup and introduced GPT-6.1 Sol.

Jump to Foundry Models, Agents & Foundry Agent Service, Speech & Content Understanding, Foundry Local, developer tools, APIs, SDKs, and CLI, pricing and model retirements, or resources and community.

TL;DR

• GPT-6 Astra, GPT-6.1 Sol, and GPT-6 Luna are generally available (GA). Compare quality and cost per task using a supported serving option.
• Routines are GA. Run agents on a timer, schedule, or supported GitHub or Teams event. The agent-scheduled reminder tool remains preview.
• Tool Search and Agent-to-Agent (A2A) are GA. Hosted-agent Toolboxes remain GA; prompt-agent Toolboxes enter public preview.
• Voice agents and long-running hosted-agent resilience enter public preview. Try spoken interactions or recoverable background tasks.
• Insights enters public preview. Investigate trace-backed findings before changing your agent.
• Model Router adds preview session affinity and routing metadata. Inspect model selection across turns.
• Foundry Local 2.1 adds bring-your-own-model support. Register compatible ONNX Runtime GenAI models without copying files. Content Understanding adds preview tooling.
• Developer tools get more practical. Dev Pack launches an installer; Foundry Toolkit adds templates, skill-only Toolboxes, and controls for unfinished Responses work.

See what's new in Foundry and how to put it to work. The Handoff is my weekly live show with Foundry updates, demos, and Q&A with special guests. Join us on Discord or watch live on YouTube, X.com, or LinkedIn.

Join The Handoff

Foundry Models

GPT-6 and GPT-6.1 Sol are generally available (GA)

We expanded the GPT lineup throughout September:

Feature / offering	GPT-6 Astra	GPT-6.1 Sol*	GPT-6 Luna
Description	Most capable model for the most demanding work.	Near-Astra performance for complex work at a lower cost.	Most efficient model for focused, high-volume tasks.
Released	September 3	September 29	September 22
Global Standard	All (28)	All (28)	All (28)
Global Provisioned	All (28)	All (28)	n/a
Data Zone Standard	US (7)	US, Europe and APAC (21)	US and Europe (16)
Data Zone Provisioned	US (7)	US (7)	n/a
Flex processing	All (28), Global Standard	All (28), Global Standard	All (28), Global Standard
Priority Processing	n/a	n/a	n/a
Input / 1M tokens	$10.00	$2.00	$0.10
Output / 1M tokens	$50.00	$10.00	$0.50
Cached input / 1M tokens	$1.00	$0.10	$0.01

Prices are September-announced USD rates per 1M tokens for Global Standard short-context requests. Long-context rates are higher. Check current pricing.

*The GPT-6.1 Sol launch reports better coding, computer use, and professional work than GPT-6 Sol at the same uncached-input and output prices, with 50% lower cached-input pricing.

All three models in the GPT-6 model family have a 1.05M-token context window and up to 128K output tokens, including reasoning, within one shared budget. They support Responses, Chat Completions, streaming, function calling, structured outputs, and image input with text output. Knowledge cutoffs: April 2026 for Astra and GPT-6.1 Sol; May 2026 for Luna. GPT-6.1 Sol tool calls require Responses. Model specifications.

Compare Models in Foundry

More model announcements

September also brought Claude and MAI announcements. Check each model's API and availability boundaries before choosing a deployment:

Announcement	Model	Availability note	A useful first task
September 24	Claude Opus 5.5	Foundry availability announced; check the hosting option and API before deployment	Compare one difficult coding or reasoning task using the Claude API path.
September 4	MAI-Image-2.6 and MAI-Image-2.6-Flash	Public preview; this is the September Foundry developer-availability announcement, not the older model-version date	Try multi-reference editing with synthetic product images.
September 3	MAI-Transcribe-2	Foundry demo availability confirmed; the launch doesn't specify a universal API/deployment GA transition	Use a fixed audio clip to inspect diarization, word timestamps, and terminology handling.

For Claude, choose between the Azure-hosted and Anthropic-hosted options, then follow the deployment and API guide below. Don't assume OpenAI client parameters transfer unchanged.

For the MAI models, choose the image or transcription guide below. Keep your test input fixed while you compare the result.

Try MAI Transcription

Model Router: session affinity and routing metadata (preview)

September adds two controls for applications that use Model Router: session affinity for related Chat Completions requests, and request-level metadata for routing attempts and fallback. Model router expands to 32 regions, adding Canada Central, North Europe, Norway East, and UAE North. North Europe and Norway East support Global and Data Zone Standard; Canada Central and UAE North add Global Standard.

Session affinity asks Model Router to prefer the same eligible model across related requests. That can help with prompt-cache reuse, but neither a cache hit nor the same model is guaranteed. Safety, capability, quota, availability, and fallback requirements still apply.

Both hosted agents in the developer changelog workflow example below use a router deployment for inference. That is separate from their frameworks and external protocols. A deployment name in a usage field doesn't identify the underlying model or prove affinity.

Reuse a session ID across related Chat Completions turns and inspect the returned routing metadata. A switch can be legitimate fallback. Keep unrelated reviews on separate IDs and compare results before changing routing policy.

Inspect Model Router Decisions

Agents & Foundry Agent Service

A Foundry developer changelog with two hosted agents

For this example, I'm using the GitHub Copilot SDK and Microsoft Agent Framework in one workflow: collect public Foundry changes, turn them into source-backed developer release notes, and deliver them for review.

Configured workflow: the routine starts the producer; the receiver retrieves the checked report through Invocations and delivers it through native Activity. Model Router supplies inference, not orchestration.

Hosted agent	Framework	Responsibility
depend-agent	GitHub Copilot SDK	Collect scoped public changes, retain the evidence and coverage gaps, and propose optional demos.
maf-update-agent	Microsoft Agent Framework	Adopt the saved report, compose developer release notes, and deliver one card to an approved destination.

I want the changelog ready before I start planning the next edition. Routines, now GA, lets a Monday schedule start the research without my laptop. Tool Search, also GA, loads GitHub tool definitions on demand rather than all upfront, leaving more context for release evidence and potentially reducing input-token costs.

Then there's the feedback loop. Insights (public preview) helps surface recurring issues in the agent's traces, such as repeated retrieval or lost context. I can inspect the supporting evidence and recommended next steps before changing the workflow.

Choose the external protocol for the caller's contract, not the framework. A hosted agent can expose more than one:

Decision	Responses	Invocations	Activity
Reach for it when	You want an OpenAI-compatible conversational agent, tool interactions, or background responses.	You need a custom job/report API, webhook payload, or application-controlled HTTP stream.	You need Teams or Microsoft 365 messages, events, and interactive card actions.
Caller contract	Standard Responses input, response items, and streaming events; use an OpenAI-compatible client.	You define request and response bodies: JSON, text, or SSE. Publish the schema for your callers.	Activity messages and invoke events handled through the channel SDK and adapter.
State and async work	Foundry manages conversation history and background polling. Resilient recovery requires separate configuration.	You own history and job operations. Use durable storage and SDK resilient tasks when needed.	Channel conversation references and message IDs; configure proactive delivery separately.
In this workflow	No external Responses endpoint. The Copilot harness uses Responses internally for inference.	The producer's start/status/result API and checked-report handoff to the receiver.	The receiver's native channel messages and Adaptive Card actions.

I chose Invocations for the app-owned job and report contract, not merely because the output is JSON. The receiver owns its copy and delivery record rather than assuming access to the producer's private storage. It adds the native Activity protocol for Teams. Model inference is separate: the Copilot harness uses Responses internally, while the editorial receiver uses Chat Completions.

Responses-based agents can also use Foundry's Activity bridge when published to Microsoft 365. Here, native Activity lets the receiver handle channel events and card actions directly. See the protocol selection guide.

The output is the weekly brief; the traces show how it was produced. The Insights review below offers a second view of the workflow, pointing to behavior worth investigating before the next run.

A source-backed upgrade notice from a changelog, consumed in Microsoft Teams.

With the Foundry Dev Pack installed, follow the Microsoft Foundry skill setup guide, then give your coding agent this prompt. Start with one public repository and one reporting week:

Use the microsoft-foundry skill to create a Foundry developer changelog
with two hosted agents.
Use the GitHub Copilot SDK for source collection, with Foundry Toolbox
Tool Search to discover scoped, read-only GitHub operations.
Use Microsoft Agent Framework for source-backed editorial composition
and native Activity delivery to Teams.
Reuse an existing Foundry project and Model Router deployment for both agents.
Start with one approved public repository and one reporting week.
Keep published releases, merged changes, and developing work separate.
Prepare a weekly Foundry Routine to start the collector; keep it disabled.
Hand off the checked report through authenticated Invocations.
For each note, explain the developer consequence, preserve material warnings,
and link to the primary source. Keep the full evidence ledger and coverage gaps.
Use a fixed, approved Teams destination; the model cannot select recipients.
Add tracing with content capture off by default and keep secrets out of telemetry.
Prepare an on-demand Insights (public preview) review of saved agent traces
to propose improvements; do not apply fixes automatically.
Ask before deploying, enabling schedules or trace content capture, sending
messages, or running billable Insights scans.
Do not execute samples or publish the report.

Review one resulting note against its source before adding another repository. The useful first milestone is a change you can act on and trace back, not a large receipt count.

[alert type="note" heading="Incurring costs"]Source collection and authoring call cloud tools and models. Hosted runs also use active compute; tracing and Insights can add monitoring or judge-model costs. See model pricing and the Hosted Agents billing explanation.[/alert]

Explore the GitHub Copilot SDK

Tool Search is generally available (GA)

We announced Tool Search GA on September 24. Instead of putting every tool definition in each model request, a Toolbox exposes discovery and invocation through tool_search and call_tool. Hosted-agent Toolboxes were already GA; the prompt-agent expansion is public preview.

For the changelog agent, the next operation depends on the evidence. A merged PR needs its changed files. A developing branch needs a head commit. A proposed demo needs the actual sample and a release or preview source. Those are different reads, not interchangeable search results.

The demonstration's Toolbox exposes seven GitHub read operations. Application code restricts them further to approved repositories, paths, and PR-read methods. Tool discovery is not permission to write a comment or run sample code.

The observable sequence is discovery, a scoped source read, and a note linked to the returned evidence. A missing required tool fails explicitly rather than producing an empty changelog.

Try this with an agent that already uses several read tools. Configure Tool Search, then trace one note back to its release, PR, or sample. Inspect which definitions the agent loaded and why. This demonstration proves discovery; it doesn't measure token savings.

Configure Tool Search

Routines are generally available (GA)

We announced Routines GA on September 24. A routine starts one agent from one trigger: a timer, recurring schedule, GitHub issue event, or supported Teams channel event. Its configuration, identity, and run history stay with the Foundry project.

That is useful automation without a separate scheduler. It is also a specific boundary: Routines don't replace multi-agent orchestration or approval workflows. The agent-scheduled reminder tool is still preview, even though Routines is GA.

Start the changelog, then review its delivery

The changelog is most useful to me when it arrives before I start planning the month's examples. Its routine is configured for Monday 09:00 in America/Los_Angeles; change that for your own review habit.

A routine starts the work. It does not automatically put the result in Teams. This workflow separates durable job acceptance, a completed source-checked report, and a private delivery receipt. Its code-owned adapter sends only to a fixed, approved destination; the model never chooses a recipient.

The routine sends a structured start request. The application persists the job before accepting it, then exposes status and result operations. An accepted request is not a finished report, and a finished report is not a delivered message.

For Teams delivery, maf-update-agent uses the native Activity protocol. After the personal app is installed and its conversation registered, it adopts the checked report through Invocations and sends one Adaptive Card to that fixed destination. The Teams proactive messaging guide covers the conversation requirements.

The card puts new capabilities, improvements, fixes, and upgrade notices ahead of the full source ledger. Category buttons open complete saved pages; they don't start another collection or model call. Wrapping and a full-width layout keep the note and its source link together. Reports and source baselines have a 90-day lifecycle.

The October 13 demonstration confirmed delivery of the saved report and navigation within that same card. The producer adopted the receiver's real message receipt without sending again. A lost acknowledgment stays uncertain for review; the application doesn't blindly replay it.

The Monday schedule is now enabled. The completed demonstration used a manual routine dispatch, so it isn't proof of a calendar-triggered Monday run. For your own workflow, begin with a manual no-send run, review its sources, approve the destination, and enable the schedule only after the delivery path works. That's the difference between an agent that can generate a report and a workflow you can rely on for review.

Create a Routine

Insights in Foundry (public preview)

We introduced Insights in public preview on September 24. It helps answer a practical question once an agent is running: what should I improve next? Insights groups recurring trace behavior into findings with supporting evidence, likely causes, and proposed next steps.

Recorded behavior, reviewable findings, and a human-controlled improvement loop.

In the saved collection traces, Insights flagged:

• Context: sample-heavy prompts after a batch was already ruled out for demo proposals.
• Retries: large prompts resubmitted after rate-limit errors.
• Delivery: an earlier unconfirmed receipt on a path that has since recovered.

Cropped excerpts of an Insights finding and its proposed fix. The chart and trace table are omitted.

Start with one finding, inspect its linked trace, and test the proposed change against the same input before applying it.

Investigate Agent Traces with Insights

More agent updates from September 24

Our September platform announcement also changes how agents connect, interact, and recover:

Update	September status	What to try
Toolboxes for prompt agents	Public preview	Reuse a curated Toolbox with a prompt agent rather than rebuilding its tool configuration.
Tool search and A2A	GA	Check the discovery and delegation paths in an agent that already has several tools or specialist agents.
Voice agents in Foundry Agent Service	Public preview	Test a spoken interaction using an agent's existing tools and knowledge. Check interruptions and corrected identifiers, not just whether it speaks.
Long-running hosted-agent resilience	Public preview	Start a read-only background report, disconnect the client, and verify that you can recover the result.
Insights in Foundry	Public preview	Inspect a trace-backed issue, its likely cause, and the proposed fix before changing the agent.
Entra and Agent 365 lifecycle operations	Availability confirmed by September 24; no separate maturity label in the announcement	Verify that approved lifecycle changes to a non-production agent affect its runtime, not just its directory record.

The voice-agent preview is distinct from the Hosted Agents with Voice Live integration covered in the July and August edition. Keep those maturity labels separate.

Long-running resilience requires the documented background-response and server configuration. Application checkpointing and idempotency still matter: reconnecting a conversation doesn't make repeated external actions safe.

The same September announcement targeted rubric evaluation, synthetic and trace-derived dataset generation, and Agent Optimizer GA for "later this month." That is a target, not a completed-release receipt. The Python Projects changelog records related GA API surfaces in 2.8.0 on October 2; it doesn't establish September service GA. These remain September-announced targets in this roundup.

The announcement also introduces the open-source run-assert-eval skill, which connects risk discovery, policy-based evaluation, and targeted controls. Keep the test inputs and judge configuration fixed when you compare changes. A higher quality score is not proof that every risk is covered.

Configure Long-Running Resilience

Speech & Content Understanding

Content Understanding Toolkit and CU CLI (preview)

The September Content Understanding changelog adds a preview toolkit, CU CLI, and analyzer schema references. Use them to analyze local files and create, test, and manage analyzers without turning every experiment into a portal workflow.

Start with one synthetic document and a small field schema, then inspect the extraction before connecting it to a business process. The CLI guide below covers setup and supported API versions. File analysis and resource provisioning can incur charges; a CLI preview doesn't change the maturity of the underlying API you select.

Try the Content Understanding CLI

Speech LLM 2607

The September 10 Speech announcement improves multilingual and mixed-language recognition and adds a phraseList field for domain terminology. The update rolls out on the service side, so it doesn't require a customer-managed model replacement.

Try fast transcription with a short clip and known terminology. Compare the transcript with and without your phrase list. The announcement doesn't give a rollout-completion date or a separate GA label; don't read 2607 as the launch date or assume every capability applies identically to realtime and file transcription.

Try Fast Transcription

Speech SDK 1.52

The September Speech SDK release notes add preview commit support for PushAudioInputStream and support for selecting a streaming transcription model. The JavaScript release also fixes reconnect audio offsets and missing channel information in conversation transcription. If your application streams audio or reconnects mid-conversation, test that path before upgrading.

Review Speech SDK 1.52

Foundry Local

Foundry Local 2.1

The Foundry Local 2.1.0 release, published September 30 UTC, lets you register compatible ONNX Runtime GenAI models without copying or transferring their files. Bring-your-own-model support spans C++, C#, Python, JavaScript/TypeScript, and Rust. The release also adds custom text tools and improves cancellation, token accounting, and model-browser accessibility.

If you already have a compatible model on disk, try it with the Foundry Local samples on the hardware you plan to support. Check runtime and model-packaging compatibility first; this isn't a promise that every model format runs unchanged.

For applications moving through the 2.x SDK, review the 2.0.1 migration notes too. In-process OpenAI-style clients are deprecated in favor of typed chat, embedding, and audio sessions; the OpenAI-compatible HTTP contracts remain supported. That near-boundary release is migration context, not a fresh September headline.

Try Foundry Local Samples

Foundry Local on Azure Local: extension 2609 (preview)

The Azure Local extension is a separate surface from the desktop SDK. Its September 2609 update enables Kubernetes service account token authentication by default for in-cluster inference. It uses short-lived, audience-bound tokens and Kubernetes RBAC; this change doesn't cover control-plane requests.

Before upgrading, check the service account token setup, including the extension managed identity's Reader requirement at the Arc-enabled cluster scope.

Configure Service Account Authentication

Developer tools, APIs, SDKs, and CLI

Dev Pack and Foundry Toolkit

The September 15 Dev Pack announcement packages Foundry environment setup into an installer. Follow its installation guide for the current bundle and supported platforms.

Foundry Toolkit's dated September changelog records four releases:

Release	Changes worth trying
1.6.11, September 2	Hosted-agent validation support and Inspector event search/export
1.6.12, September 9	Opt-in remote images, Windows profiling, and connection/replay diagnostics
1.6.13, September 16	Private non-ACR registry deployment UI, Fara AMD NPU support, and adapter/WinML tooling updates
1.6.14, September 23	Solution templates, skill-only Toolboxes, steer/stop controls for active Responses work, and reconnection to unfinished background responses

If setup is the blocker, start with Dev Pack. If you already work in VS Code, try a solution template and inspect one agent response before changing your production workflow.

Get Foundry Dev Pack

Agent Framework memory and interactive experiences

The September 4 Cosmos DB memory integration adds a Python preview context provider for background extraction and cross-session recall. Use authenticated user scoping when you adapt it; don't turn a user ID supplied in a prompt into an authorization decision.

The September Agent Framework roundup also documents stable AG-UI support in Python, with .NET support still preview. Choose the language-specific path rather than assigning one maturity label to the whole framework.

The month's core artifacts are Python 1.17.0, 1.18.0, and 1.19.0, plus .NET 1.21.0 and 1.22.0. They add vector-store integrations, checkpoint-restoration controls, and per-tool execution controls alongside fixes. Some connectors and hosting integrations remain alpha or preview; a stable core artifact doesn't promote them all to GA.

Explore Agent Framework Updates

Foundry SDK releases: check the migration, not just the version

These are September releases, not the newer versions shown by an October setup guide:

Language	September packages	Changes worth checking before upgrading
Python	azure-ai-projects 2.6.0 (September 4), 2.6.1 (September 14), 2.7.0 (September 18)	Insights and routine dispatch identity; polling fixes; preview Voice APIs, prompt harness/skills, and toolbox metadata. Review beta constructor and sample-limit changes.
JavaScript/TypeScript	@azure/ai-projects 2.6.0 (September 3), 2.7.0 (September 18), 2.7.1 (September 23)	Insights and preview Voice APIs; beta.voiceAgents operation moves; browser bundling fixes in 2.7.1.
.NET	Azure.AI.Projects 3.0.0-beta.2 (September 3), beta.3 (September 16), with matching Projects.Agents changes	Insights and realtime-session startup; preview telephony/conversation clients. This package line remains beta.
Java	azure-ai-projects 2.5.0 (September 9), 2.6.0 (September 22), 2.6.1 (September 23); azure-ai-agents 2.6.0 (September 22)	Insights, routine authorization, tracing/output controls, preview Voice clients, and serialization fixes. Check required authorization arguments and preview opt-in.

The Python evaluation patches run from 1.18.5 through 1.18.7 this month. If you upgrade to 1.18.7, remove aoai_output_items_page_size; the release removes that option.

Hosted-agent developers should also review the runtime packages: AgentServer Core 2.2.0, Responses 2.2.0 plus the 2.3.0 beta line, and Invocations 1.2.0. Check session isolation, graceful shutdown, persistence, and trace export behavior. Core's default Azure Monitor trace sampling is 100%, so review trace volume and cost before rollout.

For retrieval code, Azure.Search.Documents 12.1.0-beta.3, released September 14, changes the streamed-retrieve protocol overload to AsyncStreamingResult<SseItem<BinaryData>> and restores indexer create/update parameters. Treat this as an SDK migration, not a new September Foundry IQ service launch.

Review Python SDK Changes

Review JavaScript/TypeScript SDK Changes

Review .NET SDK Changes

Review Java SDK Changes

Azure Developer CLI and Foundry extensions

The September azd recap covers core versions 1.33.0 through 1.34.2, including extension lifecycle, deployment layers, concurrency, external authentication, and build diagnostics.

The Foundry extensions continue on beta release lines. Two changes deserve a check if you used the summer CLI recipes:

• In azure.ai.agents beta.18, dated September 30, runtime definitions must live directly in azure.yaml or through an explicit root $ref. Legacy AgentManifest/config discovery is rejected, and the extension requires azd 1.34.2 or later. Long-running invocation also moves to --long-running and the invocations command group.
• September connections and toolboxes releases remove standalone deploy commands in favor of azd deploy <service>. Check local service definitions before changing your deployment automation.

The projects, routines, skills, and Inspector updates improve local composition, identity handling, reconciliation, and run diagnostics. Review the installation and versioning guide below instead of assuming every beta version uses the same command shape.

New preview evaluations and dataset extensions also arrive this month. They add declarative evaluation workflows, versioned datasets, and CI failure thresholds. Evaluation initialization is local; generation and execution call cloud services.

Install Foundry CLI Extensions

Pricing & Model Retirements

The deployment pricing policy effective September 1 was announced in July. Its Standard premiums apply only to models launched on or after September 1; staying on an existing Standard model doesn't trigger that increase. Affected EU Data Zone and non-US Regional PTU customers have a different rule: the increases apply to existing customers too. Global pricing remains unchanged by this policy.

APAC Data Zone becomes available under that policy. Before comparing deployments, check the current rates for your model, deployment geography, and reservation terms. A relative premium is not a complete price quote.

The retirement schedule also lists two September deadlines:

Scheduled date	Deployment version to check	Next action
September 15	MAI-Transcribe-1, version 2026-01-23	Inventory deployments and evaluate the listed replacement, MAI-Transcribe-1.5.
September 24	gpt-chat-latest, snapshot 2026-06-24	Check pinned versions; the deadline isn't a retirement of every later snapshot or the entire rolling alias.

These are scheduled lifecycle dates, not a claim that a shutdown was observed. Use the retirement policy when planning a migration.

Compare Model Pricing

Resources & Community

The Handoff is my weekly live show for keeping up with Foundry and seeing what you can build with it. We cover what's new, walk through practical demos, and host Q&A with special guests.

Bring your own implementation questions, or use the demos to explore a different approach for your AI app, agent, model, or workflow. If you share an example, keep credentials and private data out of it.

Join The Handoff

Choose the Monday showtime that works for you: 8:00 AM or 4:30 PM Pacific Time.

Monday Show: 8:00 AM Pacific

Monday Show: 4:30 PM Pacific

I also livestream the show on YouTube, X.com, and LinkedIn, so you can watch on your preferred platform. Start with the YouTube broadcast, X.com list, or LinkedIn event. Discord remains the main room for live questions and follow-up.

Discuss on GitHub

Subscribe via RSS

Post Updated on October 16, 2026 at 03:04AM
Thanks for reading
from devamazonaws.blogspot.com