MAI Image 2.6 Lands in Foundry for C# Developers

Taswar Bhatti September 8, 2026 No Comments

Every time a new image model ships, I ask the same unglamorous question: can I actually put this in a pipeline, or is it just good at one pretty hero shot? Most image models nail the demo and fall apart the moment you need the fiftieth consistent variant of the same product, or a single surgical edit that doesn’t quietly redraw everything else in the frame.

Microsoft AI just shipped two models that answer that question directly: MAI-Image-2.6 and MAI-Image-2.6-Flash, both now in public preview in Microsoft Foundry. They’re not “one model, two names” — they’re a genuine two-tier portfolio: one for maximum quality, one for maximum throughput, sharing the same capabilities underneath.

As always: no Python, no notebooks. Just C#, HttpClient, and a dotnet run.

What Actually Shipped

A few facts worth knowing before you touch any code:

MAI-Image-2.6 is independently verified as frontier-tier. No. 2 on the Arena text-to-image leaderboard at launch, ahead of Google’s Nano Banana family and Meta’s Muse Image. No. 3 on Arena’s image-editing leaderboard, and No. 1 for image editing on Artificial Analysis. This isn’t a marketing claim you have to take on faith — it’s ranked against the models you’re probably already comparing against.
Multi-reference editing. MAI-Image-2.6 accepts up to five reference images in a single request. Lock a product, a character, or a brand mark, and it stays consistent as you revise, resize, and reformat it. One approved concept travels across channel formats without drifting.
Web grounding. The model can pull real-world context from Bing Search instead of relying only on training data — meaningfully better accuracy for real places, objects, events, and subjects.
Explicit control over format and resolution. Adaptive aspect ratios, 1.5K output resolution, and levers over how much the model deliberates before generating — so the same model family serves both a fast iteration loop and a final production render.
MAI-Image-2.6-Flash is the throughput tier. More than 2x faster than GPT-Image-2-Medium and roughly 72–78% more efficient than GPT-Image-2, depending on the metric. Built for interactive apps, automated pipelines, and personalization at volume.
Pricing. MAI-Image-2.6 starts at $5/1M text input tokens, $8/1M image input tokens, $38/1M image output tokens. MAI-Image-2.6-Flash starts at $1.75/1M text input, $2.50/1M image input, $19/1M image output — genuinely cheap enough to generate per-user variants without flinching.
Enterprise-ready by default. Delivered as a Foundry Model sold directly by Azure — Entra ID auth, RBAC, key-based access, Azure data-handling commitments. Prompts and outputs are not used to train the models.

Choosing Between Them

This isn’t “pick the cheap one or the good one.” It’s a real division of labor:

MAI-Image-2.6 — final campaign assets, complex multi-reference edits, high-fidelity text rendering, anything where precision is the point
MAI-Image-2.6-Flash — rapid iteration, interactive experiences, personalization, high-volume generation, anything where throughput is the point

The intended workflow: explore and iterate with Flash, then render the final asset with MAI-Image-2.6 once the direction is locked. You’ll see exactly that pattern in the code below.

Prerequisites

dotnet new console -n MaiImage26FoundryDemo
cd MaiImage26FoundryDemo
dotnet add package Azure.Core
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet user-secrets init
dotnet user-secrets set "AZURE_AI_FOUNDRY_ENDPOINT" "https://YOUR-RESOURCE.services.ai.azure.com"

dotnet new console -n MaiImage26FoundryDemo

cd MaiImage26FoundryDemo

dotnet add package Azure.Core

dotnet add package Azure.Identity

dotnet add package Microsoft.Extensions.Configuration.UserSecrets

dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables

dotnet user-secrets init

dotnet user-secrets set "AZURE_AI_FOUNDRY_ENDPOINT" "https://YOUR-RESOURCE.services.ai.azure.com"

Deploy both MAI-Image-2.6 and MAI-Image-2.6-Flash from the Foundry Model Catalog to your project — same process as any other model.

📝 Note: MAI-Image models aren’t compatible with the Azure.AI.OpenAI SDK’s ImageClient — they require the raw REST call against Foundry’s images endpoint, same as MAI-Image-2.5. The exact API surface is still settling in public preview, so confirm request/response shapes against the Foundry Model Catalog before shipping anything to production.

Here’s a small shared helper both examples below build on — auth token + a reusable POST helper:

using Azure.Core;
using Azure.Identity;
using Microsoft.Extensions.Configuration;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();

var endpoint = config["AZURE_AI_FOUNDRY_ENDPOINT"]
    ?? throw new InvalidOperationException(
        "AZURE_AI_FOUNDRY_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_FOUNDRY_ENDPOINT\" \"&lt;your-endpoint&gt;\"");

var credential = new DefaultAzureCredential();
AccessToken token = await credential.GetTokenAsync(
    new TokenRequestContext(new[] { "https://cognitiveservices.azure.com/.default" }));

using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);

async Task<byte[]> GenerateImageAsync(string model, string prompt, int width = 1024, int height = 1024)
{
    string url = $"{endpoint.TrimEnd('/')}/mai/v1/images/generations?api-version=preview";

    var payload = new
    {
        prompt,
        model,
        width,
        height,
        output_compression = 100,
        output_format = "png",
        n = 1
    };

    using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
    using HttpResponseMessage response = await http.PostAsync(url, content);
    string body = await response.Content.ReadAsStringAsync();

    if (!response.IsSuccessStatusCode)
    {
        throw new InvalidOperationException($"{model} generation failed: {(int)response.StatusCode} {response.ReasonPhrase}\n{body}");
    }

    using JsonDocument json = JsonDocument.Parse(body);
    string b64 = json.RootElement.GetProperty("data")[0].GetProperty("b64_json").GetString()
        ?? throw new InvalidOperationException("Response missing data[0].b64_json.");

    return Convert.FromBase64String(b64);
}

using Azure.Core;

using Azure.Identity;

using Microsoft.Extensions.Configuration;

using System.Net.Http.Headers;

using System.Text;

using System.Text.Json;

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var endpoint = config["AZURE_AI_FOUNDRY_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_FOUNDRY_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_FOUNDRY_ENDPOINT\" \"<your-endpoint>\"");

var credential = new DefaultAzureCredential();

AccessToken token = await credential.GetTokenAsync(

new TokenRequestContext(new[] { "https://cognitiveservices.azure.com/.default" }));

using var http = new HttpClient();

http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);

async Task<byte[]> GenerateImageAsync(string model, string prompt, int width = 1024, int height = 1024)

{

string url = $"{endpoint.TrimEnd('/')}/mai/v1/images/generations?api-version=preview";

var payload = new

{

prompt,

model,

width,

height,

output_compression = 100,

output_format = "png",

n = 1

};

using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");

using HttpResponseMessage response = await http.PostAsync(url, content);

string body = await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)

{

throw new InvalidOperationException($"{model} generation failed: {(int)response.StatusCode} {response.ReasonPhrase}\n{body}");

}

using JsonDocument json = JsonDocument.Parse(body);

string b64 = json.RootElement.GetProperty("data")[0].GetProperty("b64_json").GetString()

?? throw new InvalidOperationException("Response missing data[0].b64_json.");

return Convert.FromBase64String(b64);

}

Now let’s put both models to work on the actual use cases Microsoft is targeting.

Use Case 1: Marketing & Campaign Production — Legible Text, First Try

Text rendering inside generated images has historically been the weak point of diffusion models — garbled letters, wrong spacing, headlines that look right at a glance and fall apart on inspection. MAI-Image-2.6’s quality step-up specifically targets this.

var campaignPrompt = """
    A wide-format e-commerce banner ad for a summer sale. Clean minimalist studio
    background in soft pastel blue. A pair of white running shoes floating at a
    slight angle, dramatic soft shadow beneath. Bold, perfectly legible headline
    text at the top reading "SUMMER SALE — 30% OFF" in a clean modern sans-serif
    font, white text with subtle drop shadow. Small subtext below reading
    "Limited time only" in a lighter weight. Professional advertising photography
    style, high detail, 1.5K resolution.
    """;

byte[] campaignAsset = await GenerateImageAsync("MAI-Image-2.6", campaignPrompt, width: 1536, height: 864);
await File.WriteAllBytesAsync("campaign-summer-sale-banner.png", campaignAsset);
Console.WriteLine("Saved: campaign-summer-sale-banner.png");

var campaignPrompt = """

A wide-format e-commerce banner ad for a summer sale. Clean minimalist studio

background in soft pastel blue. A pair of white running shoes floating at a

slight angle, dramatic soft shadow beneath. Bold, perfectly legible headline

text at the top reading "SUMMER SALE — 30% OFF" in a clean modern sans-serif

font, white text with subtle drop shadow. Small subtext below reading

"Limited time only" in a lighter weight. Professional advertising photography

style, high detail, 1.5K resolution.

""";

byte[] campaignAsset = await GenerateImageAsync("MAI-Image-2.6", campaignPrompt, width: 1536, height: 864);

await File.WriteAllBytesAsync("campaign-summer-sale-banner.png", campaignAsset);

Console.WriteLine("Saved: campaign-summer-sale-banner.png");

Saved: campaign-summer-sale-banner.png

1	Saved: campaign-summer-sale-banner.png

Open the file and check the headline text specifically — that’s the thing to inspect closely, since it’s the failure mode this model is explicitly built to fix. If your marketing team currently routes every hero banner through a designer for text placement and kerning, this is the workflow to pilot first: generate ten headline variants overnight, let the team pick the one that needs the least manual cleanup.

Use Case 2: Retail & E-Commerce Catalogs — Consistent Imagery at Volume

Catalogs live and die on consistency: same lighting, same framing, same background across hundreds of SKUs. Here’s a batch pattern using Flash for the volume — this is exactly the “millionth personalized variant” scenario Flash is priced for.

var catalogItems = new[]
{
    new { Sku = "SKU-1001", Description = "a matte black ceramic coffee mug" },
    new { Sku = "SKU-1002", Description = "a glossy red ceramic coffee mug" },
    new { Sku = "SKU-1003", Description = "a sage green ceramic coffee mug" },
    new { Sku = "SKU-1004", Description = "a cream white ceramic coffee mug" },
};

const string catalogStyleTemplate = """
    A studio product photo of {0} on a plain white seamless background,
    soft even lighting from the upper left, subtle reflection beneath,
    centered composition, e-commerce catalog style, no props, no text.
    """;

foreach (var item in catalogItems)
{
    var prompt = string.Format(catalogStyleTemplate, item.Description);
    byte[] image = await GenerateImageAsync("MAI-Image-2.6-Flash", prompt);
    string outPath = $"catalog-{item.Sku}.png";
    await File.WriteAllBytesAsync(outPath, image);
    Console.WriteLine($"Saved: {outPath}");
}

var catalogItems = new[]

{

new { Sku = "SKU-1001", Description = "a matte black ceramic coffee mug" },

new { Sku = "SKU-1002", Description = "a glossy red ceramic coffee mug" },

new { Sku = "SKU-1003", Description = "a sage green ceramic coffee mug" },

new { Sku = "SKU-1004", Description = "a cream white ceramic coffee mug" },

};

const string catalogStyleTemplate = """

A studio product photo of {0} on a plain white seamless background,

soft even lighting from the upper left, subtle reflection beneath,

centered composition, e-commerce catalog style, no props, no text.

""";

foreach (var item in catalogItems)

{

var prompt = string.Format(catalogStyleTemplate, item.Description);

byte[] image = await GenerateImageAsync("MAI-Image-2.6-Flash", prompt);

string outPath = $"catalog-{item.Sku}.png";

await File.WriteAllBytesAsync(outPath, image);

Console.WriteLine($"Saved: {outPath}");

}

Saved: catalog-SKU-1001.png
Saved: catalog-SKU-1002.png
Saved: catalog-SKU-1003.png
Saved: catalog-SKU-1004.png

Saved: catalog-SKU-1001.png

Saved: catalog-SKU-1002.png

Saved: catalog-SKU-1003.png

Saved: catalog-SKU-1004.png

Because the style template is fixed and only the product description changes, lighting and framing stay consistent across the whole batch. Swap this loop to read SKUs from your actual product database and you have an overnight catalog-refresh job instead of a photo studio booking.

Use Case 3: Brand & Creative Operations — Multi-Reference Editing

This is the capability that’s genuinely new in 2.6: up to five reference images in a single request, so a locked brand asset — a mascot, a product shape, a logo mark — stays consistent as you reformat it for different channels. Here’s a helper for a multi-reference edit call, followed by locking a product across three different channel formats.

async Task<byte[]> EditWithReferencesAsync(string model, string editPrompt, params string[] referenceImagePaths)
{
    if (referenceImagePaths.Length == 0 || referenceImagePaths.Length > 5)
    {
        throw new ArgumentException("Provide between 1 and 5 reference images.");
    }

    string url = $"{endpoint.TrimEnd('/')}/mai/v1/images/edits?api-version=preview";

    using var content = new MultipartFormDataContent
    {
        { new StringContent(editPrompt), "prompt" },
        { new StringContent(model), "model" }
    };

    foreach (var path in referenceImagePaths)
    {
        byte[] bytes = await File.ReadAllBytesAsync(path);
        var imagePart = new ByteArrayContent(bytes);
        imagePart.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");
        content.Add(imagePart, "image", Path.GetFileName(path));
    }

    using HttpResponseMessage response = await http.PostAsync(url, content);
    string body = await response.Content.ReadAsStringAsync();

    if (!response.IsSuccessStatusCode)
    {
        throw new InvalidOperationException($"{model} multi-reference edit failed: {(int)response.StatusCode} {response.ReasonPhrase}\n{body}");
    }

    using JsonDocument json = JsonDocument.Parse(body);
    string b64 = json.RootElement.GetProperty("data")[0].GetProperty("b64_json").GetString()
        ?? throw new InvalidOperationException("Response missing data[0].b64_json.");

    return Convert.FromBase64String(b64);
}
 
// Lock a brand mascot + product shape as references, then reformat for three channels.
var channelFormats = new[]
{
    ("instagram-square.png", "Recompose for an Instagram square post (1:1), mascot on the right, product centered-left."),
    ("story-vertical.png", "Recompose for a 9:16 vertical story format, mascot at the bottom, product taking up the upper two-thirds."),
    ("banner-wide.png", "Recompose for a wide horizontal banner (16:9), mascot and product side by side with even spacing."),
};

foreach (var (fileName, formatPrompt) in channelFormats)
{
    byte[] reformatted = await EditWithReferencesAsync(
        "MAI-Image-2.6",
        formatPrompt + " Keep the mascot design, product shape, and brand colors identical to the references.",
        "brand-mascot-reference.png",
        "product-shape-reference.png");

    await File.WriteAllBytesAsync(fileName, reformatted);
    Console.WriteLine($"Saved: {fileName}");
}

async Task<byte[]> EditWithReferencesAsync(string model, string editPrompt, params string[] referenceImagePaths)

{

if (referenceImagePaths.Length == 0 || referenceImagePaths.Length > 5)

{

throw new ArgumentException("Provide between 1 and 5 reference images.");

}

string url = $"{endpoint.TrimEnd('/')}/mai/v1/images/edits?api-version=preview";

using var content = new MultipartFormDataContent

{

{ new StringContent(editPrompt), "prompt" },

{ new StringContent(model), "model" }

};

foreach (var path in referenceImagePaths)

{

byte[] bytes = await File.ReadAllBytesAsync(path);

var imagePart = new ByteArrayContent(bytes);

imagePart.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");

content.Add(imagePart, "image", Path.GetFileName(path));

}

using HttpResponseMessage response = await http.PostAsync(url, content);

string body = await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)

{

throw new InvalidOperationException($"{model} multi-reference edit failed: {(int)response.StatusCode} {response.ReasonPhrase}\n{body}");

}

using JsonDocument json = JsonDocument.Parse(body);

string b64 = json.RootElement.GetProperty("data")[0].GetProperty("b64_json").GetString()

?? throw new InvalidOperationException("Response missing data[0].b64_json.");

return Convert.FromBase64String(b64);

}

// Lock a brand mascot + product shape as references, then reformat for three channels.

var channelFormats = new[]

{

("instagram-square.png", "Recompose for an Instagram square post (1:1), mascot on the right, product centered-left."),

("story-vertical.png", "Recompose for a 9:16 vertical story format, mascot at the bottom, product taking up the upper two-thirds."),

("banner-wide.png", "Recompose for a wide horizontal banner (16:9), mascot and product side by side with even spacing."),

};

foreach (var (fileName, formatPrompt) in channelFormats)

{

byte[] reformatted = await EditWithReferencesAsync(

"MAI-Image-2.6",

formatPrompt + " Keep the mascot design, product shape, and brand colors identical to the references.",

"brand-mascot-reference.png",

"product-shape-reference.png");

await File.WriteAllBytesAsync(fileName, reformatted);

Console.WriteLine($"Saved: {fileName}");

}

Saved: instagram-square.png
Saved: story-vertical.png
Saved: banner-wide.png

Saved: instagram-square.png

Saved: story-vertical.png

Saved: banner-wide.png

Same mascot, same product, same brand colors — three different channel-native compositions, generated from two locked reference images instead of a designer manually recreating the layout three times. This is the actual “one approved concept travels across formats without drifting” pitch, and it’s the reason multi-reference editing is the headline feature of this release.

Use Case 4: Personalization at Scale — Flash in an Interactive Loop

Flash’s pricing and latency profile make per-user or per-segment generation viable inside a live request path, not just a batch job. Here’s a minimal pattern for a personalized greeting card generator — the kind of feature you’d wire into an app, not run overnight.

async Task<byte[]> GeneratePersonalizedCardAsync(string recipientName, string occasion, string themeColor)
{
    var prompt = $"""
        A festive greeting card illustration for a {occasion} celebration.
        Hand-lettered style text reading "Happy {occasion}, {recipientName}!"
        centered at the top. Warm {themeColor} color palette, soft decorative
        flourishes around the border, friendly and celebratory illustration style,
        square format.
        """;
 
    return await GenerateImageAsync("MAI-Image-2.6-Flash", prompt, width: 1024, height: 1024);
}
 
// Simulates generating cards for a batch of users in an interactive path —
// fast enough per-call that this could sit behind a live API endpoint.
var requests = new[]
{
    ("Priya", "Birthday", "coral and gold"),
    ("Marcus", "Work Anniversary", "navy and silver"),
    ("Aiko", "Graduation", "sage green and cream"),
};
 
foreach (var (name, occasion, colors) in requests)
{
    var started = DateTime.UtcNow;
    byte[] card = await GeneratePersonalizedCardAsync(name, occasion, colors);
    var elapsed = DateTime.UtcNow - started;
 
    string fileName = $"card-{name.ToLowerInvariant()}.png";
    await File.WriteAllBytesAsync(fileName, card);
    Console.WriteLine($"Saved: {fileName} ({elapsed.TotalSeconds:F1}s)");
}

async Task<byte[]> GeneratePersonalizedCardAsync(string recipientName, string occasion, string themeColor)

{

var prompt = $"""

A festive greeting card illustration for a {occasion} celebration.

Hand-lettered style text reading "Happy {occasion}, {recipientName}!"

centered at the top. Warm {themeColor} color palette, soft decorative

flourishes around the border, friendly and celebratory illustration style,

square format.

""";

return await GenerateImageAsync("MAI-Image-2.6-Flash", prompt, width: 1024, height: 1024);

}

// Simulates generating cards for a batch of users in an interactive path —

// fast enough per-call that this could sit behind a live API endpoint.

var requests = new[]

{

("Priya", "Birthday", "coral and gold"),

("Marcus", "Work Anniversary", "navy and silver"),

("Aiko", "Graduation", "sage green and cream"),

};

foreach (var (name, occasion, colors) in requests)

{

var started = DateTime.UtcNow;

byte[] card = await GeneratePersonalizedCardAsync(name, occasion, colors);

var elapsed = DateTime.UtcNow - started;

string fileName = $"card-{name.ToLowerInvariant()}.png";

await File.WriteAllBytesAsync(fileName, card);

Console.WriteLine($"Saved: {fileName} ({elapsed.TotalSeconds:F1}s)");

}

Saved: card-priya.png (2.1s)
Saved: card-marcus.png (1.9s)
Saved: card-aiko.png (2.0s)

Saved: card-priya.png (2.1s)

Saved: card-marcus.png (1.9s)

Saved: card-aiko.png (2.0s)

(Timings above are illustrative — measure against your own Foundry deployment region and load. The point of the pattern is that Flash’s latency profile makes this loop viable inside a request/response cycle, not that these exact numbers are guaranteed.)

Swap the hardcoded array for real user data from your app, and this same loop becomes a “generate a personalized asset on demand” endpoint behind an API controller.

Use Case 5: Image Cleanup & Surgical Editing

The other side of multi-reference editing is single-image precision editing — targeted object edits, replacements, inpainting, text updates, and artifact removal, without regenerating the whole scene. This is the same surgical-edit pattern from MAI-Image-2.5, still very much present in 2.6.

var cleanupPrompt = """
    Remove the motion blur from the product in this image and sharpen the focus.
    Replace the scuffed cardboard background with a clean plain white studio
    background. Keep the product's position, angle, and proportions exactly
    the same — do not regenerate or redesign the product itself.
    """;

byte[] cleanedUp = await EditWithReferencesAsync(
    "MAI-Image-2.6",
    cleanupPrompt,
    "warehouse-photo-raw.png");

await File.WriteAllBytesAsync("product-cleaned.png", cleanedUp);
Console.WriteLine("Saved: product-cleaned.png");

var cleanupPrompt = """

Remove the motion blur from the product in this image and sharpen the focus.

Replace the scuffed cardboard background with a clean plain white studio

background. Keep the product's position, angle, and proportions exactly

the same — do not regenerate or redesign the product itself.

""";

byte[] cleanedUp = await EditWithReferencesAsync(

"MAI-Image-2.6",

cleanupPrompt,

"warehouse-photo-raw.png");

await File.WriteAllBytesAsync("product-cleaned.png", cleanedUp);

Console.WriteLine("Saved: product-cleaned.png");

Saved: product-cleaned.png

1	Saved: product-cleaned.png

This is the unglamorous, high-volume use case that actually pays for itself: a warehouse team’s phone-camera product shots turned into catalog-ready images without a reshoot. The product itself is untouched — only the blur and background changed.

Where This Fits (and Where It Doesn’t)

Reach for MAI-Image-2.6 when:

You need final, ship-ready campaign assets with legible, precise text rendering
You’re locking a brand asset across multiple reference images and need it to survive reformatting
Editing precision matters more than generation speed

Reach for MAI-Image-2.6-Flash when:

You’re generating at volume — catalogs, personalization, high-throughput pipelines
Latency matters because the call sits inside an interactive user-facing path
You’re iterating on concepts before committing to a final MAI-Image-2.6 render

Don’t reach for either when:

You need pixel-perfect brand-guideline compliance without any human review — treat generated output as a strong first draft, not a final approval-free asset
Your workload depends on an SDK-level ImageClient integration today — you’re on raw REST calls for now, and the API surface is still settling in public preview

Wrapping Up

MAI-Image-2.6 and MAI-Image-2.6-Flash aren’t “the same model, one slower.” They’re a genuine quality/throughput portfolio: iterate fast with Flash, ship precise with 2.6, and use multi-reference editing to keep one approved creative direction consistent across every format your marketing or product team actually needs. If your team is currently paying someone to manually generate the fiftieth catalog variant or resize one approved hero image into six channel formats by hand — this is worth a real pilot, not just a demo.

Resources

Building AI features in C#? I write about practical, no-hype prompt engineering and Azure AI patterns for .NET developers. Check out Prompt Engineering for .NET Developers — free, no Python required. Also subscribe to my mailing list for the latest blogs, tips and tricks I share.

Microsoft Foundry

.net, Azure AI, C#, Developer Tools, Generative AI, Image Generation, MAI-Image-2.6, MAI-Image-2.6-Flash, Microsoft AI, Microsoft Foundry

GPT-6 Astra for C# Developers

Taswar Bhatti September 7, 2026 No Comments

The next era of enterprise AI isn’t going to be defined by chat experiences. It’s going to be defined by how well a model can actually work for you — not just talk at you. GPT-6 Astra, OpenAI’s newest frontier model, is now generally available for all customers in Microsoft Foundry. Instead of optimizing for “answer this one prompt well,” Astra is built to take an open-ended challenge, reason through it in multiple steps, create a plan, and hand you a finished result.

That’s a meaningfully different design target, and it’s the kind of thing that matters once you move past demos and start building agents that have to survive contact with real workloads — where the interesting part isn’t the model call, it’s everything Foundry brings around it: identity, networking, governance, data handling, evaluation, compliance.

As always: no Python required, no notebook required. Just Microsoft.Extensions.AI and dotnet run.

What GPT-6 Astra Actually Is

A few things worth knowing before you touch any code:

Deliberate planning and decision support. Astra breaks a challenge into steps, evaluates options, communicates its recommendation, and identifies next actions for review — rather than just returning a single best-effort answer.
Polished, purposeful output. It applies context, templates, and quality standards throughout a workflow, aiming to produce documents, spreadsheets, presentations, and analyses that are ready for expert review, not rough drafts.
Execution across applications. With advanced tool use and computer use, Astra can interact with software on a person’s behalf, move between apps, and complete multi-step tasks with appropriate human oversight — including workflows that have no dedicated API.
Long-context understanding. Up to 1,050,000 total context tokens, so large repositories, filings, and multi-document knowledge bases can be reasoned about in one pass instead of chunked and reassembled.
Enterprise controls by default. Microsoft Entra identity and access management, encryption in transit and at rest, private networking, RBAC, content filtering, safety evaluations, and monitoring. Prompts and outputs are not used to train the models.
Generally available. Not preview — this is production-ready in Foundry today.

Why This Matters for .NET Developers Specifically

The enterprise scenarios Microsoft is calling out map directly onto real .NET workloads:

Software engineering — reproduce complex bugs, investigate likely causes, propose fixes, and prepare changes for developer testing and review
Business intelligence — build and refine dashboards in Power BI, compare data, identify trade-offs, and prepare insights to share
Professional work — produce documents, spreadsheets, and presentations that follow existing templates and business standards
Application workflows — update customer records, process forms, test websites, and work through approved interfaces where dedicated APIs are limited
Financial services — synthesize filings, market data, and internal research into an investment point of view, then draft client-ready materials in a firm’s house style
Customer experience — resolve tickets rather than route them: research the issue, act in CRM and billing, close the loop

And because Astra is a native OpenAI model in Foundry — not a partner/MaaS model — it slots in through the exact same AzureOpenAIClient + IChatClient pattern you already use for GPT-4o or GPT-chat-latest. No special client, no bearer-token workaround. Swapping Astra into your evaluation pipeline is a deployment-name change, not a rewrite.

Getting Started

dotnet new console -n GptSixAstraDemo
cd GptSixAstraDemo
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet add package Microsoft.Extensions.AI.OpenAI
dotnet user-secrets init
dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

dotnet new console -n GptSixAstraDemo

cd GptSixAstraDemo

dotnet add package Azure.AI.OpenAI

dotnet add package Microsoft.Extensions.AI

dotnet add package Azure.Identity

dotnet add package Microsoft.Extensions.Configuration.UserSecrets

dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables

dotnet add package Microsoft.Extensions.AI.OpenAI

dotnet user-secrets init

dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

Deploy gpt-6-astra from the Foundry Model Catalog to your project — same process as any other model. Grab your endpoint and deployment name, and you’re ready to go.

Use Case 1: Software Engineering — Deliberate Bug Investigation and Fix Proposal

This is the headline scenario: Astra reproducing a complex bug, investigating likely causes, and proposing a fix for developer review — not guessing from a stack trace alone. Let’s build a small agent that pulls recent error logs and the relevant code change history before it commits to a root cause, reasoning through both signals together instead of pattern-matching on the first plausible explanation.

#pragma warning disable OPENAI001 // Responses API is experimental in the OpenAI .NET SDK
using Azure.Identity;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using OpenAI.Responses;
using System.ClientModel.Primitives;
using System.ComponentModel;
 
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();
 
var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "gpt-6-astra";
var resourceEndpoint = config["AZURE_AI_ENDPOINT"]
    ?? throw new InvalidOperationException(
        "AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"&lt;your-endpoint&gt;\"");

// The Responses API is only reachable on the v1 surface, not the deployments/api-version surface.
var responsesEndpoint = new Uri($"{resourceEndpoint.TrimEnd('/')}/openai/v1");
var tokenPolicy = new BearerTokenPolicy(new DefaultAzureCredential(), "https://ai.azure.com/.default");

// gpt-6-astra doesn't allow tools + reasoning_effort on /chat/completions; use /responses instead.
IChatClient chatClient = new ResponsesClient(
        authenticationPolicy: tokenPolicy,
        options: new ResponsesClientOptions { Endpoint = responsesEndpoint })
    .AsIChatClient(deploymentName)
    .AsBuilder()
    .UseFunctionInvocation()
    .Build();
 
var chatOptions = new ChatOptions
{
    Tools =
    [
        AIFunctionFactory.Create(GetRecentErrorLogs),
        AIFunctionFactory.Create(GetRecentCommits)
    ],
    // Deep, multi-step decision support - worth paying for higher reasoning effort.
    AdditionalProperties = new AdditionalPropertiesDictionary
    {
        ["reasoning_effort"] = "high" // low | medium | high
    }
};
 
var messages = new List<ChatMessage>
{
    new(ChatRole.System,
        "You are a senior engineer investigating a production bug. Pull both recent error " +
        "logs and recent commit history before concluding a root cause. State your recommended " +
        "fix, your confidence level, and the next action a human reviewer should take."),
    new(ChatRole.User, "Users report 'checkout-api' intermittently returns HTTP 500 on order submission since this morning. What's going on and what should we do?")
};
 
var response = await chatClient.GetResponseAsync(messages, chatOptions);
Console.WriteLine(response.Text);
 
// --- Tool stand-ins for real observability/source-control APIs ---
 
[Description("Gets recent error log entries for a named service.")]
static string GetRecentErrorLogs(
    [Description("The service name, e.g. checkout-api")] string serviceName)
{
    return serviceName switch
    {
        "checkout-api" => "09:14 NullReferenceException at OrderTotalCalculator.Apply(discount). " +
                           "Occurs on ~8% of requests, only when a promo code is present.",
        _ => "No recent errors found."
    };
}
 
[Description("Gets a summary of recent commits merged to a named service's main branch.")]
static string GetRecentCommits(
    [Description("The service name, e.g. checkout-api")] string serviceName)
{
    return serviceName switch
    {
        "checkout-api" => "06:40 - 'Refactor discount pipeline to support stacked promo codes' " +
                           "(touches OrderTotalCalculator.cs, PromoCodeResolver.cs).",
        _ => "No recent commits found."
    };
}

#pragma warning disable OPENAI001 // Responses API is experimental in the OpenAI .NET SDK

using Azure.Identity;

using Microsoft.Extensions.AI;

using Microsoft.Extensions.Configuration;

using OpenAI.Responses;

using System.ClientModel.Primitives;

using System.ComponentModel;

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "gpt-6-astra";

var resourceEndpoint = config["AZURE_AI_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\"");

// The Responses API is only reachable on the v1 surface, not the deployments/api-version surface.

var responsesEndpoint = new Uri($"{resourceEndpoint.TrimEnd('/')}/openai/v1");

var tokenPolicy = new BearerTokenPolicy(new DefaultAzureCredential(), "https://ai.azure.com/.default");

// gpt-6-astra doesn't allow tools + reasoning_effort on /chat/completions; use /responses instead.

IChatClient chatClient = new ResponsesClient(

authenticationPolicy: tokenPolicy,

options: new ResponsesClientOptions { Endpoint = responsesEndpoint })

.AsIChatClient(deploymentName)

.AsBuilder()

.UseFunctionInvocation()

.Build();

var chatOptions = new ChatOptions

{

Tools =

[

AIFunctionFactory.Create(GetRecentErrorLogs),

AIFunctionFactory.Create(GetRecentCommits)

// Deep, multi-step decision support - worth paying for higher reasoning effort.

AdditionalProperties = new AdditionalPropertiesDictionary

{

["reasoning_effort"] = "high" // low | medium | high

}

};

var messages = new List<ChatMessage>

{

new(ChatRole.System,

"You are a senior engineer investigating a production bug. Pull both recent error " +

"logs and recent commit history before concluding a root cause. State your recommended " +

"fix, your confidence level, and the next action a human reviewer should take."),

new(ChatRole.User, "Users report 'checkout-api' intermittently returns HTTP 500 on order submission since this morning. What's going on and what should we do?")

};

var response = await chatClient.GetResponseAsync(messages, chatOptions);

Console.WriteLine(response.Text);

// --- Tool stand-ins for real observability/source-control APIs ---

[Description("Gets recent error log entries for a named service.")]

static string GetRecentErrorLogs(

[Description("The service name, e.g. checkout-api")] string serviceName)

{

return serviceName switch

{

"checkout-api" => "09:14 NullReferenceException at OrderTotalCalculator.Apply(discount). " +

"Occurs on ~8% of requests, only when a promo code is present.",

_ => "No recent errors found."

};

}

[Description("Gets a summary of recent commits merged to a named service's main branch.")]

static string GetRecentCommits(

[Description("The service name, e.g. checkout-api")] string serviceName)

{

return serviceName switch

{

"checkout-api" => "06:40 - 'Refactor discount pipeline to support stacked promo codes' " +

"(touches OrderTotalCalculator.cs, PromoCodeResolver.cs).",

_ => "No recent commits found."

};

}

Case 1 – Output

**Likely cause:** a regression in promo-code handling from the discount-pipeline refactor merged at **06:40**.

Evidence:
- Recent logs show a **`NullReferenceException` at `OrderTotalCalculator.Apply(discount)`** at 09:14, affecting roughly **8% of requests**, only when a promo code is present.
- The refactor, “support stacked promo codes,” changed both `OrderTotalCalculator.cs` and `PromoCodeResolver.cs`, directly overlapping the failing path.

This suggests the new pipeline permits a null value that the calculator does not handle. The exact null reference—and whether that commit was deployed before failures began—still needs confirmation.

**Recommended fix**
- **Mitigate:** if deployment timing confirms the correlation, roll back the refactor through the normal incident process, provided rollback is safe.
- **Patch:** inspect the resolver-to-calculator contract and explicitly handle absent or invalid discount results according to intended promo behavior. Don’t simply swallow the exception or silently charge an undiscounted total.
- Add regression tests for invalid, expired, unresolved, and stacked promo codes, plus orders without promos.

**Confidence:** high that the failure is in promo discount handling; moderate that this specific commit caused it until deployment history and the diff are verified.

**Next human action:** have the on-call reviewer confirm when the 06:40 commit reached production and review the two changed files against the exception stack. If confirmed and safe, approve rollback, then monitor checkout 500 rates and promo-order success. Before retrying affected orders, verify whether failed requests created any orders or payments.

**Likely cause:** a regression in promo-code handling from the discount-pipeline refactor merged at **06:40**.

Evidence:

- Recent logs show a **`NullReferenceException` at `OrderTotalCalculator.Apply(discount)`** at 09:14, affecting roughly **8% of requests**, only when a promo code is present.

- The refactor, “support stacked promo codes,” changed both `OrderTotalCalculator.cs` and `PromoCodeResolver.cs`, directly overlapping the failing path.

This suggests the new pipeline permits a null value that the calculator does not handle. The exact null reference—and whether that commit was deployed before failures began—still needs confirmation.

**Recommended fix**

- **Mitigate:** if deployment timing confirms the correlation, roll back the refactor through the normal incident process, provided rollback is safe.

- **Patch:** inspect the resolver-to-calculator contract and explicitly handle absent or invalid discount results according to intended promo behavior. Don’t simply swallow the exception or silently charge an undiscounted total.

- Add regression tests for invalid, expired, unresolved, and stacked promo codes, plus orders without promos.

**Confidence:** high that the failure is in promo discount handling; moderate that this specific commit caused it until deployment history and the diff are verified.

**Next human action:** have the on-call reviewer confirm when the 06:40 commit reached production and review the two changed files against the exception stack. If confirmed and safe, approve rollback, then monitor checkout 500 rates and promo-order success. Before retrying affected orders, verify whether failed requests created any orders or payments.

Notice Astra doesn’t stop at “here’s an exception” — it correlates the error with why it started happening (a specific recent change), proposes a concrete fix, states its confidence, and hands off a clear next action. That’s the “planning and decision support” Microsoft is describing, applied to something every .NET team actually deals with.

Use Case 2: Business Intelligence — Power BI Insight Synthesis

The second headline scenario is business intelligence: comparing data, identifying trade-offs, and preparing insights someone can act on. Here’s a pattern for feeding Astra a dataset summary — the kind of thing you’d pull from a Power BI dataset via the REST API — and getting back a structured, decision-ready recommendation instead of a paragraph you have to re-read three times.

using System.Text.Json.Serialization;

var chatOptionsBI = new ChatOptions
{
    ResponseFormat = ChatResponseFormat.ForJsonSchema<RegionalInsight>()
};
 
var biMessages = new List<ChatMessage>
{
    new(ChatRole.System,
        "You are a BI analyst. Given quarterly regional sales data, identify the clearest " +
        "trade-off, recommend one action, and flag anything that needs a human to verify " +
        "before it goes in a report."),
    new(ChatRole.User, """
        Q3 regional sales summary (vs. Q2):
        - West: revenue +18%, returns +22%, avg order value flat
        - East: revenue +4%, returns -3%, avg order value +11%
        - Central: revenue -6%, returns +2%, avg order value -9%
        What should we highlight to leadership, and what's the trade-off?
        """)
};
 
var biResponse = await chatClient.GetResponseAsync<RegionalInsight>(biMessages, chatOptionsBI);
var insight = biResponse.Result;
Console.WriteLine("Case 2: Business Intelligence — Power BI Insight Synthesis");
Console.WriteLine("**********************************************************");
Console.WriteLine($"Headline: {insight.Headline}");
Console.WriteLine($"Trade-off: {insight.TradeOff}");
Console.WriteLine($"Recommended action: {insight.RecommendedAction}");
Console.WriteLine($"Needs human verification: {insight.NeedsVerification}");
Console.WriteLine("**********************************************************");
record RegionalInsight(
    [property: JsonPropertyName("headline")] string Headline,
    [property: JsonPropertyName("trade_off")] string TradeOff,
    [property: JsonPropertyName("recommended_action")] string RecommendedAction,
    [property: JsonPropertyName("needs_verification")] string NeedsVerification);

using System.Text.Json.Serialization;

var chatOptionsBI = new ChatOptions

{

ResponseFormat = ChatResponseFormat.ForJsonSchema<RegionalInsight>()

};

var biMessages = new List<ChatMessage>

{

new(ChatRole.System,

"You are a BI analyst. Given quarterly regional sales data, identify the clearest " +

"trade-off, recommend one action, and flag anything that needs a human to verify " +

"before it goes in a report."),

new(ChatRole.User, """

Q3 regional sales summary (vs. Q2):

- West: revenue +18%, returns +22%, avg order value flat

- East: revenue +4%, returns -3%, avg order value +11%

- Central: revenue -6%, returns +2%, avg order value -9%

What should we highlight to leadership, and what's the trade-off?

""")

};

var biResponse = await chatClient.GetResponseAsync<RegionalInsight>(biMessages, chatOptionsBI);

var insight = biResponse.Result;

Console.WriteLine("Case 2: Business Intelligence — Power BI Insight Synthesis");

Console.WriteLine("**********************************************************");

Console.WriteLine($"Headline: {insight.Headline}");

Console.WriteLine($"Trade-off: {insight.TradeOff}");

Console.WriteLine($"Recommended action: {insight.RecommendedAction}");

Console.WriteLine($"Needs human verification: {insight.NeedsVerification}");

Console.WriteLine("**********************************************************");

record RegionalInsight(

[property: JsonPropertyName("headline")] string Headline,

[property: JsonPropertyName("trade_off")] string TradeOff,

[property: JsonPropertyName("recommended_action")] string RecommendedAction,

[property: JsonPropertyName("needs_verification")] string NeedsVerification);

Case 2 – Output

Headline: West leads revenue growth (+18%), but rising returns warrant scrutiny. East shows more balanced improvement; Central is weakening across all three metrics.
Trade-off: West’s strong revenue growth comes alongside a larger percentage increase in returns (+22%), with average order value flat—potentially offsetting some growth benefits. East grows more slowly (+4%) but combines fewer returns (-3%) with higher average order value (+11%). Profitability cannot be determined from these figures alone.
Recommended action: Prioritize a review of West’s return drivers by product and channel before committing additional growth investment.
Needs human verification: Confirm whether returns means count, dollar value, or return rate; whether revenue is gross or net of returns; and the underlying Q2/Q3 totals. A 22% increase in returns versus 18% revenue growth does not by itself establish a higher return rate or lower profit. Check return timing and seasonal effects before attributing the changes to Q3 performance.

Headline: West leads revenue growth (+18%), but rising returns warrant scrutiny. East shows more balanced improvement; Central is weakening across all three metrics.

Trade-off: West’s strong revenue growth comes alongside a larger percentage increase in returns (+22%), with average order value flat—potentially offsetting some growth benefits. East grows more slowly (+4%) but combines fewer returns (-3%) with higher average order value (+11%). Profitability cannot be determined from these figures alone.

Recommended action: Prioritize a review of West’s return drivers by product and channel before committing additional growth investment.

Needs human verification: Confirm whether returns means count, dollar value, or return rate; whether revenue is gross or net of returns; and the underlying Q2/Q3 totals. A 22% increase in returns versus 18% revenue growth does not by itself establish a higher return rate or lower profit. Check return timing and seasonal effects before attributing the changes to Q3 performance.

That last field is doing real work: Astra is explicit about where the data runs out and a human needs to step in, instead of confidently inventing a root cause it can’t actually support. Wire the structured fields straight into a Power BI custom visual, a Teams card, or an email digest — no regex-parsing a paragraph to extract “what do I actually do with this.”

Use Case 3: Professional Work — Template-Based Report Generation

The third scenario: producing documents that follow existing templates and business standards, polished enough for expert review rather than a rough draft. Here’s Astra generating a weekly status report against a fixed template structure — the kind of thing that normally eats twenty minutes of a project lead’s Friday afternoon.

var reportMessages = new List<ChatMessage>
{
    new(ChatRole.System, """
        You produce weekly status reports for a project template with exactly these
        sections, in this order: Summary, Progress This Week, Risks, Next Week.
        Keep tone professional and concise. Do not invent details not provided.
        """),
    new(ChatRole.User, """
        Project: Order Fulfillment Modernization
        Raw notes from the team:
        - Migrated inventory sync job to the new event bus, passed load testing
        - Warehouse API integration is 2 days behind schedule due to a vendor sandbox outage
        - Next week: finish warehouse API integration, start UAT with ops team
        - Risk: vendor sandbox reliability could delay UAT start if it recurs
        """)
};

var reportResponse = await chatClient.GetResponseAsync(reportMessages);
Console.WriteLine(reportResponse.Text);

var reportMessages = new List<ChatMessage>

{

new(ChatRole.System, """

You produce weekly status reports for a project template with exactly these

sections, in this order: Summary, Progress This Week, Risks, Next Week.

Keep tone professional and concise. Do not invent details not provided.

"""),

new(ChatRole.User, """

Project: Order Fulfillment Modernization

Raw notes from the team:

- Migrated inventory sync job to the new event bus, passed load testing

- Warehouse API integration is 2 days behind schedule due to a vendor sandbox outage

- Next week: finish warehouse API integration, start UAT with ops team

- Risk: vendor sandbox reliability could delay UAT start if it recurs

""")

};

var reportResponse = await chatClient.GetResponseAsync(reportMessages);

Console.WriteLine(reportResponse.Text);

Case 3 – Output

## Summary
Order Fulfillment Modernization progressed with the inventory sync migration completed and load testing passed. Warehouse API integration is two days behind schedule.

## Progress This Week
- Migrated the inventory sync job to the new event bus and passed load testing.
- Warehouse API integration fell two days behind schedule due to a vendor sandbox outage.

## Risks
- Recurring vendor sandbox outages could delay the start of UAT.

## Next Week
- Finish warehouse API integration.
- Start UAT with the operations team.

## Summary

Order Fulfillment Modernization progressed with the inventory sync migration completed and load testing passed. Warehouse API integration is two days behind schedule.

## Progress This Week

- Migrated the inventory sync job to the new event bus and passed load testing.

- Warehouse API integration fell two days behind schedule due to a vendor sandbox outage.

## Risks

- Recurring vendor sandbox outages could delay the start of UAT.

## Next Week

- Finish warehouse API integration.

- Start UAT with the operations team.

This is deliberately unglamorous, and that’s the point — Astra didn’t editorialize, didn’t invent a risk that wasn’t in the notes, and stuck to the exact template structure. That’s the difference between “ready for expert review” and “needs to be rewritten before anyone sees it.”

Use Case 4: Application Workflows — Acting Through Approved Interfaces

The fourth scenario is the one without a clean API: updating customer records, processing forms, and working through approved interfaces where a dedicated API is limited or doesn’t exist. Full computer-use automation is a Foundry-side capability with its own configuration, approvals, and monitoring — but the same tool-driven pattern applies at the code level. Here’s Astra deciding what action to take and why, with the actual system interaction going through a scoped, human-approved tool rather than the model touching anything directly.

var workflowChatOptions = new ChatOptions
{
    Tools =
    [
        AIFunctionFactory.Create(LookUpCustomerRecord),
        AIFunctionFactory.Create(ProposeRecordUpdate)
    ]
};

var workflowMessages = new List<ChatMessage>
{
    new(ChatRole.System,
        "You process customer update requests submitted via a support form. Look up the " +
        "current record before proposing any change. Never apply an update directly - " +
        "only propose it for a human approver to confirm."),
    new(ChatRole.User, "Form submission: customer ACC-4471 says their billing email should now be finance@northwind-retail.com instead of the old one.")
};

var workflowResponse = await chatClient.GetResponseAsync(workflowMessages, workflowChatOptions);
Console.WriteLine(workflowResponse.Text);

// --- Scoped tool stand-ins - the model proposes, a human/approved system applies ---

[Description("Looks up a customer record by account ID.")]
static string LookUpCustomerRecord(
    [Description("The account ID, e.g. ACC-4471")] string accountId)
{
    return accountId switch
    {
        "ACC-4471" => "Account: Northwind Retail. Current billing email: billing-old@northwind-retail.com. Status: active.",
        _ => "Account not found."
    };
}

[Description("Proposes a record update for human approval. Does not apply the change.")]
static string ProposeRecordUpdate(
    [Description("The account ID")] string accountId,
    [Description("The field to change")] string field,
    [Description("The new value")] string newValue)
{
    return $"Proposed update queued for approval: {accountId} / {field} -> {newValue}. Awaiting reviewer confirmation.";
}

var workflowChatOptions = new ChatOptions

{

Tools =

[

AIFunctionFactory.Create(LookUpCustomerRecord),

AIFunctionFactory.Create(ProposeRecordUpdate)

]

};

var workflowMessages = new List<ChatMessage>

{

new(ChatRole.System,

"You process customer update requests submitted via a support form. Look up the " +

"current record before proposing any change. Never apply an update directly - " +

"only propose it for a human approver to confirm."),

new(ChatRole.User, "Form submission: customer ACC-4471 says their billing email should now be finance@northwind-retail.com instead of the old one.")

};

var workflowResponse = await chatClient.GetResponseAsync(workflowMessages, workflowChatOptions);

Console.WriteLine(workflowResponse.Text);

// --- Scoped tool stand-ins - the model proposes, a human/approved system applies ---

[Description("Looks up a customer record by account ID.")]

static string LookUpCustomerRecord(

[Description("The account ID, e.g. ACC-4471")] string accountId)

{

return accountId switch

{

"ACC-4471" => "Account: Northwind Retail. Current billing email: billing-old@northwind-retail.com. Status: active.",

_ => "Account not found."

};

}

[Description("Proposes a record update for human approval. Does not apply the change.")]

static string ProposeRecordUpdate(

[Description("The account ID")] string accountId,

[Description("The field to change")] string field,

[Description("The new value")] string newValue)

{

return $"Proposed update queued for approval: {accountId} / {field} -> {newValue}. Awaiting reviewer confirmation.";

}

Case 4 – Output

Proposed billing email change for **Northwind Retail (ACC-4471)**:
- **Current:** billing-old@northwind-retail.com
- **Proposed:** finance@northwind-retail.com

The proposal is queued for human approval. No change has been applied.

Proposed billing email change for **Northwind Retail (ACC-4471)**:

- **Current:** billing-old@northwind-retail.com

- **Proposed:** finance@northwind-retail.com

The proposal is queued for human approval. No change has been applied.

That “propose, don’t apply” boundary is the whole game here. The announcement is explicit about this: computer-use capability demands containment, with scoped credentials, approved resources, and human checkpoints for consequential actions. Your AIFunction tools are exactly where you enforce that boundary in code — a lookup tool that reads, and a propose tool that never writes without a human in the loop.

Use Case 5: Financial Services — Long-Context Synthesis Into an Investment Point of View

The fifth scenario leans on Astra’s up-to-1M-token context: synthesizing filings, market data, and internal research into a point of view, then drafting client-ready materials in a firm’s house style. You don’t need a chunking/retrieval pipeline for a single filing plus a research note — just pass the whole thing in.

var filingExcerpt = await File.ReadAllTextAsync("northwind-q3-10q-excerpt.txt");
var researchNote = await File.ReadAllTextAsync("internal-analyst-note.txt");

var financeMessages = new List<ChatMessage>
{
    new(ChatRole.System,
        "You are a financial analyst assistant. Synthesize the filing excerpt and internal " +
        "note into a one-page investment point of view, in the firm's house style: " +
        "Thesis, Supporting Evidence, Risks, Recommendation. Cite which source each point " +
        "came from (filing or internal note)."),
    new(ChatRole.User, $"""
        FILING EXCERPT:
        {filingExcerpt}

        INTERNAL ANALYST NOTE:
        {researchNote}

        Draft the point of view.
        """)
};

var financeResponse = await chatClient.GetResponseAsync(financeMessages);
Console.WriteLine(financeResponse.Text);

var filingExcerpt = await File.ReadAllTextAsync("northwind-q3-10q-excerpt.txt");

var researchNote = await File.ReadAllTextAsync("internal-analyst-note.txt");

var financeMessages = new List<ChatMessage>

{

new(ChatRole.System,

"You are a financial analyst assistant. Synthesize the filing excerpt and internal " +

"note into a one-page investment point of view, in the firm's house style: " +

"Thesis, Supporting Evidence, Risks, Recommendation. Cite which source each point " +

"came from (filing or internal note)."),

new(ChatRole.User, $"""

FILING EXCERPT:

{filingExcerpt}

INTERNAL ANALYST NOTE:

{researchNote}

Draft the point of view.

""")

};

var financeResponse = await chatClient.GetResponseAsync(financeMessages);

Console.WriteLine(financeResponse.Text);

Case 5 – Output

## Northwind | Q3 Investment Point of View

### Thesis
**Operational execution is improving, but the durability and cash returns of those improvements remain unproven.** Sales growth, better inventory productivity, and lower fulfillment costs support a constructive operating outlook. Internal checks corroborate several efficiency gains, but heavier promotions, elevated shrink, and rising automation spending temper confidence that recent margin improvement will persist. **[Filing; Internal note]**

### Supporting Evidence
- **Growth is supported by both existing stores and digital demand.** Q3 net sales rose 6.8% to $1.84billion, including 3.1% comparable-store growth. E-commerce grew 14% to 27% of revenue, while fulfillment cost per order fell 8%. Field checks independently corroborate lower last-mile costs and continued strong online order growth. **[Filing; Internal note]**
- **Efficiency gains extend across merchandise and operating expenses.** Gross margin increased 90 basis points to 35.7%, reflecting lower freight costs, fewer markdowns, and favorable mix. SG&A declinedto 24.1% of sales from 24.8%. Internal observations support productivity benefits from labor scheduling and reduced manual handling through distribution-center automation. **[Filing; Internal note]**
- **Inventory and supplier execution are stronger.** Inventory rose just 2.4%, below sales growth, and turns improved to 4.6 from 4.2. On-time, in-full supplier deliveries increased to 93% from 88%. Store visits and supplier conversations corroborate better availability at high-volume locations and fewerexpedited replenishment requests. **[Filing; Internal note]**
- **Cash generation improved, although investment demands are rising.** Operating cash flow increasedto $198 million from $141 million. Separately, year-to-date capital expenditures rose to $126 millionfrom $82 million, making investment discipline increasingly important to the cash-flow outlook. **[Filing]**

### Risks
- **Margin gains face emerging pressure.** Analysts observed heavier late-Q3 promotions in discretionary categories, challenging the sustainability of the filing’s markdown benefit. Shrink increased to 1.8% of sales from 1.6%, with urban-market checks indicating continued losses despite additional prevention measures. Hourly wages rose 4.5%, creating expense pressure if sales moderate. **[Filing; Internal note]**
- **Automation benefits lack a clear spending boundary.** Quarterly supply-chain automation capex reached $74 million versus $49 million a year earlier, its third consecutive quarterly increase. No capexceiling is disclosed; internal analysts flag the timing of returns as increasingly important. Continued spending could constrain free cash flow if savings or working-capital benefits disappoint. **[Filing; Internal note]**
- **Expansion and seasonal inventory introduce execution risk.** Northwind opened 12 stores and closed five, ending Q3 with 486 locations. Internal checks suggest healthy new-store traffic but corroborate below-mature-store productivity. Earlier holiday inventory arrivals reduce near-term stockout risk while increasing markdown exposure if demand falls short. **[Filing; Internal note]**
- **Digital cost savings are not yet a service differentiator.** Customer sentiment on delivery speedhas not materially improved, and returns remain a meaningful fulfillment expense. These findings temper the investment case for continued digital efficiency gains. **[Internal note]**

### Recommendation
**Maintain a cautiously constructive operating view; require further evidence before adopting a stronger investment stance.** Prioritize holiday comparable-store growth and markdown performance, shrink stabilization, new-store productivity, and clearer automation spending limits and payback milestones. These measures will help establish whether current efficiencies translate into durable earnings and free cash flow. **[Analyst assessment based on Filing; Internal note]**

A valuation-based buy or sell recommendation is not supported by the supplied materials, which provide no share price, valuation multiples, or earnings outlook.

## Northwind | Q3 Investment Point of View

### Thesis

**Operational execution is improving, but the durability and cash returns of those improvements remain unproven.** Sales growth, better inventory productivity, and lower fulfillment costs support a constructive operating outlook. Internal checks corroborate several efficiency gains, but heavier promotions, elevated shrink, and rising automation spending temper confidence that recent margin improvement will persist. **[Filing; Internal note]**

### Supporting Evidence

- **Growth is supported by both existing stores and digital demand.** Q3 net sales rose 6.8% to $1.84billion, including 3.1% comparable-store growth. E-commerce grew 14% to 27% of revenue, while fulfillment cost per order fell 8%. Field checks independently corroborate lower last-mile costs and continued strong online order growth. **[Filing; Internal note]**

- **Efficiency gains extend across merchandise and operating expenses.** Gross margin increased 90 basis points to 35.7%, reflecting lower freight costs, fewer markdowns, and favorable mix. SG&A declinedto 24.1% of sales from 24.8%. Internal observations support productivity benefits from labor scheduling and reduced manual handling through distribution-center automation. **[Filing; Internal note]**

- **Inventory and supplier execution are stronger.** Inventory rose just 2.4%, below sales growth, and turns improved to 4.6 from 4.2. On-time, in-full supplier deliveries increased to 93% from 88%. Store visits and supplier conversations corroborate better availability at high-volume locations and fewerexpedited replenishment requests. **[Filing; Internal note]**

- **Cash generation improved, although investment demands are rising.** Operating cash flow increasedto $198 million from $141 million. Separately, year-to-date capital expenditures rose to $126 millionfrom $82 million, making investment discipline increasingly important to the cash-flow outlook. **[Filing]**

### Risks

- **Margin gains face emerging pressure.** Analysts observed heavier late-Q3 promotions in discretionary categories, challenging the sustainability of the filing’s markdown benefit. Shrink increased to 1.8% of sales from 1.6%, with urban-market checks indicating continued losses despite additional prevention measures. Hourly wages rose 4.5%, creating expense pressure if sales moderate. **[Filing; Internal note]**

- **Automation benefits lack a clear spending boundary.** Quarterly supply-chain automation capex reached $74 million versus $49 million a year earlier, its third consecutive quarterly increase. No capexceiling is disclosed; internal analysts flag the timing of returns as increasingly important. Continued spending could constrain free cash flow if savings or working-capital benefits disappoint. **[Filing; Internal note]**

- **Expansion and seasonal inventory introduce execution risk.** Northwind opened 12 stores and closed five, ending Q3 with 486 locations. Internal checks suggest healthy new-store traffic but corroborate below-mature-store productivity. Earlier holiday inventory arrivals reduce near-term stockout risk while increasing markdown exposure if demand falls short. **[Filing; Internal note]**

- **Digital cost savings are not yet a service differentiator.** Customer sentiment on delivery speedhas not materially improved, and returns remain a meaningful fulfillment expense. These findings temper the investment case for continued digital efficiency gains. **[Internal note]**

### Recommendation

**Maintain a cautiously constructive operating view; require further evidence before adopting a stronger investment stance.** Prioritize holiday comparable-store growth and markdown performance, shrink stabilization, new-store productivity, and clearer automation spending limits and payback milestones. These measures will help establish whether current efficiencies translate into durable earnings and free cash flow. **[Analyst assessment based on Filing; Internal note]**

A valuation-based buy or sell recommendation is not supported by the supplied materials, which provide no share price, valuation multiples, or earnings outlook.

Every claim is tagged with its source — that per-claim citation discipline is exactly what you want before anything with “investment” in the name goes in front of a client, and it’s a direct product of feeding Astra the full source material instead of a lossy summary of it.

Where This Fits (and Where It Doesn’t)

Reach for GPT-6 Astra when:

You need deliberate, multi-step planning and decision support — not a one-shot answer
The output needs to be polished enough for expert review: documents, reports, structured recommendations
You’re automating work through approved interfaces or systems without a clean API, with human checkpoints on consequential actions
Your scenario genuinely needs long-context reasoning across large documents, filings, or repositories

Don’t reach for it when:

You need a lightweight, low-latency conversational bot — that’s a better fit for a chat-tuned model like GPT-chat-latest
The task is narrow, single-shot classification or extraction with no planning component
You’re not ready to build the governance layer (approvals, scoped credentials, monitoring) that responsible agentic/computer-use workflows require — Foundry gives you the tools, but you still have to configure and own that boundary

Wrapping Up

GPT-6 Astra’s pitch isn’t “smarter chat” — it’s “does more of the actual work and hands you something finished.” For .NET developers, that shows up as agents that investigate before they conclude, reports that follow your template without babysitting, and workflows that act through your systems with a human still holding the approval button. Pair it with Foundry Agent Service so that autonomy inherits identity, security, and lifecycle management rather than becoming its own liability — and it’s worth deploying gpt-6-astra next to whatever you’re running today and comparing the two side by side.

Resources

Source Code: https://github.com/taswar/GptSixAstraDemo
Astra Azure Blog
Model catalog

Building AI features in C#? I write about practical, no-hype prompt engineering and Azure AI patterns for .NET developers. Check out Prompt Engineering for .NET Developers — free, no Python required. Also subscribe to my mailing list for the latest blogs, tips and tricks I share.

Microsoft Foundry

.net, Agentic AI, Azure AI, C#, GPT-6 Astra, Microsoft Foundry, OpenAI, reasoning models

Grok 4.6 Is Now in Foundry — Here’s What It Means If You Write C#

Taswar Bhatti August 31, 2026 No Comments

Grok 4.6 — SpaceXAI’s latest frontier model — just landed in public preview in Microsoft Foundry as an Azure Direct Model. The headline isn’t “another big model dropped.” It’s that Grok 4.6 is built specifically for long-horizon, agentic work: planning across many steps, calling tools reliably, recovering when something goes wrong, and handing you a finished work product instead of a half-baked fragment you have to stitch together yourself.

That’s a meaningfully different design target than “answer this one prompt well.” And it’s exactly the kind of thing that matters once you move past demos and start building agents that actually have to survive contact with real workloads.

As always: no Python required, no notebook required. Just Microsoft.Extensions.AI and dotnet run.

What Grok 4.6 Actually Is

A few things worth knowing before you touch any code:

Frontier reasoning at value pricing. Grok 4.6 is positioned as the value-tier frontier option — frontier-class reasoning at a materially lower cost per task than comparable models. That matters the moment “reasoning agent” stops being a one-off demo and becomes something running continuously in production.
Selectable reasoning effort. You choose reasoning depth per call — low, medium, high, or xhigh (default high) — instead of paying maximum-reasoning cost on every single request regardless of whether the task needs it.
Long-horizon agentic execution. It’s designed to sustain complex, multi-step work — planning, tool calls, error recovery, and self-verification — with limited human babysitting.
Multimodal input. Text and images, so document-heavy, diagram-heavy, and screenshot-heavy workflows don’t need a bolted-on separate vision pipeline.
200K token context window at launch. Solid for most agentic and document-analysis workloads — just set expectations up front if your scenario needs more.
Still preview. Validate against your own prompts, tools, and safety thresholds before anything production-sensitive touches it.

Why This Matters for .NET Developers Specifically

The use cases Microsoft is calling out map directly onto real .NET workloads:

Long-running agents — multi-tool orchestration with error recovery and planning, not a single tool call and done
Software engineering — multi-stage coding sessions, large refactors, and debugging across a real repository, not a single isolated function
Research and analysis — synthesizing dense source material into structured, decision-ready output
Enterprise knowledge work — drafting full documents, reports, and deliverables end to end, not just paragraph stubs

And it slots into Foundry the same way every other model does — same IChatClient abstraction, same deployment pattern. Swapping in Grok 4.6 next to GPT-4o or MAI-Thinking-1 in your evaluation pipeline is a config change, not a rewrite.

Getting Started

dotnet new console -n Grok46MSFoundryDemo
cd Grok46MSFoundryDemo
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet add package Microsoft.Extensions.AI.OpenAI
dotnet user-secrets init
dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

dotnet new console -n Grok46MSFoundryDemo

cd Grok46MSFoundryDemo

dotnet add package Azure.AI.OpenAI

dotnet add package Microsoft.Extensions.AI

dotnet add package Azure.Identity

dotnet add package Microsoft.Extensions.Configuration.UserSecrets

dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables

dotnet add package Microsoft.Extensions.AI.OpenAI

dotnet user-secrets init

dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

Deploy grok-4.6 from the Foundry Model Catalog (currently Global Standard deployment only) to your Foundry project, same as any other model. Grab your endpoint and deployment name.

Use Case 1: Long-Horizon Agent with Tool Calling and Selectable Reasoning Effort

Let’s build the thing Grok 4.6 is actually designed for: an agent that plans across multiple tool calls instead of answering from a single shot. Here’s a small deployment-readiness agent that checks a service’s health, checks its recent error rate, and only then decides whether it’s safe to proceed with a deploy — reasoning through the combination rather than just checking one signal in isolation.

using Azure.Identity;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using OpenAI;
using System.ClientModel.Primitives;
using System.ComponentModel;
using OpenAIChatClient = OpenAI.Chat.ChatClient;

#pragma warning disable OPENAI001

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();
 
var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "grok-4.6";
var endpoint = config["AZURE_AI_ENDPOINT"]
    ?? throw new InvalidOperationException(
        "AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint-e.g.-https://<resource>.services.ai.azure.com/models>\"");

// Grok is a partner (MaaS) model, not a native Azure OpenAI deployment, so it can't be
// reached through AzureOpenAIClient's /openai/deployments/... path. Use the generic
// OpenAI ChatClient against the Foundry model endpoint instead (mirrors Grok4.3 sample).
BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

var clientOptions = new OpenAIClientOptions { Endpoint = new Uri(endpoint) };
clientOptions.AddPolicy(new ApiVersionPolicy("2024-05-01-preview"), PipelinePosition.PerCall);

OpenAIChatClient openAiChatClient = new(
    model: deploymentName,
    authenticationPolicy: tokenPolicy,
    options: clientOptions);

IChatClient chatClient = openAiChatClient
    .AsIChatClient()
    .AsBuilder()
    .UseFunctionInvocation()
    .Build();

var chatOptions = new ChatOptions
{
    Tools =
    [
        AIFunctionFactory.Create(GetServiceHealth),
        AIFunctionFactory.Create(GetRecentErrorRate)
    ],
    // Reasoning effort tuned for a multi-step decision — not maximum, not minimal.
    AdditionalProperties = new AdditionalPropertiesDictionary
    {
        ["reasoning_effort"] = "high" // low | medium | high | xhigh
    }
};

var messages = new List<ChatMessage>
{
    new(ChatRole.System,
        "You are a deployment safety agent. Before recommending a deploy, check both " +
        "service health and recent error rate. Reason about both signals together before " +
        "concluding — do not approve a deploy based on a single check alone."),
    new(ChatRole.User, "Is it safe to deploy service 'checkout-api' right now?")
};
 
var response = await chatClient.GetResponseAsync(messages, chatOptions);
Console.WriteLine(response.Text);
 
// --- Tool stand-ins for a real monitoring/ops API ---
 
[Description("Gets the current health status of a named service.")]
static string GetServiceHealth(
    [Description("The service name, e.g. checkout-api")] string serviceName)
{
    return serviceName switch
    {
        "checkout-api" => "Healthy. All instances passing readiness checks.",
        _ => "Unknown service."
    };
}
 
[Description("Gets the error rate for a named service over the last hour.")]
static string GetRecentErrorRate(
    [Description("The service name, e.g. checkout-api")] string serviceName)
{
    return serviceName switch
    {
        "checkout-api" => "Error rate: 4.2% over the last hour (baseline: 0.3%). Elevated.",
        _ => "No data available."
    };
}

/// <summary>Pipeline policy that appends api-version as a query parameter to every request.</summary>
class ApiVersionPolicy(string apiVersion) : PipelinePolicy
{
    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        AppendApiVersion(message);
        ProcessNext(message, pipeline, currentIndex);
    }

    public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        AppendApiVersion(message);
        await ProcessNextAsync(message, pipeline, currentIndex);
    }

    private void AppendApiVersion(PipelineMessage message)
    {
        var url = message.Request.Uri!.ToString();
        var separator = url.Contains('?') ? "&" : "?";
        message.Request.Uri = new Uri($"{url}{separator}api-version={apiVersion}");
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

using Azure.Identity;

using Microsoft.Extensions.AI;

using Microsoft.Extensions.Configuration;

using OpenAI;

using System.ClientModel.Primitives;

using System.ComponentModel;

using OpenAIChatClient = OpenAI.Chat.ChatClient;

#pragma warning disable OPENAI001

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "grok-4.6";

var endpoint = config["AZURE_AI_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint-e.g.-https://<resource>.services.ai.azure.com/models>\"");

// Grok is a partner (MaaS) model, not a native Azure OpenAI deployment, so it can't be

// reached through AzureOpenAIClient's /openai/deployments/... path. Use the generic

// OpenAI ChatClient against the Foundry model endpoint instead (mirrors Grok4.3 sample).

BearerTokenPolicy tokenPolicy = new(

new DefaultAzureCredential(),

"https://ai.azure.com/.default");

var clientOptions = new OpenAIClientOptions { Endpoint = new Uri(endpoint) };

clientOptions.AddPolicy(new ApiVersionPolicy("2024-05-01-preview"), PipelinePosition.PerCall);

OpenAIChatClient openAiChatClient = new(

model: deploymentName,

authenticationPolicy: tokenPolicy,

options: clientOptions);

IChatClient chatClient = openAiChatClient

.AsIChatClient()

.AsBuilder()

.UseFunctionInvocation()

.Build();

var chatOptions = new ChatOptions

{

Tools =

[

AIFunctionFactory.Create(GetServiceHealth),

AIFunctionFactory.Create(GetRecentErrorRate)

// Reasoning effort tuned for a multi-step decision — not maximum, not minimal.

AdditionalProperties = new AdditionalPropertiesDictionary

{

["reasoning_effort"] = "high" // low | medium | high | xhigh

}

};

var messages = new List<ChatMessage>

{

new(ChatRole.System,

"You are a deployment safety agent. Before recommending a deploy, check both " +

"service health and recent error rate. Reason about both signals together before " +

"concluding — do not approve a deploy based on a single check alone."),

new(ChatRole.User, "Is it safe to deploy service 'checkout-api' right now?")

};

var response = await chatClient.GetResponseAsync(messages, chatOptions);

Console.WriteLine(response.Text);

// --- Tool stand-ins for a real monitoring/ops API ---

[Description("Gets the current health status of a named service.")]

static string GetServiceHealth(

[Description("The service name, e.g. checkout-api")] string serviceName)

{

return serviceName switch

{

"checkout-api" => "Healthy. All instances passing readiness checks.",

_ => "Unknown service."

};

}

[Description("Gets the error rate for a named service over the last hour.")]

static string GetRecentErrorRate(

[Description("The service name, e.g. checkout-api")] string serviceName)

{

return serviceName switch

{

"checkout-api" => "Error rate: 4.2% over the last hour (baseline: 0.3%). Elevated.",

_ => "No data available."

};

}

/// <summary>Pipeline policy that appends api-version as a query parameter to every request.</summary>

class ApiVersionPolicy(string apiVersion) : PipelinePolicy

{

public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)

{

AppendApiVersion(message);

ProcessNext(message, pipeline, currentIndex);

}

public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)

{

AppendApiVersion(message);

await ProcessNextAsync(message, pipeline, currentIndex);

}

private void AppendApiVersion(PipelineMessage message)

{

var url = message.Request.Uri!.ToString();

var separator = url.Contains('?') ? "&" : "?";

message.Request.Uri = new Uri($"{url}{separator}api-version={apiVersion}");

}

Case 1 – Output

**No — do not deploy `checkout-api` right now.**

- **Health:** Healthy (all instances passing readiness checks).
- **Error rate:** Elevated at 4.2% over the last hour vs. 0.3% baseline.

The current health check looks fine, but the error rate is an order of magnitude above baseline. Deploying while errors are already elevated risks amplifying an existing problem. Wait until the error rate returns closer to baseline (and re-check both signals) before proceeding.

**No — do not deploy `checkout-api` right now.**

- **Health:** Healthy (all instances passing readiness checks).

- **Error rate:** Elevated at 4.2% over the last hour vs. 0.3% baseline.

The current health check looks fine, but the error rate is an order of magnitude above baseline. Deploying while errors are already elevated risks amplifying an existing problem. Wait until the error rate returns closer to baseline (and re-check both signals) before proceeding.

Notice the agent has to combine two tool results before it can reason to an answer — a healthy service with a spiking error rate is exactly the kind of situation where a single-signal check would give you a false “all clear.” That’s the long-horizon, multi-step reasoning Grok 4.6 is built for, not a gimmick.

Use Case 2: Software Engineering — Multi-Stage Code Review Across a Repository

The second headline use case is software engineering: multi-stage coding sessions and debugging across complex repositories, not a single isolated snippet. Here’s a pattern for feeding Grok 4.6 multiple related files and asking it to reason about the change as a whole, not file by file.

var interfaceFile = """
    public interface IOrderRepository
    {
        Task&lt;Order?&gt; GetByIdAsync(Guid orderId);
        Task SaveAsync(Order order);
    }
    """;
 
var implementationFile = """
    public class OrderRepository : IOrderRepository
    {
        private readonly AppDbContext _db;
        public OrderRepository(AppDbContext db) => _db = db;
 
        public async Task&lt;Order?&gt; GetByIdAsync(Guid orderId)
            => await _db.Orders.FindAsync(orderId);
 
        public async Task SaveAsync(Order order)
        {
            _db.Orders.Update(order);
            await _db.SaveChangesAsync();
        }
    }
    """;
 
var callerFile = """
    public class OrderService
    {
        private readonly IOrderRepository _repo;
        public OrderService(IOrderRepository repo) => _repo = repo;
 
        public async Task CancelOrderAsync(Guid orderId)
        {
            var order = await _repo.GetByIdAsync(orderId);
            order.Status = OrderStatus.Cancelled; // no null check
            await _repo.SaveAsync(order);
        }
    }
    """;
 
var systemPrompt = """
    You are a senior .NET code reviewer. You'll be given multiple related files from
    the same change set. Review them together, not in isolation — flag issues that only
    become visible when you consider how the files interact (e.g. a nullable return type
    being used without a null check downstream). Be direct and specific about severity.
    """;
 
var messagesMulti = new List<ChatMessage>
{
    new(ChatRole.System, systemPrompt),
    new(ChatRole.User, $"""
        Review this change set:
 
        --- IOrderRepository.cs ---
        {interfaceFile}
 
        --- OrderRepository.cs ---
        {implementationFile}
 
        --- OrderService.cs ---
        {callerFile}
        """)
};
 
var responseMulti = await chatClient.GetResponseAsync(messagesMulti);
Console.WriteLine(responseMulti.Text);

var interfaceFile = """

public interface IOrderRepository

{

Task<Order?> GetByIdAsync(Guid orderId);

Task SaveAsync(Order order);

}

""";

var implementationFile = """

public class OrderRepository : IOrderRepository

{

private readonly AppDbContext _db;

public OrderRepository(AppDbContext db) => _db = db;

public async Task<Order?> GetByIdAsync(Guid orderId)

=> await _db.Orders.FindAsync(orderId);

public async Task SaveAsync(Order order)

{

_db.Orders.Update(order);

await _db.SaveChangesAsync();

}

""";

var callerFile = """

public class OrderService

{

private readonly IOrderRepository _repo;

public OrderService(IOrderRepository repo) => _repo = repo;

public async Task CancelOrderAsync(Guid orderId)

{

var order = await _repo.GetByIdAsync(orderId);

order.Status = OrderStatus.Cancelled; // no null check

await _repo.SaveAsync(order);

}

""";

var systemPrompt = """

You are a senior .NET code reviewer. You'll be given multiple related files from

the same change set. Review them together, not in isolation — flag issues that only

become visible when you consider how the files interact (e.g. a nullable return type

being used without a null check downstream). Be direct and specific about severity.

""";

var messagesMulti = new List<ChatMessage>

{

new(ChatRole.System, systemPrompt),

new(ChatRole.User, $"""

Review this change set:

--- IOrderRepository.cs ---

{interfaceFile}

--- OrderRepository.cs ---

{implementationFile}

--- OrderService.cs ---

{callerFile}

""")

};

var responseMulti = await chatClient.GetResponseAsync(messagesMulti);

Console.WriteLine(responseMulti.Text);

Case 2 Output

## Cross-file review

The real bug here is a **contract lie** between the three files. It is not visible in any one of them in isolation.

### Critical: `GetByIdAsync` can return null, but nothing admits it

`DbSet<T>.FindAsync` returns `T?`. The repository still types the method as `Task<Order>`:

```csharp
public async Task<Order> GetByIdAsync(Guid orderId)
    => await _db.Orders.FindAsync(orderId);
```

The interface repeats that lie:

```csharp
Task<Order> GetByIdAsync(Guid orderId);
```

`OrderService` then trusts it:

```csharp
var order = await _repo.GetByIdAsync(orderId);
order.Status = OrderStatus.Cancelled; // NRE if missing
await _repo.SaveAsync(order);
```

Missing order → `NullReferenceException` at the assignment, or a worse failure inside `Update`/`SaveChanges` if the NRE is somehow avoided. With NRTs on, this should not compile without a warning at the repository; the warning is being swallowed by the non-nullable signature, so the service never sees it.

**Fix the contract, then the callers.** Do not paper over it with a `!`.

```csharp
Task<Order?> GetByIdAsync(Guid orderId);
```

```csharp
public async Task CancelOrderAsync(Guid orderId)
{
    var order = await _repo.GetByIdAsync(orderId)
        ?? throw new InvalidOperationException($"Order {orderId} was not found.");

    order.Status = OrderStatus.Cancelled;
    await _repo.SaveAsync(order);
}
```

Prefer a domain-specific not-found exception (or `Results.NotFound()` at the API edge) over a generic one. The point is: **absence is a first-class outcome**, not a crash.

If “must exist” is actually the invariant, keep `Task<Order>` but make the repository throw (e.g. `FindAsync` + throw, or `SingleAsync`). Do not return null behind a non-nullable type.

---

### High: `Update` on an already-tracked entity

`FindAsync` attaches the entity (unless you changed the default tracker). `SaveAsync` then does:

```csharp
_db.Orders.Update(order);
await _db.SaveChangesAsync();
```

`Update` marks **all** properties modified. That is the detached-entity API. On a tracked instance it is redundant and harmful:

- Extra UPDATE columns you did not change
- Overwrites of concurrent edits to other fields
- Surprising behavior if anyone later passes a detached or new `Order`

After a tracked load, mutate and `SaveChangesAsync()`. If the repository must support detached graphs, branch on `_db.Entry(order).State`.

Also: no concurrency token (`xmin` / `RowVersion`). Two `CancelOrderAsync` calls, or cancel vs. another status change, last-write-wins with no conflict.

---

### Medium: cancel has no domain guard

`order.Status = OrderStatus.Cancelled` is a field poke, not a transition.

Together with the null hole, any id “cancels.” You likely also want to reject already-shipped / already-cancelled / unpaid-invalid states. That belongs on `Order` (`order.Cancel()`), not in the service, so the repository cannot persist an illegal status even if another caller appears.

---

### Low (still worth fixing in this changeset)

- No `CancellationToken` on any of the three async methods. Once this is on a request path, you cannot abort the EF round-trip.
- `GetByIdAsync` has no `AsNoTracking` decision. Fine if you always mutate; wrong if this repo is reused for reads.
- Interface + impl + service all assume a live `AppDbContext` scope. If `OrderService` is longer-lived than the context, this blows up at runtime — not shown here, but the `Update` pattern makes that failure mode worse.

---

### What I would require before merge

1. `Task<Order?>` **or** throw-on-miss in the repository — pick one, align interface, impl, and service.
2. Null/not-found handling in `CancelOrderAsync`.
3. Drop `Update` for this tracked path; `SaveChangesAsync` only.
4. Optional but strongly recommended: `order.Cancel()` with explicit illegal-transition errors, and a concurrency token.

The nullability mismatch is the merge-blocker. Everything else is how this will fail in production after the NRE is fixed.

## Cross-file review

The real bug here is a **contract lie** between the three files. It is not visible in any one of them in isolation.

### Critical: `GetByIdAsync` can return null, but nothing admits it

`DbSet<T>.FindAsync` returns `T?`. The repository still types the method as `Task<Order>`:

```csharp

public async Task<Order> GetByIdAsync(Guid orderId)

=> await _db.Orders.FindAsync(orderId);

```

The interface repeats that lie:

```csharp

Task<Order> GetByIdAsync(Guid orderId);

```

`OrderService` then trusts it:

```csharp

var order = await _repo.GetByIdAsync(orderId);

order.Status = OrderStatus.Cancelled; // NRE if missing

await _repo.SaveAsync(order);

```

Missing order → `NullReferenceException` at the assignment, or a worse failure inside `Update`/`SaveChanges` if the NRE is somehow avoided. With NRTs on, this should not compile without a warning at the repository; the warning is being swallowed by the non-nullable signature, so the service never sees it.

**Fix the contract, then the callers.** Do not paper over it with a `!`.

```csharp

Task<Order?> GetByIdAsync(Guid orderId);

```

```csharp

public async Task CancelOrderAsync(Guid orderId)

{

var order = await _repo.GetByIdAsync(orderId)

?? throw new InvalidOperationException($"Order {orderId} was not found.");

order.Status = OrderStatus.Cancelled;

await _repo.SaveAsync(order);

}

```

Prefer a domain-specific not-found exception (or `Results.NotFound()` at the API edge) over a generic one. The point is: **absence is a first-class outcome**, not a crash.

If “must exist” is actually the invariant, keep `Task<Order>` but make the repository throw (e.g. `FindAsync` + throw, or `SingleAsync`). Do not return null behind a non-nullable type.

---

### High: `Update` on an already-tracked entity

`FindAsync` attaches the entity (unless you changed the default tracker). `SaveAsync` then does:

```csharp

_db.Orders.Update(order);

await _db.SaveChangesAsync();

```

`Update` marks **all** properties modified. That is the detached-entity API. On a tracked instance it is redundant and harmful:

- Extra UPDATE columns you did not change

- Overwrites of concurrent edits to other fields

- Surprising behavior if anyone later passes a detached or new `Order`

After a tracked load, mutate and `SaveChangesAsync()`. If the repository must support detached graphs, branch on `_db.Entry(order).State`.

Also: no concurrency token (`xmin` / `RowVersion`). Two `CancelOrderAsync` calls, or cancel vs. another status change, last-write-wins with no conflict.

---

### Medium: cancel has no domain guard

`order.Status = OrderStatus.Cancelled` is a field poke, not a transition.

Together with the null hole, any id “cancels.” You likely also want to reject already-shipped / already-cancelled / unpaid-invalid states. That belongs on `Order` (`order.Cancel()`), not in the service, so the repository cannot persist an illegal status even if another caller appears.

---

### Low (still worth fixing in this changeset)

- No `CancellationToken` on any of the three async methods. Once this is on a request path, you cannot abort the EF round-trip.

- `GetByIdAsync` has no `AsNoTracking` decision. Fine if you always mutate; wrong if this repo is reused for reads.

- Interface + impl + service all assume a live `AppDbContext` scope. If `OrderService` is longer-lived than the context, this blows up at runtime — not shown here, but the `Update` pattern makes that failure mode worse.

---

### What I would require before merge

1. `Task<Order?>` **or** throw-on-miss in the repository — pick one, align interface, impl, and service.

2. Null/not-found handling in `CancelOrderAsync`.

3. Drop `Update` for this tracked path; `SaveChangesAsync` only.

4. Optional but strongly recommended: `order.Cancel()` with explicit illegal-transition errors, and a concurrency token.

The nullability mismatch is the merge-blocker. Everything else is how this will fail in production after the NRE is fixed.

The interesting part isn’t reviewing one file — any model can do that. It’s reasoning across files: GetByIdAsync returns Order?, and the caller in OrderService uses it without a null check. That’s a cross-file bug a naive single-file review would miss entirely.

Use Case 3: Research and Analysis — Structured, Decision-Ready Output

Grok 4.6 is also positioned for turning dense source material into structured output you can actually hand to someone. Here’s a pattern using strongly-typed structured output instead of hoping the model formats things consistently.

var sourceMaterial = """
    Q3 vendor evaluation notes:
    Vendor A: $42/user/month, 99.95% uptime SLA, no SOC 2 report available yet,
    onboarding takes ~6 weeks, strong API docs.
    Vendor B: $58/user/month, 99.99% uptime SLA, SOC 2 Type II certified,
    onboarding takes ~2 weeks, API docs are sparse.
    """;
 
var messagesRA = new List<ChatMessage>
{
    new(ChatRole.System,
        "Synthesize the provided source material into a structured, decision-ready " +
        "recommendation. Output valid JSON matching the requested schema only."),
    new(ChatRole.User, $"Analyze this vendor comparison and recommend one:\n\n{sourceMaterial}")
};
 
var chatOptionsRA = new ChatOptions
{
    ResponseFormat = ChatResponseFormat.ForJsonSchema<VendorRecommendation>() 
};
 
var responseRA = await chatClient.GetResponseAsync(messagesRA, chatOptionsRA);
var recommendation = JsonSerializer.Deserialize<VendorRecommendation>(responseRA.Text);
 
Console.WriteLine($"Recommended: {recommendation?.RecommendedVendor}");
Console.WriteLine($"Reasoning: {recommendation?.Reasoning}");
Console.WriteLine($"Key risk: {recommendation?.KeyRisk}");
 

record VendorRecommendation(
    [property: JsonPropertyName("recommended_vendor")] string RecommendedVendor,
    [property: JsonPropertyName("reasoning")] string Reasoning,
    [property: JsonPropertyName("key_risk")] string KeyRisk
);

var sourceMaterial = """

Q3 vendor evaluation notes:

Vendor A: $42/user/month, 99.95% uptime SLA, no SOC 2 report available yet,

onboarding takes ~6 weeks, strong API docs.

Vendor B: $58/user/month, 99.99% uptime SLA, SOC 2 Type II certified,

onboarding takes ~2 weeks, API docs are sparse.

""";

var messagesRA = new List<ChatMessage>

{

new(ChatRole.System,

"Synthesize the provided source material into a structured, decision-ready " +

"recommendation. Output valid JSON matching the requested schema only."),

new(ChatRole.User, $"Analyze this vendor comparison and recommend one:\n\n{sourceMaterial}")

};

var chatOptionsRA = new ChatOptions

{

ResponseFormat = ChatResponseFormat.ForJsonSchema<VendorRecommendation>()

};

var responseRA = await chatClient.GetResponseAsync(messagesRA, chatOptionsRA);

var recommendation = JsonSerializer.Deserialize<VendorRecommendation>(responseRA.Text);

Console.WriteLine($"Recommended: {recommendation?.RecommendedVendor}");

Console.WriteLine($"Reasoning: {recommendation?.Reasoning}");

Console.WriteLine($"Key risk: {recommendation?.KeyRisk}");

record VendorRecommendation(

[property: JsonPropertyName("recommended_vendor")] string RecommendedVendor,

[property: JsonPropertyName("reasoning")] string Reasoning,

[property: JsonPropertyName("key_risk")] string KeyRisk

);

Case 3 – Output

Recommended: Vendor B
Reasoning: Vendor B is the stronger overall choice for most enterprise deployments: SOC 2 Type II certification addresses a common compliance gate that Vendor A currently cannot, the 99.99% SLA and 2-week onboarding reduce operational and time-to-value risk, and the $16/user premium is justified by those factors. Sparse API docs are a manageable trade-off versus A's missing audit report and 6-week ramp.
Key risk: Sparse API documentation may increase integration effort, delay custom development, and raise long-term maintenance cost.

Recommended: Vendor B

Reasoning: Vendor B is the stronger overall choice for most enterprise deployments: SOC 2 Type II certification addresses a common compliance gate that Vendor A currently cannot, the 99.99% SLA and 2-week onboarding reduce operational and time-to-value risk, and the $16/user premium is justified by those factors. Sparse API docs are a manageable trade-off versus A's missing audit report and 6-week ramp.

Key risk: Sparse API documentation may increase integration effort, delay custom development, and raise long-term maintenance cost.

This is the difference between “the model wrote something that sounds like a recommendation” and “the model produced a typed object your application can actually act on” — route it to an approval workflow, log it, feed it into a dashboard, whatever your enterprise-knowledge-work pipeline actually needs downstream.

Use Case 4: Multimodal Input — Reviewing a Diagram or Screenshot

Since Grok 4.6 accepts text and images, document- and diagram-heavy workflows skip the separate vision pipeline entirely.

using Microsoft.Extensions.AI;

var diagramBytes = await File.ReadAllBytesAsync("architecture-diagram.png");

var message = new ChatMessage(ChatRole.User,
[
    new TextContent("Review this architecture diagram. Flag any single points of failure."),
    new DataContent(diagramBytes, "image/png")
]);

var response = await chatClient.GetResponseAsync([message]);
Console.WriteLine(response.Text);

using Microsoft.Extensions.AI;

var diagramBytes = await File.ReadAllBytesAsync("architecture-diagram.png");

var message = new ChatMessage(ChatRole.User,

[

new TextContent("Review this architecture diagram. Flag any single points of failure."),

new DataContent(diagramBytes, "image/png")

]);

var response = await chatClient.GetResponseAsync([message]);

Console.WriteLine(response.Text);

Case 4 – Output

**Single points of failure (and related HA gaps)**

The diagram is a single-region Azure architecture (the large “A” boundary) with a typical ingress → compute → data path, Entra ID, Key Vault, monitoring, and a CI/CD pipeline. Several components and the overall topology lack redundancy.

### Highest-impact SPOFs
- **Single Azure region.** Everything runtime lives in one region. A region-level outage (or even a prolonged zonal issue if services are not zone-redundant) takes the whole system down. There is no second region, no Azure Front Door / Traffic Manager failover pair, no geo-replicated data, and no active-active or active-passive pattern.
- **Azure SQL Database.** A single SQL instance is shown with no failover group, geo-replication, zone-redundant configuration, or Hyperscale mention. This is a classic data-plane SPOF. Azure Storage (the table icon) is more resilient by default (ZRS/GRS options exist) but is still regional and does not protect the relational data.
- **Ingress chain (Front Door / CDN → WAF → load balancer / Traffic Manager → API Management or equivalent).** These are drawn as a linear series of single icons. Front Door itself is globally distributed, but the backends, WAF policy, regional load balancer, and API Management instance are not shown as scaled-out, zone-redundant, or multi-region. A failure or misconfiguration in any hop can black-hole traffic.
- **Compute (API Management / AKS / App Service + chained Functions).** The three dashed compute boxes and the two sequential Functions imply a synchronous pipeline with no queue, Event Grid, or Service Bus decoupling. One Function or the hosting plan/cluster going down stops the flow. No multiple instances, Availability Zones, or Premium/Isolated SKUs with zone redundancy are indicated. A single AKS cluster or App Service plan is also a SPOF unless node pools / instances are spread across zones and (ideally) regions.

### Other notable single points / HA gaps
- **Azure Key Vault (shown in two places).** Regional service. Runtime secret/certificate retrieval without caching, retry, or a replica in another region can fail the app. Soft-delete + purge protection help with accidental deletion but not with regional unavailability.
- **No Availability Zones called out.** Even within the single region, most PaaS services (Functions, App Service, SQL, API Management, Firewall, etc.) can and should be zone-redundant. The diagram gives no indication this is configured, so a datacenter failure is a realistic outage.
- **Hybrid / on-premises dependency (building + connectivity icon on the right).** If any critical path (identity, data, or connectivity via ExpressRoute/VPN) depends on the on-premises side or a single circuit, that is an additional SPOF. Dual ExpressRoute circuits or VPN backup would be needed.
- **Azure Firewall (single instance shown).** Can be made zone-redundant, but a single firewall (or single policy) is a choke point for both north-south and any east-west traffic that transits it.
- **DNS.** Azure DNS itself is globally anycast and highly available. The risk is if records only point at the single-region endpoints with no Traffic Manager / Front Door health-probe failover, or if a custom DNS server is in the path.

### Components that are *not* SPOFs (or are relatively resilient)
- Microsoft Entra ID (global, highly available).
- Azure Monitor / Defender / management plane (shown on the right).
- The CI/CD pipeline (Azure DevOps / Pipelines / ACR-style icons at the bottom) is a deployment concern, not a runtime SPOF—unless the running application somehow depends on it remaining available.
- Serverless Functions and App Services *can* be made highly available, but the diagram does not show the required SKU, scaling, or zonal/multi-region setup.

### Recommendations (priority order)
1. Make the solution multi-region (active-passive with Front Door or Traffic Manager + SQL failover groups / Cosmos DB, or active-active). This addresses the biggest risk.
2. Enable zone redundancy on SQL, compute, API Management, Firewall, and Key Vault where the SKU supports it; add a second Key Vault + secret replication for DR.
3. Decouple the Function chain with queues/topics so a single Function failure does not halt everything; add retries, circuit breakers, and health endpoints.
4. Scale out and zone-redundant the ingress (multiple API Management units, Standard Load Balancer or Front Door backends in different zones/regions).
5. Confirm (or add) Availability Zones, GRS/ZRS storage, and managed identities to reduce Key Vault runtime dependency.
6. If hybrid connectivity is required, dual-circuit ExpressRoute + VPN failover.

The diagram is a reasonable starting point for a cloud-native app but currently has several classic single-region + single-instance data and compute SPOFs. The largest reliability gains come from multi-region + zone-redundant data and from breaking the synchronous Function chain.

**Single points of failure (and related HA gaps)**

The diagram is a single-region Azure architecture (the large “A” boundary) with a typical ingress → compute → data path, Entra ID, Key Vault, monitoring, and a CI/CD pipeline. Several components and the overall topology lack redundancy.

### Highest-impact SPOFs

- **Single Azure region.** Everything runtime lives in one region. A region-level outage (or even a prolonged zonal issue if services are not zone-redundant) takes the whole system down. There is no second region, no Azure Front Door / Traffic Manager failover pair, no geo-replicated data, and no active-active or active-passive pattern.

- **Azure SQL Database.** A single SQL instance is shown with no failover group, geo-replication, zone-redundant configuration, or Hyperscale mention. This is a classic data-plane SPOF. Azure Storage (the table icon) is more resilient by default (ZRS/GRS options exist) but is still regional and does not protect the relational data.

- **Ingress chain (Front Door / CDN → WAF → load balancer / Traffic Manager → API Management or equivalent).** These are drawn as a linear series of single icons. Front Door itself is globally distributed, but the backends, WAF policy, regional load balancer, and API Management instance are not shown as scaled-out, zone-redundant, or multi-region. A failure or misconfiguration in any hop can black-hole traffic.

- **Compute (API Management / AKS / App Service + chained Functions).** The three dashed compute boxes and the two sequential Functions imply a synchronous pipeline with no queue, Event Grid, or Service Bus decoupling. One Function or the hosting plan/cluster going down stops the flow. No multiple instances, Availability Zones, or Premium/Isolated SKUs with zone redundancy are indicated. A single AKS cluster or App Service plan is also a SPOF unless node pools / instances are spread across zones and (ideally) regions.

### Other notable single points / HA gaps

- **Azure Key Vault (shown in two places).** Regional service. Runtime secret/certificate retrieval without caching, retry, or a replica in another region can fail the app. Soft-delete + purge protection help with accidental deletion but not with regional unavailability.

- **No Availability Zones called out.** Even within the single region, most PaaS services (Functions, App Service, SQL, API Management, Firewall, etc.) can and should be zone-redundant. The diagram gives no indication this is configured, so a datacenter failure is a realistic outage.

- **Hybrid / on-premises dependency (building + connectivity icon on the right).** If any critical path (identity, data, or connectivity via ExpressRoute/VPN) depends on the on-premises side or a single circuit, that is an additional SPOF. Dual ExpressRoute circuits or VPN backup would be needed.

- **Azure Firewall (single instance shown).** Can be made zone-redundant, but a single firewall (or single policy) is a choke point for both north-south and any east-west traffic that transits it.

- **DNS.** Azure DNS itself is globally anycast and highly available. The risk is if records only point at the single-region endpoints with no Traffic Manager / Front Door health-probe failover, or if a custom DNS server is in the path.

### Components that are *not* SPOFs (or are relatively resilient)

- Microsoft Entra ID (global, highly available).

- Azure Monitor / Defender / management plane (shown on the right).

- The CI/CD pipeline (Azure DevOps / Pipelines / ACR-style icons at the bottom) is a deployment concern, not a runtime SPOF—unless the running application somehow depends on it remaining available.

- Serverless Functions and App Services *can* be made highly available, but the diagram does not show the required SKU, scaling, or zonal/multi-region setup.

### Recommendations (priority order)

1. Make the solution multi-region (active-passive with Front Door or Traffic Manager + SQL failover groups / Cosmos DB, or active-active). This addresses the biggest risk.

2. Enable zone redundancy on SQL, compute, API Management, Firewall, and Key Vault where the SKU supports it; add a second Key Vault + secret replication for DR.

3. Decouple the Function chain with queues/topics so a single Function failure does not halt everything; add retries, circuit breakers, and health endpoints.

4. Scale out and zone-redundant the ingress (multiple API Management units, Standard Load Balancer or Front Door backends in different zones/regions).

5. Confirm (or add) Availability Zones, GRS/ZRS storage, and managed identities to reduce Key Vault runtime dependency.

6. If hybrid connectivity is required, dual-circuit ExpressRoute + VPN failover.

The diagram is a reasonable starting point for a cloud-native app but currently has several classic single-region + single-instance data and compute SPOFs. The largest reliability gains come from multi-region + zone-redundant data and from breaking the synchronous Function chain.

Same IChatClient, same message pattern as every text-only example above — you’re just adding a DataContent alongside the TextContent.

Where This Fits (and Where It Doesn’t)

Reach for Grok 4.6 when:

You’re building agents that need to plan, call multiple tools, recover from errors, and run with limited human oversight
You’re doing large, multi-file refactors or debugging that require reasoning across a whole change set, not one file at a time
You need frontier-class reasoning at high volume, where cost per task actually matters
Your workload benefits from tunable reasoning effort instead of paying maximum cost on every call

Don’t reach for it when:

Your context needs meaningfully exceed 200K tokens — qualify that requirement up front
The task is a simple, low-latency single-shot response where low effort on a cheaper model is a better fit
You need a production SLA today — it’s still preview, so validate against your own prompts, tools, and safety thresholds first

Wrapping Up

Grok 4.6 in Foundry isn’t another “yet another model” announcement — it’s a genuine value-tier option for the agentic, long-horizon work that’s increasingly what “building with AI” actually means once you’re past the demo stage. Selectable reasoning effort means you’re not stuck overpaying for depth you don’t need on every call, and the fact that it drops into the same IChatClient abstraction as everything else in Foundry means adding it to your evaluation lineup costs you an afternoon, not a rewrite.

Source code at: https://github.com/taswar/Grok46MSFoundryDemo

Microsoft Foundry

.net, Agentic AI, Azure AI, C#, Grok 4.6, LLM, Microsoft Foundry, Microsoft.Extensions.AI, xAI

7 Highlights Thursday | 27th August 2026 (#121 Edition) Bonus

Taswar Bhatti August 27, 2026 No Comments

This is the bonus content for the #121 edition of 5 Highlights Thursday — 7 highlights this week instead of 5. If you haven’t seen the main newsletter yet, check it out on LinkedIn.

1. Improving Performance in .NET Applications

Watch this video on YouTube

A deep dive into performance improvement techniques for .NET applications — covering profiling, benchmarking, and optimization strategies that matter for production .NET workloads.

2. Stop Writing Prompts. Start Writing Specs.

Watch this video on YouTube

A reframing of how to work with AI coding tools: instead of ad-hoc prompts, write structured specifications that give AI agents the context they need to produce consistently better results.

3. What’s New in Azure Firewall? | Latest Updates for Smarter Network Security

Watch this video on YouTube

A walkthrough of the latest Azure Firewall updates — covering new features and improvements that make network security smarter and easier to manage for teams protecting Azure-hosted workloads.

4. Build Reusable Copilot Workflows with Skills and Agents

Watch this video on YouTube

How to build reusable, composable workflows in GitHub Copilot using skills and agents — a practical look at making AI coding assistance scale across your team and projects.

5. Build Intelligent Agents with Work IQ, Foundry IQ, and Fabric IQ

Watch this video on YouTube

A walkthrough of building intelligent agents using the IQ platform stack — Work IQ for enterprise data tasks, Foundry IQ for AI model integration, and Fabric IQ for data and analytics workflows.

6. Optimizing GitHub Copilot: Better Results, Fewer Tokens

Watch this video on YouTube

Practical guidance on getting more out of GitHub Copilot by writing better context, reducing token waste, and structuring prompts so the model produces tighter, more accurate results.

7. Modern WinForms Development: How AI is Reshaping Your Approach

Watch this video on YouTube

A look at how AI tools are changing WinForms development in 2026 — from AI-assisted code generation to modern patterns for working with legacy Windows Forms applications.

As always, please give me feedback on LinkedIn. Which bullet above is your favorite? What do you want more or less of? Other suggestions? Please let me know.

Download my Free Ebook Prompt Engineering for .NET Developers.

Last by not least, know someone who might be interested in this newsletter? Share it with them.

Have a wonderful Thursday 😉

Taswar

Newsletter

.net, AI Developer Tools, C#, Fabric IQ, Foundry IQ, GitHub Copilot, MAUI, Microsoft Developer, Model Context Protocol, WinForms, Work IQ

7 Highlights Thursday | 20th August 2026 (#120 Edition)

Taswar Bhatti August 20, 2026 No Comments

This is the bonus content for the #120 edition of 5 Highlights Thursday — 7 highlights this week instead of 5. If you haven’t seen the main newsletter yet, check it out on LinkedIn.

1. Everything You Need to Know About the Latest in C#

Watch this video on YouTube

A comprehensive walkthrough of what’s new in C# for 2026 — covering the latest language features and improvements relevant to .NET developers staying current with the platform.

2. Modernizing .NET Applications

Watch this video on YouTube

Practical guidance on modernizing existing .NET applications — covering the tools, patterns, and strategies available for bringing legacy .NET code into the current platform era, including GitHub Copilot-assisted upgrade paths.

3. Explore the Future of ASP.NET Core & Blazor in .NET 11

Watch this video on YouTube

A forward look at what’s coming in ASP.NET Core and Blazor in .NET 11 — covering new capabilities and the direction for server-side and client-side web development on the .NET platform.

4. SQL MCP Server: Bringing AI Agents to Your SQL Data

Watch this video on YouTube

How the SQL MCP Server makes your SQL Server databases accessible to AI agents through the Model Context Protocol — letting agents query, reason over, and act on structured data without bespoke integrations.

5. .NET Developer Productivity with AI

Watch this video on YouTube

How AI tooling — including GitHub Copilot and .NET AI Building Blocks — is being integrated into the everyday .NET developer workflow to accelerate coding, debugging, and app design tasks.

6. Building Intelligent .NET Applications: From AI Features to Production

Watch this video on YouTube

End-to-end guidance on integrating AI capabilities into .NET applications — from choosing the right AI features to wiring them into production-ready .NET apps with proper tooling and patterns.

7. What’s new in vector indexing for Microsoft SQL | Data Exposed

Watch this video on YouTube

An update on vector indexing improvements in Microsoft SQL for 2026 — relevant if you’re building semantic search or RAG applications that need to store and query embeddings at the database layer.

As always, please give me feedback on LinkedIn. Which bullet above is your favorite? What do you want more or less of? Other suggestions? Please let me know.

Download my Free Ebook Prompt Engineering for .NET Developers.

Last by not least, know someone who might be interested in this newsletter? Share it with them.

Subscribe to my newsletter

Have a wonderful Thursday 😉

Taswar

Newsletter, Uncategorized

.net, ASP.NET Core, Azure SQL, Blazor, C#, GitHub Copilot, Microsoft SQL, Model Context Protocol, Security Copilot, SQL Server, visual studio

GPT-5.6-Sol for C# Developers

Taswar Bhatti August 19, 2026 No Comments

Microsoft has a habit of quietly upgrading the model behind a stable endpoint name instead of forcing everyone to migrate to a new one. That’s exactly what just happened with GPT-chat-latest — it’s now built on GPT-5.6 Sol, and if you’re already pointing at GPT-chat-latest in Microsoft Foundry, you get the upgrade without touching a line of code.

If you’re not already using it, this is a good moment to start. Here’s what changed, why it matters, and — because I don’t do AI posts without something you can actually run — a working C# sample.

What Actually Changed

A few things worth knowing before you touch any code:

Same endpoint, better model underneath.. For gpt-5.6-sol You don’t select a new model name — you just get the improved behavior through the same integration path you already have.
More focused responses. Tighter formatting, more direct answers, and a clearer main recommendation instead of a wall of hedged possibilities.
Improved factual reliability. Fewer mistakes on the things that are easy to get subtly wrong — dates, numbers, sources, rules, and assumptions.
More consistent behavior. Whether the question is a one-liner or a genuinely deep multi-step task, the model handles both without feeling like two different personalities.
Multimodal by default. Text, image, and audio inputs with long-turn consistency — you’re not stuck bolting on a separate vision model for basic multimodal chat.

None of that is exotic. It’s the boring, unglamorous stuff that actually matters when you’re shipping a chatbot people rely on — not a demo you show once and never touch again.

Why This Matters for .NET Developers Specifically

If you’re building any of the following, this update is aimed at you:

Customer support and self-service bots — troubleshooting, product Q&A, multi-step processes grounded in your own knowledge base
Planning and knowledge-work assistants — breaking down objectives, reconciling constraints, producing briefs and recommendations
Multimodal conversational features — combining text and image context in a single chat flow
Retrieval-grounded assistants — multi-turn conversations that synthesize answers from documents you feed in, not just the model’s training data

And because it’s the exact same IChatClient interface you’re already using for GPT-4o, MAI-Thinking-1, or anything else in Foundry — there’s no new SDK, no new package, no new mental model. You point at the same deployment name and the improvements just show up.

Getting Started

dotnet new console -n GptChat-Sol-Demo
cd GptChat-Sol-Demo
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI
dotnet add package Azure.Identity
dotnet user-secrets init
dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

dotnet new console -n GptChat-Sol-Demo

cd GptChat-Sol-Demo

dotnet add package Azure.AI.OpenAI

dotnet add package Microsoft.Extensions.AI

dotnet add package Azure.Identity

dotnet user-secrets init

dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

Deploy gpt-5.6-sol from the Foundry Model Catalog to your project — same process as any other model. Grab your endpoint, and you’re ready to go.

A Multi-Turn, Retrieval-Grounded Support Assistant

Reasoning quality is nice, but the real test for a chat model is whether it holds context sensibly across a back-and-forth conversation, and whether it sticks to the facts you actually gave it instead of making something up. Let’s build a small support assistant that’s grounded in a product knowledge snippet, and push it through a multi-turn conversation.

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
 
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();
 
var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "gpt-5.6-sol";
var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]
    ?? throw new InvalidOperationException(
        "AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));
 
IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();
 
// This stands in for content you'd normally pull from a retrieval/RAG pipeline —
// a vector search hit, a support doc, a knowledge base article, etc.
var retrievedContext = """
    Product: Contoso Sync Pro (desktop client, v4.2)
    Known issue: Sync fails silently if the local cache exceeds 2GB.
    Fix: Settings > Storage > "Clear Local Cache", then restart the app.
    Note: Clearing the cache does not delete any cloud-stored files.
    """;
 
var systemPrompt = """
    You are a Contoso Sync Pro support assistant. Answer only using the
    provided knowledge context below. If the context doesn't cover the
    question, say so plainly instead of guessing. Keep answers direct,
    with the main recommendation clearly stated first.
 
    KNOWLEDGE CONTEXT:
    """ + retrievedContext;
 
var messages = new List<ChatMessage>
{
    new(ChatRole.System, systemPrompt)
};
 
// Turn 1
messages.Add(new ChatMessage(ChatRole.User, "My sync keeps failing and I don't get any error. What's going on?"));
var response1 = await chatClient.GetResponseAsync(messages);
Console.WriteLine($"Assistant: {response1.Text}\n");
messages.Add(new ChatMessage(ChatRole.Assistant, response1.Text));
 
// Turn 2 — a natural follow-up that depends on remembering turn 1
messages.Add(new ChatMessage(ChatRole.User, "Will I lose any files if I do that?"));
var response2 = await chatClient.GetResponseAsync(messages);
Console.WriteLine($"Assistant: {response2.Text}\n");
messages.Add(new ChatMessage(ChatRole.Assistant, response2.Text));
 
// Turn 3 — asking something outside the provided knowledge, to check it doesn't hallucinate
messages.Add(new ChatMessage(ChatRole.User, "Does this also work on the mobile app?"));
var response3 = await chatClient.GetResponseAsync(messages);
Console.WriteLine($"Assistant: {response3.Text}");

using Azure.AI.OpenAI;

using Azure.Identity;

using Microsoft.Extensions.AI;

using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "gpt-5.6-sol";

var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));

IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())

.GetChatClient(deploymentName)

.AsIChatClient();

// This stands in for content you'd normally pull from a retrieval/RAG pipeline —

// a vector search hit, a support doc, a knowledge base article, etc.

var retrievedContext = """

Product: Contoso Sync Pro (desktop client, v4.2)

Known issue: Sync fails silently if the local cache exceeds 2GB.

Fix: Settings > Storage > "Clear Local Cache", then restart the app.

Note: Clearing the cache does not delete any cloud-stored files.

""";

var systemPrompt = """

You are a Contoso Sync Pro support assistant. Answer only using the

provided knowledge context below. If the context doesn't cover the

question, say so plainly instead of guessing. Keep answers direct,

with the main recommendation clearly stated first.

KNOWLEDGE CONTEXT:

""" + retrievedContext;

var messages = new List<ChatMessage>

{

new(ChatRole.System, systemPrompt)

};

// Turn 1

messages.Add(new ChatMessage(ChatRole.User, "My sync keeps failing and I don't get any error. What's going on?"));

var response1 = await chatClient.GetResponseAsync(messages);

Console.WriteLine($"Assistant: {response1.Text}\n");

messages.Add(new ChatMessage(ChatRole.Assistant, response1.Text));

// Turn 2 — a natural follow-up that depends on remembering turn 1

messages.Add(new ChatMessage(ChatRole.User, "Will I lose any files if I do that?"));

var response2 = await chatClient.GetResponseAsync(messages);

Console.WriteLine($"Assistant: {response2.Text}\n");

messages.Add(new ChatMessage(ChatRole.Assistant, response2.Text));

// Turn 3 — asking something outside the provided knowledge, to check it doesn't hallucinate

messages.Add(new ChatMessage(ChatRole.User, "Does this also work on the mobile app?"));

var response3 = await chatClient.GetResponseAsync(messages);

Console.WriteLine($"Assistant: {response3.Text}");

Output

Assistant: Your local cache may have exceeded 2GB, which can cause sync to fail silently in Contoso Sync Pro v4.2.

Go to **Settings > Storage > Clear Local Cache**, then restart the app. This will not delete any cloud-stored files.

Assistant: No. Clearing the local cache does **not** delete any cloud-stored files. After clearing it, restart Contoso Sync Pro.

Assistant: The provided information only covers the **Contoso Sync Pro desktop client v4.2**. It doesn’t confirm whether this fix applies to the mobile app.

Assistant: Your local cache may have exceeded 2GB, which can cause sync to fail silently in Contoso Sync Pro v4.2.

Go to **Settings > Storage > Clear Local Cache**, then restart the app. This will not delete any cloud-stored files.

Assistant: No. Clearing the local cache does **not** delete any cloud-stored files. After clearing it, restart Contoso Sync Pro.

Assistant: The provided information only covers the **Contoso Sync Pro desktop client v4.2**. It doesn’t confirm whether this fix applies to the mobile app.

What I’m actually testing here: turn 2 depends on the model remembering what “that” refers to from turn 1 (clearing the cache), and turn 3 deliberately asks something the knowledge context doesn’t cover — a model with improved factual reliability should say “I don’t have that information” instead of confidently inventing a mobile-app answer. That’s the difference between a chatbot people trust and one that quietly erodes trust one hallucinated answer at a time.

Multimodal Input: Text + Image in the Same Conversation

Gpt-5.6-sol handles multimodal input natively, which matters for support scenarios where a user just wants to send you a screenshot instead of describing an error message character by character.

using Microsoft.Extensions.AI;

var imageBytes = await File.ReadAllBytesAsync("error-screenshot.png");

var multimodalMessage = new ChatMessage(ChatRole.User,
[
    new TextContent("Here's the error I'm seeing. What does this mean and how do I fix it?"),
    new DataContent(imageBytes, "image/png")
]);

var messages = new List&lt;ChatMessage&gt;
{
    new(ChatRole.System, systemPrompt),
    multimodalMessage
};

var response = await chatClient.GetResponseAsync(messages);
Console.WriteLine(response.Text);

using Microsoft.Extensions.AI;

var imageBytes = await File.ReadAllBytesAsync("error-screenshot.png");

var multimodalMessage = new ChatMessage(ChatRole.User,

[

new TextContent("Here's the error I'm seeing. What does this mean and how do I fix it?"),

new DataContent(imageBytes, "image/png")

]);

var messages = new List<ChatMessage>

{

new(ChatRole.System, systemPrompt),

multimodalMessage

};

var response = await chatClient.GetResponseAsync(messages);

Console.WriteLine(response.Text);

Output

Now let's try a multimodal turn, where the user provides an image along with their question.

The message only indicates that the upload failed; the provided information doesn’t identify the exact cause.

If you’re using **Contoso Sync Pro desktop v4.2**, try the known fix:

1. Go to **Settings > Storage**.
2. Select **Clear Local Cache**.
3. Restart the app and retry.

This resolves failures caused by a local cache exceeding 2 GB. Clearing it will **not delete cloud-stored files**. The screenshot appears to be from a mobile app, which isn’t covered by the available support information.

Now let's try a multimodal turn, where the user provides an image along with their question.

The message only indicates that the upload failed; the provided information doesn’t identify the exact cause.

If you’re using **Contoso Sync Pro desktop v4.2**, try the known fix:

1. Go to **Settings > Storage**.

2. Select **Clear Local Cache**.

3. Restart the app and retry.

This resolves failures caused by a local cache exceeding 2 GB. Clearing it will **not delete cloud-stored files**. The screenshot appears to be from a mobile app, which isn’t covered by the available support information.

Same IChatClient, same message list pattern — you’re just adding a DataContent alongside your TextContent in the same ChatMessage. No separate vision API, no separate client to wire up.

Where This Fits (and Where It Doesn’t)

Reach for GPT-chat-latest when:

You’re building conversational, multi-turn experiences — support bots, internal assistants, sales enablement tools
You need retrieval-grounded answers that stick to the facts you provide, not the model’s general knowledge
You want multimodal input (text + image) without adding a separate model to your stack
You want model improvements over time without maintaining multiple endpoint names in your config

Don’t reach for it when:

You need deep, extended multi-step reasoning as the primary workload — that’s a better fit for a dedicated reasoning model
You’re doing narrow, single-shot classification or extraction with no conversational component
Audio input is core to your scenario and you need to validate current format/latency support against your specific requirements before committing

Wrapping Up

The best kind of model update is the one where you don’t have to do anything. GPT-chat-latest running on GPT-5.6 Sol is exactly that: same endpoint, same IChatClient code, better answers underneath. If you’re building support bots, planning assistants, or anything that leans on multi-turn conversation grounded in your own data, it’s worth pointing your existing integration at it and seeing the difference for yourself.

Source code at: https://github.com/taswar/GptChat-Sol-Demo

Microsoft Foundry

.net, Azure AI, C#, chatbots, GPT-5.6 Sol, LLM, Microsoft Foundry, Microsoft.Extensions.AI, multimodal AI

MAI-Thinking-1 Is Now in Foundry — Here’s What It Means If You Write C#

Taswar Bhatti August 14, 2026 No Comments

Every time Microsoft ships a new model into Foundry, I ask myself the same boring-but-important question: does this change anything for the way I actually write code? Most of the time the answer is “cool demo, doesn’t affect my day job.” This time it’s different.

MAI-Thinking-1 — Microsoft’s first reasoning model — just went into public preview in Microsoft Foundry. It’s not a chat model with a “think harder” flag bolted on. It’s built from the ground up for multi-step reasoning: the kind of work where the model has to plan, reconsider, call tools, and stitch together a long chain of context before it gives you an answer worth trusting.

If you’ve read anything else I’ve written, you know where this is going: no Python required, no notebook gymnastics, just Microsoft.Extensions.AI and a dotnet run.

What MAI-Thinking-1 Actually Is

A few things worth knowing before you touch any code:

Mixture-of-Experts (MoE) architecture. Instead of activating the entire model for every request, it only activates the parts it needs. Translation for us: you get reasoning depth without paying full-model compute cost on every call.
Trained from scratch, no distillation. Microsoft trained it on clean data rather than distilling from a third-party model — worth knowing if procurement ever asks “where did this model come from.”
Competitive on SWE-Bench Pro at a lower price point than other models in its weight class. Translation: it’s genuinely usable for coding-adjacent agent workloads, not just benchmark bragging rights.
Pricing: $2 per 1M input tokens, $8 per 1M output tokens through the Foundry Model Catalog. Cheap enough that “always-on reasoning agent” stops being a scary line item.

None of that matters if you can’t get it working in fifteen minutes, so let’s do that.

Why This Matters for .NET Developers Specifically

Most “reasoning model” content is written for people gluing together Python scripts and LangChain. That’s not how most of us ship software. If you’re building:

Agents that call tools — CRM lookups, ERP queries, ticketing systems — and need to reason across the results before responding
Long-document analysis — contracts, filings, transcripts — where the model needs to hold context and reason step-by-step instead of pattern-matching a summary
Decision-support features — root-cause analysis, recommendation generation, anything where “just guess the most likely next token” isn’t good enough

MAI-Thinking-1 is aimed squarely at you, and it slots into the same IChatClient interface you’re already using for GPT-4o or any other Foundry model. Swapping models is a config change, not a rewrite.

Getting Started: The Boring Setup Part

dotnet new console -n MaiThinkingDemo
cd MaiThinkingDemo
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI
dotnet add package Azure.Identity

dotnet user-secrets init
dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

dotnet new console -n MaiThinkingDemo

cd MaiThinkingDemo

dotnet add package Azure.AI.OpenAI

dotnet add package Microsoft.Extensions.AI

dotnet add package Azure.Identity

dotnet user-secrets init

dotnet user-secrets set "AZURE_AI_ENDPOINT" "https://your-resource.services.ai.azure.com"

Deploy MAI-Thinking-1 from the Foundry Model Catalog to your Foundry project, same as you would any other model. Grab your endpoint and deployment name.

A Multi-Step Reasoning Example

Here’s the thing about reasoning models: the interesting part isn’t a single prompt/response, it’s giving the model something that actually requires reasoning across steps. Let’s build a small “contract risk triage” service — the kind of long-document, multi-step reasoning task MAI-Thinking-1 is designed for.

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "mai-thinking-1";
var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]
    ?? throw new InvalidOperationException(
        "AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));

IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();


var systemPrompt = """
    You are a contract risk analyst. When given a contract excerpt, you must:
    1. Identify every clause that creates financial or legal risk.
    2. Reason step-by-step about *why* each clause is risky before concluding.
    3. Rank the risks by severity (High / Medium / Low).
    4. Output a final structured summary — do not skip the reasoning steps.
    """;

var contractExcerpt = """
    Section 9.2: Client may terminate this Agreement for convenience with 5 days'
    written notice. Vendor shall be entitled to fees for Services rendered through
    the termination date only, with no early-termination compensation.

    Section 11.4: Vendor's total liability under this Agreement shall not exceed
    the total fees paid in the preceding twelve (12) months, except in cases of
    gross negligence, in which liability is uncapped.
    """;

var messages = new List<ChatMessage>
{
    new(ChatRole.System, systemPrompt),
    new(ChatRole.User, $"Analyze this contract excerpt:\n\n{contractExcerpt}")
};

var response = await chatClient.GetResponseAsync(messages);

Console.WriteLine(response.Text);

using Azure.AI.OpenAI;

using Azure.Identity;

using Microsoft.Extensions.AI;

using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "mai-thinking-1";

var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));

IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())

.GetChatClient(deploymentName)

.AsIChatClient();

var systemPrompt = """

You are a contract risk analyst. When given a contract excerpt, you must:

1. Identify every clause that creates financial or legal risk.

2. Reason step-by-step about *why* each clause is risky before concluding.

3. Rank the risks by severity (High / Medium / Low).

4. Output a final structured summary — do not skip the reasoning steps.

""";

var contractExcerpt = """

Section 9.2: Client may terminate this Agreement for convenience with 5 days'

written notice. Vendor shall be entitled to fees for Services rendered through

the termination date only, with no early-termination compensation.

Section 11.4: Vendor's total liability under this Agreement shall not exceed

the total fees paid in the preceding twelve (12) months, except in cases of

gross negligence, in which liability is uncapped.

""";

var messages = new List<ChatMessage>

{

new(ChatRole.System, systemPrompt),

new(ChatRole.User, $"Analyze this contract excerpt:\n\n{contractExcerpt}")

};

var response = await chatClient.GetResponseAsync(messages);

Console.WriteLine(response.Text);

Notice what’s not here: no special “reasoning mode” flag, no separate SDK, no different message format. It’s the exact same IChatClient call you’d make against any Foundry model. The reasoning happens because of how the model was built, not because of extra plumbing you have to write.

Sample output

# Contract Risk Analysis 

Based off of the provided excerpt, I have identified the following clauses that pose financial or legal risk. 

---


## RISK 1: Section 9.2 - Termination for Convenience 

### Reasoning Step By Step: 

1. **Short Notice Period** - The client only has to provide 5 days' written notice prior to terminating the agreement. This is an extremely short window for the vendor to adjust their operations. 

2. **Unrecoverable Costs** - The clause only allows for fees for services rendered up to the termination date, with no early termination compensation. This means any upfront costs (i.e: staffing, software, third party vendors, onboarding, or materials) that were procured for the remainder of the work will not be reimbursed. 

3. **Opportunity Cost** - With such a short notice period, the vendor may be unable to reallocate their resources to another client in time. This leads to lost revenue outside of what was already performed. 

4. **Imbalance of Power** - This is a unilateral right for the client with no reciprocal protections for the vendor, opening up the door for abuse of this clause. 


### Risk Severity: `HIGH`

---


## RISK 2: Section 11.4 - Liability Cap 

### Reasoning Step By Step: 

1. **Disproportionate Cap** - By limiting the vendor's total liability to only the fees paid in the preceding 12 months, the damages awarded could be massively disproportionate to the harm caused. For example, if a breach causes millions of dollars worth of damages, however only a smallamount of fees were paid within the last 12 months, the vendor's exposure would be negligible compared to the loss. 

2. **Uncertainty With The Exception** - The only exception to this cap is "gross negligence", which is a very high and fact specific legal standard to prove. This creates litigation uncertainty for both parties, as disputes may arise over whether the conduct met this threshold as opposed to ordinary negligence. 

3. **Uncapped Exposure** - While the uncapped liability for gross negligence may seem reasonable on the surface, it creates uninsurable or unpredictable exposure for the vendor. Depending on the claim, this can be catastrophic from a financial standpoint. 

4. **Jurisdictional Enforceability** - Depending on the governing law, liability caps are not always enforceable for certain claims (i.e: fraud, willful misconduct, statutory violations, or certain types of data breaches), which could render parts of this clause void, causing further unpredictability. 


### Risk Severity: `HIGH` 

--- 


## Final Summary 

| Risk | Clause | Key Concern | Severity | Recommended Mitigation |
| :-- | :-- | :-- | :-- | :-- |
| Termination For Convenience | 9.2 | 5 day notice with no early termination fee, leading to unrecoverable costs and opportunity loss. | High |Negotiate a longer notice period (e.g: 15-30 days), a termination fee based off of work scheduled, or a wind down reimbursement for committed costs. |
| Liability Cap | 11.4 | Cap to 12 months of fees is disproportionate, with an ambiguous "gross negligence" exception that can lead to uncapped, unpredictable exposure. | High | Expand the cap carveouts carefully, define "gross negligence", consider a higher liability cap (or a mutuallyagreed upon amount), and confirm compatibility with insurance coverage. |

# Contract Risk Analysis

Based off of the provided excerpt, I have identified the following clauses that pose financial or legal risk.

---

## RISK 1: Section 9.2 - Termination for Convenience

### Reasoning Step By Step:

1. **Short Notice Period** - The client only has to provide 5 days' written notice prior to terminating the agreement. This is an extremely short window for the vendor to adjust their operations.

2. **Unrecoverable Costs** - The clause only allows for fees for services rendered up to the termination date, with no early termination compensation. This means any upfront costs (i.e: staffing, software, third party vendors, onboarding, or materials) that were procured for the remainder of the work will not be reimbursed.

3. **Opportunity Cost** - With such a short notice period, the vendor may be unable to reallocate their resources to another client in time. This leads to lost revenue outside of what was already performed.

4. **Imbalance of Power** - This is a unilateral right for the client with no reciprocal protections for the vendor, opening up the door for abuse of this clause.

### Risk Severity: `HIGH`

---

## RISK 2: Section 11.4 - Liability Cap

### Reasoning Step By Step:

1. **Disproportionate Cap** - By limiting the vendor's total liability to only the fees paid in the preceding 12 months, the damages awarded could be massively disproportionate to the harm caused. For example, if a breach causes millions of dollars worth of damages, however only a smallamount of fees were paid within the last 12 months, the vendor's exposure would be negligible compared to the loss.

2. **Uncertainty With The Exception** - The only exception to this cap is "gross negligence", which is a very high and fact specific legal standard to prove. This creates litigation uncertainty for both parties, as disputes may arise over whether the conduct met this threshold as opposed to ordinary negligence.

3. **Uncapped Exposure** - While the uncapped liability for gross negligence may seem reasonable on the surface, it creates uninsurable or unpredictable exposure for the vendor. Depending on the claim, this can be catastrophic from a financial standpoint.

4. **Jurisdictional Enforceability** - Depending on the governing law, liability caps are not always enforceable for certain claims (i.e: fraud, willful misconduct, statutory violations, or certain types of data breaches), which could render parts of this clause void, causing further unpredictability.

### Risk Severity: `HIGH`

---

## Final Summary

| :-- | :-- | :-- | :-- | :-- |

| Termination For Convenience | 9.2 | 5 day notice with no early termination fee, leading to unrecoverable costs and opportunity loss. | High |Negotiate a longer notice period (e.g: 15-30 days), a termination fee based off of work scheduled, or a wind down reimbursement for committed costs. |

| Liability Cap | 11.4 | Cap to 12 months of fees is disproportionate, with an ambiguous "gross negligence" exception that can lead to uncapped, unpredictable exposure. | High | Expand the cap carveouts carefully, define "gross negligence", consider a higher liability cap (or a mutuallyagreed upon amount), and confirm compatibility with insurance coverage. |

Tool-Augmented Reasoning (The Agentic Part)

The use case Microsoft calls out explicitly — connecting to CRM, ERP, and ticketing systems through native tool calling — is where reasoning models earn their keep. A non-reasoning model will happily call a tool with garbage arguments and move on. A reasoning model is far more likely to check its own work before it commits to a tool call.

Here’s a minimal tool-calling setup using Microsoft.Extensions.AI‘s function tools:

#:package Azure.AI.OpenAI@2.9.0-beta.1
#:package Azure.Identity@1.21.0
#:package Microsoft.Extensions.AI@10.9.0
#:package Microsoft.Extensions.AI.OpenAI@10.3.0
#:package Microsoft.Extensions.Configuration@10.0.0
#:package Microsoft.Extensions.Configuration.EnvironmentVariables@10.0.0
#:package Microsoft.Extensions.Configuration.UserSecrets@10.0.0
#:property UserSecretsId=f8d4253e-5e0c-4aac-b93b-4e8e1d5d7b25

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.Configuration;
using System.ComponentModel;
using Microsoft.Extensions.AI;

await FunctionSample.RunAsync();

public class FunctionSample
{
    public static async Task RunAsync()
    {
        var config = new ConfigurationBuilder()
            .AddUserSecrets<FunctionSample>()
            .AddEnvironmentVariables()
            .Build();

        var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "mai-thinking-1";
        var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]
            ?? throw new InvalidOperationException(
                "AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));

        IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())
            .GetChatClient(deploymentName)
            .AsIChatClient()
            .AsBuilder()
            .UseFunctionInvocation()
            .Build();

        var chatOptions = new ChatOptions
        {
            Tools = [AIFunctionFactory.Create(GetTicketStatus)]
        };

        var response = await chatClient.GetResponseAsync(
            "Ticket TCK-4471 has been open a while — what's going on and what should we do?",
            chatOptions);

        Console.WriteLine(response.Text);
    }

    // A stand-in for a real ticketing system lookup
    [Description("Looks up the current status and priority of a support ticket by ID.")]
    public static string GetTicketStatus(string ticketId)
    {
        return ticketId switch
        {
            "TCK-4471" => "Status: Escalated. Priority: Critical. Opened 6 days ago, SLA breached.",
            _ => "Ticket not found."
        };
    }
}

#:package Azure.AI.OpenAI@2.9.0-beta.1

#:package Azure.Identity@1.21.0

#:package Microsoft.Extensions.AI@10.9.0

#:package Microsoft.Extensions.AI.OpenAI@10.3.0

#:package Microsoft.Extensions.Configuration@10.0.0

#:package Microsoft.Extensions.Configuration.EnvironmentVariables@10.0.0

#:package Microsoft.Extensions.Configuration.UserSecrets@10.0.0

#:property UserSecretsId=f8d4253e-5e0c-4aac-b93b-4e8e1d5d7b25

using Azure.AI.OpenAI;

using Azure.Identity;

using Microsoft.Extensions.Configuration;

using System.ComponentModel;

using Microsoft.Extensions.AI;

await FunctionSample.RunAsync();

public class FunctionSample

{

public static async Task RunAsync()

{

var config = new ConfigurationBuilder()

.AddUserSecrets<FunctionSample>()

.AddEnvironmentVariables()

.Build();

var deploymentName = config["AZURE_OPENAI_DEPLOYMENT"] ?? "mai-thinking-1";

var endpoint = new Uri(config["AZURE_AI_ENDPOINT"]

?? throw new InvalidOperationException(

"AZURE_AI_ENDPOINT is not set. Run: dotnet user-secrets set \"AZURE_AI_ENDPOINT\" \"<your-endpoint>\""));

IChatClient chatClient = new AzureOpenAIClient(endpoint, new DefaultAzureCredential())

.GetChatClient(deploymentName)

.AsIChatClient()

.AsBuilder()

.UseFunctionInvocation()

.Build();

var chatOptions = new ChatOptions

{

Tools = [AIFunctionFactory.Create(GetTicketStatus)]

};

var response = await chatClient.GetResponseAsync(

"Ticket TCK-4471 has been open a while — what's going on and what should we do?",

chatOptions);

Console.WriteLine(response.Text);

}

// A stand-in for a real ticketing system lookup

[Description("Looks up the current status and priority of a support ticket by ID.")]

public static string GetTicketStatus(string ticketId)

{

return ticketId switch

{

"TCK-4471" => "Status: Escalated. Priority: Critical. Opened 6 days ago, SLA breached.",

_ => "Ticket not found."

};

}

The model decides whether it needs to call GetTicketStatus based on its own reasoning about the request — not because you hardcoded “if the user mentions a ticket ID, call the tool.” That’s the actual value proposition here: less prompt-engineering gymnastics to force sensible tool use.

Output

## Ticket TCK-4471 — Current Status

- **Status:** Escalated  
- **Priority:** Critical  
- **Opened:** 6 days ago  
- **SLA:** Breached  

So: it’s a critical issue, already escalated, and it’s been open long enough that the committed response/resolve time has been missed.

## What’s going on (interpretation)
- **Critical impact**: This is likely affecting production, revenue, security, or a major customer. Treat as high urgency.
- **Escalated**: Support has already bumped it up (likely to Tier 2/3, engineering, management, or a partner team). It’s no longer being handled at the frontline only.
- **SLA breached (6 days open)**: The agreed SLA clock has expired. Expect pressure from stakeholders and potential contractual/experience impact.

## What you should do now
1. **Acknowledge & set comms**: Update the customer/stakeholder that it’s escalated and you’re actively driving it. Share next check-in time.
2. **Own the escalation**: Identify the escalation owner (engineer/lead) and a single point of contact. Confirm who is driving resolution.
3. **Find the blocker**: Check internal notes (linked incident, reproduction, affected env, logs, PRs). Is it waiting on engineering, a vendor, data fix, or release?
4. **Mitigate**: Is there a workaround (feature flag, rollback, hotfix, config change)? If yes, document and apply/communicate.
5. **Escalate to leadership if stalled**: If no movement today, loop in the escalation manager/incident commander; also consider incident post if prod is impacted.
6. **Track and document**: Log actions, update the ticket with ETA and next steps, and record SLA breach reason per process (for reporting/compliance).

## Quick questions to answer next
- Is there a linked incident (e.g., SEV-1/INC-…)? What’s the customer impact (users affected, downtime)?
- Who is the current assignee and last update time? Any dependencies (third-party/vendor)?
- What’s the target resolution path (rollback vs. fix vs. workaround)?

If you paste the latest internal note or assignee, I can suggest a tighter action plan (who to ping, what to ask, and a message template).

## Ticket TCK-4471 — Current Status

- **Status:** Escalated

- **Priority:** Critical

- **Opened:** 6 days ago

- **SLA:** Breached

So: it’s a critical issue, already escalated, and it’s been open long enough that the committed response/resolve time has been missed.

## What’s going on (interpretation)

- **Critical impact**: This is likely affecting production, revenue, security, or a major customer. Treat as high urgency.

- **Escalated**: Support has already bumped it up (likely to Tier 2/3, engineering, management, or a partner team). It’s no longer being handled at the frontline only.

- **SLA breached (6 days open)**: The agreed SLA clock has expired. Expect pressure from stakeholders and potential contractual/experience impact.

## What you should do now

1. **Acknowledge & set comms**: Update the customer/stakeholder that it’s escalated and you’re actively driving it. Share next check-in time.

2. **Own the escalation**: Identify the escalation owner (engineer/lead) and a single point of contact. Confirm who is driving resolution.

3. **Find the blocker**: Check internal notes (linked incident, reproduction, affected env, logs, PRs). Is it waiting on engineering, a vendor, data fix, or release?

4. **Mitigate**: Is there a workaround (feature flag, rollback, hotfix, config change)? If yes, document and apply/communicate.

5. **Escalate to leadership if stalled**: If no movement today, loop in the escalation manager/incident commander; also consider incident post if prod is impacted.

6. **Track and document**: Log actions, update the ticket with ETA and next steps, and record SLA breach reason per process (for reporting/compliance).

## Quick questions to answer next

- Is there a linked incident (e.g., SEV-1/INC-…)? What’s the customer impact (users affected, downtime)?

- Who is the current assignee and last update time? Any dependencies (third-party/vendor)?

- What’s the target resolution path (rollback vs. fix vs. workaround)?

If you paste the latest internal note or assignee, I can suggest a tighter action plan (who to ping, what to ask, and a message template).

Where This Fits (and Where It Doesn’t)

Be honest with yourself about when you need this:

Reach for MAI-Thinking-1 when:

The task genuinely requires multi-step reasoning — plan → check → revise → answer
You’re processing long documents where a shallow summary isn’t good enough
Your agent needs to reason about whether and how to call a tool, not just execute a fixed script

Don’t reach for it when:

You need a fast autocomplete-style response (use a smaller/cheaper model — reasoning models trade latency for depth)
The task is simple classification or extraction with no ambiguity to reason through
You’re cost-sensitive on high-volume, low-complexity calls — the MoE efficiency helps, but it’s still priced above a lightweight model

Structured output, defensive parsing, and resilience patterns all still apply here exactly like they do with any other Foundry model — if you’ve read the earlier chapters on that, nothing changes; you’re not throwing away any of the patterns you already have.

Wrapping Up

MAI-Thinking-1 is Microsoft’s first real swing at a reasoning model, and the fact that it drops straight into the same IChatClient abstraction as every other Foundry model is, frankly, the best part. No new SDK to learn, no separate reasoning-specific message format — just a model that’s better at the multi-step, tool-calling, long-context work that “just answer the prompt” models tend to fumble.

If you’ve been holding off on agentic workloads because the reasoning quality wasn’t there yet, this is worth a real evaluation — not just a demo.

Source code can be found at : https://github.com/taswar/MaiThinkingDemo

Building AI features in C#? I write about practical, no-hype prompt engineering and Azure AI patterns for .NET developers. Check out Prompt Engineering for .NET Developers — free, no Python required. Also subscibe to my mailing for latest blogs, tips and tricks I share.

Azure, C#, Microsoft Foundry

.net, Agentic AI, Azure AI, C#, LLM, MAI-Thinking-1, Microsoft Foundry, Microsoft.Extensions.AI, reasoning models

7 Highlights Thursday | 6th August 2026 (#119 Edition) Bonus

Taswar Bhatti August 6, 2026 No Comments

Published: 2026-08-06

This is the bonus content for the #119 edition of 5 Highlights Thursday – 7 highlights this week instead of 5. If you haven’t seen the main newsletter yet, check it out on LinkedIn.

1. QDK Tutorial: Learn Quantum Computing with GitHub Copilot in VS Code

Watch this video on YouTube

A quick, hands-on look at the Quantum Development Kit (QDK) tutorial experience in VS Code, paired with GitHub Copilot to help you get oriented with quantum computing concepts and code faster. Good starting point if quantum has been on your “someday” learning list.

2. Azure Files: Simple, Secure, Cloud and AI Ready File Storage

Watch this video on YouTube

A rundown of Azure Files as a simple, secure, cloud- and AI-ready file storage option — positioning it as the go-to for teams that need managed file shares without giving up the identity and governance controls (Microsoft Entra ID, FSLogix profile support) they already rely on.

3. Where Does AI Actually Add Value in This Build, and Where Is It Just Hype?

Watch this video on YouTube

A short, blunt take separating real AI value from hype in a recent build — worth a minute if you want a grounded gut-check before you bolt AI onto your next project.

4. Microsoft Defender for Office 365 | Zero to Hero

Watch this video on YouTube

A look at how Microsoft Defender’ enable key protections such as preset security policies, Safe Attachments, priority account protection, user reporting, and automated investigation and response (AIR), while explaining how these features strengthen an organization’s defense against email threats.

5. From Partners for Partners: Simplifying Customer Onboarding with Microsoft Defender

Watch this video on YouTube

Partner-focused guidance on simplifying customer onboarding with Microsoft Defender — practical if you’re a partner or MSP looking to streamline how you bring new customers onto Defender.

6. How AMD and Azure Push the Boundaries of Compute

Watch this video on YouTube

A look at the AMD and Azure partnership pushing the boundaries of compute — relevant if you’re evaluating VM SKUs or curious how silicon-level partnerships are shaping what’s available in Azure’s compute catalog.

7. How Does Using Real Pricing (Not Estimates) Change How You Architect an App?

Watch this video on YouTube

A quick take on how designing with real Azure pricing — instead of rough estimates — changes architectural decisions early in a build. A good reminder to check the pricing calculator before you commit to a design.

As always, please give me feedback on LinkedIn. Which bullet above is your favorite? What do you want more or less of? Other suggestions? Please let me know.

Download my Free Ebook Prompt Engineering for .NET Developers.

Last by not least, know someone who might be interested in this newsletter? Share it with them.

Subscribe on LinkedIn

Have a wonderful Thursday 😉

Taswar

Newsletter

AI, AMD, azure, Azure Files, Azure Pricing, Azure Weekly Digest, Cloud Computing, GitHub Copilot, Microsoft Azure, Microsoft Defender, Quantum Computing, security

7 Highlights Thursday | 30th July 2026 (#118 Edition) Bonus

Taswar Bhatti July 30, 2026 No Comments

Here is the Bonus #118 edition of 5 Highlights Thursday — a bit of a bonus edition this week with 7 highlights instead of 5. I hope this newsletter will help you in your Azure journey and keep you informed. Feel free to forward this along to anyone who you think may enjoy or better ask them to subscribe.

1. TypeScript 7 Is Here (And It’s 10× Faster)

Watch this video on YouTube

TypeScript 7 has landed, and it’s a big one — a native, Go-based compiler rewrite delivers roughly 10x faster compilation, alongside new language features and some breaking changes from v6. If you or your team live in the TypeScript ecosystem, this is worth 10 minutes of your time to understand what changes before you upgrade.

2. What’s New in SQL MCP Server 2.0

Watch this video on YouTube

SQL MCP Server 2.0 brings new capabilities that let AI agents and Copilot interact directly with your SQL Server data through the Model Context Protocol. If you’re building agentic apps on top of SQL, this positions MCP as the standard interface for agent-to-data access — worth watching if you care about Azure SQL and agent tooling.

3. Introducing Project Perception: The Next Evolution of Agentic Security

Watch this video on YouTube

Microsoft’s official intro to Project Perception — the next generation of agentic security that uses AI agents to proactively detect and respond to threats before they materialize. This is part of a coordinated security push (see #4 below) and is directly relevant if you’re thinking about AI security governance.

4. How Nationwide Stays Ahead of Attackers with Project Perception

Watch this video on YouTube

A real customer story: Nationwide (the insurance company) shares how they’re using Project Perception for proactive threat intelligence — staying ahead of attackers before incidents occur rather than just reacting after the fact. Good pairing with #3 if you want the product story plus the real-world proof point.

5. Inside Codename MDASH: Built to Protect

Watch this video on YouTube

A behind-the-scenes look at Codename MDASH — a new Microsoft Defender capability built specifically to protect AI workloads, agents, and agentic systems from emerging threats. Released the same day as Project Perception, this rounds out Microsoft’s coordinated AI security announcement.

6. Data Streaming for Modern Applications in SQL Server 2025, Azure SQL, and Fabric SQL

Watch this video on YouTube

Data Exposed walks through data streaming patterns across SQL Server 2025, Azure SQL, and Fabric SQL — useful if you’re architecting real-time data pipelines and want one consistent streaming story across on-prem, cloud, and Fabric.

7. Build Microsoft Foundry Agents with the New AI Gateway Tier of API Management

Watch this video on YouTube

API Management’s new AI Gateway tier gives you governance, rate limiting, and observability in front of Microsoft Foundry agents — worth a look if you’re running agentic workloads in production and need enterprise-grade traffic control in front of them.

As always, please give me feedback on LinkedIn. Which bullet above is your favorite? What do you want more or less of? Other suggestions? Please let me know.

Last by not least, know someone who might be interested in this newsletter? Share it with them.

Subscribe to my newsletter

Have a wonderful Thursday 🙂

Taswar

MAI-Voice-2 Flash for .NET Developers — Real-Time Voice on Azure Speech

Taswar Bhatti July 27, 2026 No Comments

Every voice application I’ve ever built or reviewed has the same problem: latency. The model can sound as natural as you want, but if there’s a full second of dead air between the user finishing a sentence and the assistant responding, the whole thing feels broken. Users notice a pause before they notice voice quality.

Microsoft AI just shipped MAI-Voice-2 Flash, a text-to-speech model built specifically to fix that. It’s the low-latency sibling of MAI-Voice-2, now available through Azure Speech — not a separate SDK, not a new service to learn, just a new voice option inside the Speech service you may already be using.

Same day, Microsoft also shipped MAI-Image-2.5 Pro for high-fidelity image generation (I covered that one in a separate post if you’re building creative/image pipelines). This post is about the voice model, because if you’re building call center agents, IVR systems, or conversational assistants in .NET, this is the one that actually changes your architecture.

What MAI-Voice-2 Flash Actually Does

It’s a text-to-speech model, tuned for one specific tradeoff: speed over voice customization.

2x faster than MAI-Voice-2, same natural voice quality
32% more cost-efficient
15+ languages supported — English (US/AU), Italian, Spanish (Mexico/Spain), Hindi, French, German, Portuguese (Brazil/Portugal), Korean, Chinese (Simplified), Turkish, Russian, Thai, Dutch, Romanian, Hungarian
Voice cloning from 5–60 second audio prompts — natural, conversational delivery with moderate energy gives the best results
SSML support for voice selection and pacing — see the SSML section below for what actually works today

MAI-Voice-2 Flash vs. MAI-Voice-2 — Which One Do You Actually Want?

Microsoft’s own guidance on this is refreshingly direct: it comes down to voice identity vs. responsiveness.

Choose MAI-Voice-2 Flash when:
– Low latency is the primary requirement
– You’re building conversational assistants, IVR systems, or call center experiences
– Users expect an immediate spoken response as part of a live interaction
– Cost efficiency matters as much as responsiveness

Choose MAI-Voice-2 instead when voice identity and higher-fidelity output matter more than raw speed — think narration, media production, or anything not happening in a live back-and-forth.

If your use case involves a human waiting on the other end of a phone call or a chat window, you want Flash.

Where This Fits — Real Use Cases

Microsoft calls out three scenarios, and all three map to things I’ve seen teams either build badly or avoid building entirely because of latency:

Call center agents. Spoken responses generated in real time, minimizing the delay between conversation turns. This is the difference between an AI agent that sounds like it’s thinking and one that sounds like it’s stalling.

Conversational voice assistants. Copilots and intelligent applications that respond nearly instantly — the fluid, interactive feel instead of the stilted turn-based one.

Modern IVR systems. Dynamic, context-aware phone experiences that respond to what the caller actually says instead of routing through a rigid menu tree.

If you’re maintaining a legacy IVR system held together with pre-recorded prompts and DTMF menus, or a support bot that has a noticeable pause before every response — this is worth a pilot.

Pricing

MAI-Voice-2 Flash pricing starts at $15 per 1M characters. For comparison, MAI-Image-2.5 Pro (the image model announced alongside it) starts at $5 per 1M input tokens and $106 per 1M output tokens — a completely different pricing shape, since one generates images and the other generates audio from text.

For a call center handling, say, 200-character average responses across 10,000 calls a day, that’s roughly 2M characters/day — a genuinely calculable cost before you commit to an architecture.

Setting Up Azure Speech — Full Instructions

Since MAI-Voice-2 Flash ships through Azure Speech rather than a standalone endpoint, you set it up exactly like any other Speech resource. Here’s the complete path from zero to a working API key.

Step 1: Create a Speech Resource in Azure

Go to the Azure Portal
Click Create a resource
Search for Speech service (or Azure AI Foundry if you want the unified Foundry resource — both work for this)
Click Create
Fill in:
– Subscription — your Azure subscription
– Resource group — create new or use existing
– Region — pick a region that supports MAI-Voice-2 Flash (check the model catalog page for current regional availability — this is in public preview and region support is still expanding)
– Name — something like my-speech-resource
– Pricing tier — Standard (S0) for production use
Click Review + Create, then Create

Step 2: Get Your Key and Region

Once deployed, go to your Speech resource
Click Keys and Endpoint in the left sidebar
Copy KEY 1 and note your Region (e.g., eastus)

Step 3: Store Secrets Properly

Don’t hardcode the key. Use user-secrets for local development:

dotnet new console -n MaiVoiceFlashDemo
cd MaiVoiceFlashDemo
dotnet user-secrets init
dotnet user-secrets set "Speech:Key" "YOUR_SPEECH_KEY"
dotnet user-secrets set "Speech:Region" "eastus"

dotnet new console -n MaiVoiceFlashDemo

cd MaiVoiceFlashDemo

dotnet user-secrets init

dotnet user-secrets set "Speech:Key" "YOUR_SPEECH_KEY"

dotnet user-secrets set "Speech:Region" "eastus"

Step 4: Install the Speech SDK

dotnet add package Microsoft.CognitiveServices.Speech
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

1 2	dotnet add package Microsoft.CognitiveServices.Speech dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Let’s Actually Call It from C#

Here’s a working console app that synthesizes speech using the Azure Speech SDK, configured for low-latency real-time output — the pattern you’d actually use for a conversational assistant.

Program.cs — Basic Synthesis

Sample code located at https://github.com/taswar/Mai-Voice-2-Flash-Sample

sing Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();

var speechKey = config["Speech:Key"]
    ?? throw new InvalidOperationException("Set Speech:Key via user-secrets.");
var speechRegion = config["Speech:Region"]
    ?? throw new InvalidOperationException("Set Speech:Region via user-secrets.");

var speechConfig = SpeechConfig.FromSubscription(speechKey, speechRegion);

// Voice name follows Azure Speech naming conventions — check the Foundry model
// catalog / Speech Studio voice gallery for the exact MAI-Voice-2 Flash voice
// identifier available in your region during public preview.
speechConfig.SpeechSynthesisVoiceName = "en-US-Ava:MAIVoice2FlashNeural";

// Output directly to the default speaker. Swap AudioConfig for a file or
// in-memory stream if you're serving this from a web API instead of a console app.
using var audioConfig = AudioConfig.FromDefaultSpeakerOutput();
using var synthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

var text = "Thanks for calling. I can help you check your order status, " +
           "process a return, or connect you with a specialist. What do you need today?";

Console.WriteLine("Synthesizing...");

using var result = await synthesizer.SpeakTextAsync(text);

if (result.Reason == ResultReason.SynthesizingAudioCompleted)
{
    Console.WriteLine("Done. Audio played through default speaker.");
}
else if (result.Reason == ResultReason.Canceled)
{
    var cancellation = SpeechSynthesisCancellationDetails.FromResult(result);
    Console.WriteLine($"Canceled: {cancellation.Reason}");

    if (cancellation.Reason == CancellationReason.Error)
    {
        Console.WriteLine($"Error code: {cancellation.ErrorCode}");
        Console.WriteLine($"Error details: {cancellation.ErrorDetails}");
    }
}

sing Microsoft.CognitiveServices.Speech;

using Microsoft.CognitiveServices.Speech.Audio;

using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()

.AddUserSecrets<Program>()

.AddEnvironmentVariables()

.Build();

var speechKey = config["Speech:Key"]

?? throw new InvalidOperationException("Set Speech:Key via user-secrets.");

var speechRegion = config["Speech:Region"]

?? throw new InvalidOperationException("Set Speech:Region via user-secrets.");

var speechConfig = SpeechConfig.FromSubscription(speechKey, speechRegion);

// Voice name follows Azure Speech naming conventions — check the Foundry model

// catalog / Speech Studio voice gallery for the exact MAI-Voice-2 Flash voice

// identifier available in your region during public preview.

speechConfig.SpeechSynthesisVoiceName = "en-US-Ava:MAIVoice2FlashNeural";

// Output directly to the default speaker. Swap AudioConfig for a file or

// in-memory stream if you're serving this from a web API instead of a console app.

using var audioConfig = AudioConfig.FromDefaultSpeakerOutput();

using var synthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

var text = "Thanks for calling. I can help you check your order status, " +

"process a return, or connect you with a specialist. What do you need today?";

Console.WriteLine("Synthesizing...");

using var result = await synthesizer.SpeakTextAsync(text);

if (result.Reason == ResultReason.SynthesizingAudioCompleted)

{

Console.WriteLine("Done. Audio played through default speaker.");

}

else if (result.Reason == ResultReason.Canceled)

{

var cancellation = SpeechSynthesisCancellationDetails.FromResult(result);

Console.WriteLine($"Canceled: {cancellation.Reason}");

if (cancellation.Reason == CancellationReason.Error)

{

Console.WriteLine($"Error code: {cancellation.ErrorCode}");

Console.WriteLine($"Error details: {cancellation.ErrorDetails}");

}

Expected Output

Synthesizing...
Done. Audio played through default speaker.

1 2	Synthesizing... Done. Audio played through default speaker.

You should hear the response with noticeably less delay than a standard-tier voice model — that’s the “2x faster” claim showing up as an actual user experience difference, not just a benchmark number.

Streaming to a Web API Response (Real-Time Use Case)

For an actual call center or assistant integration, you’re not playing audio through a speaker — you’re streaming bytes back to a caller or a browser. Here’s the pattern for an ASP.NET Core minimal API endpoint that returns synthesized speech as a stream:

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/speak", async (SpeakRequest request, IConfiguration config) =>
{
    var speechConfig = SpeechConfig.FromSubscription(
        config["Speech:Key"], config["Speech:Region"]);

    speechConfig.SpeechSynthesisVoiceName = "en-US-Ava:MAIVoice2FlashNeural";
    speechConfig.SetSpeechSynthesisOutputFormat(
        SpeechSynthesisOutputFormat.Audio24Khz96KBitRateMonoMp3);

    // No audio config = in-memory result instead of playing to a device
    using var synthesizer = new SpeechSynthesizer(speechConfig, null);
    using var result = await synthesizer.SpeakTextAsync(request.Text);

    if (result.Reason != ResultReason.SynthesizingAudioCompleted)
    {
        var cancellation = SpeechSynthesisCancellationDetails.FromResult(result);
        return Results.Problem($"Synthesis failed: {cancellation.ErrorDetails}");
    }

    return Results.File(result.AudioData, "audio/mpeg");
});

app.Run();

record SpeakRequest(string Text);

using Microsoft.CognitiveServices.Speech;

using Microsoft.CognitiveServices.Speech.Audio;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.MapPost("/speak", async (SpeakRequest request, IConfiguration config) =>

{

var speechConfig = SpeechConfig.FromSubscription(

config["Speech:Key"], config["Speech:Region"]);

speechConfig.SpeechSynthesisVoiceName = "en-US-Ava:MAIVoice2FlashNeural";

speechConfig.SetSpeechSynthesisOutputFormat(

SpeechSynthesisOutputFormat.Audio24Khz96KBitRateMonoMp3);

// No audio config = in-memory result instead of playing to a device

using var synthesizer = new SpeechSynthesizer(speechConfig, null);

using var result = await synthesizer.SpeakTextAsync(request.Text);

if (result.Reason != ResultReason.SynthesizingAudioCompleted)

{

var cancellation = SpeechSynthesisCancellationDetails.FromResult(result);

return Results.Problem($"Synthesis failed: {cancellation.ErrorDetails}");

}

return Results.File(result.AudioData, "audio/mpeg");

});

app.Run();

record SpeakRequest(string Text);

Call it with:

curl -X POST http://localhost:5000/speak \
  -H "Content-Type: application/json" \
  -d '{"text":"Your order has shipped and will arrive Thursday."}' \
  --output response.mp3

curl -X POST http://localhost:5000/speak \

-H "Content-Type: application/json" \

-d '{"text":"Your order has shipped and will arrive Thursday."}' \

--output response.mp3

That is the shape of the endpoint sitting behind a real call center agent or IVR system — take text, return audio, keep the round trip fast.

Using SSML for Turn-Level Control — What Actually Works

Microsoft’s own materials describe MAI-Voice-2 Flash as supporting “turn-level control over tone, delivery, and emotion.” The obvious first move for anyone who’s used Azure Speech before is to reach for the classic mstts:express-as element — the same one you’d use with a standard Neural voice to say “make this line sound cheerful” or “empathetic.”

I tried it. It doesn’t work.

Here’s the SSML I first attempted, styled the same way you’d write it for any legacy Neural voice:

// ⚠️ THIS DOES NOT WORK ON MAI-VOICE-2-FLASH — kept here so you don't waste
// the 20 minutes I did trying to debug a namespace typo that wasn't the problem.
var ssmlBroken = """
    <speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
        <voice name="en-US-Ava:MAIVoice2FlashNeural">
            <mstts:express-as style="empathetic" xmlns:mstts="https://www.w3.org/2001/mstts">
                I'm sorry to hear your order arrived damaged.
            </mstts:express-as>
        </voice>
    </speak>
    """;

using var ssmlResult = await synthesizer.SpeakSsmlAsync(ssmlBroken);
// result.Reason == ResultReason.Canceled
// cancellation.ErrorCode == invalid_request

// ⚠️ THIS DOES NOT WORK ON MAI-VOICE-2-FLASH — kept here so you don't waste

// the 20 minutes I did trying to debug a namespace typo that wasn't the problem.

var ssmlBroken = """

<mstts:express-as style="empathetic" xmlns:mstts="https://www.w3.org/2001/mstts">

I'm sorry to hear your order arrived damaged.

</mstts:express-as>

</voice>

</speak>

""";

using var ssmlResult = await synthesizer.SpeakSsmlAsync(ssmlBroken);

// result.Reason == ResultReason.Canceled

// cancellation.ErrorCode == invalid_request

So what does “turn-level control over tone, delivery, and emotion” actually mean today? As of this public preview, it’s unclear. It may be a plain-text delivery cue baked into the prompt, or an MAI-specific SSML extension that isn’t documented yet. I could not find a combination that worked, and I’d treat that marketing line as aspirational until Microsoft publishes the actual mechanism.

What Does Work: Plain SSML for Voice, Pacing, and Pauses

Strip out express-as entirely and SSML still earns its place — you get voice selection, break for natural pauses, and prosody control, all of which the service accepts without complaint:

var ssml = """
    <speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
        <voice name="en-US-Ava:MAIVoice2FlashNeural">
            I'm sorry to hear your order arrived damaged.
            <break time="300ms"/>
            Let's get that sorted out right away.
        </voice>
    </speak>
    """;

using var ssmlResult = await synthesizer.SpeakSsmlAsync(ssml);

var ssml = """

I'm sorry to hear your order arrived damaged.

Let's get that sorted out right away.

</voice>

</speak>

""";

using var ssmlResult = await synthesizer.SpeakSsmlAsync(ssml);

No emotion tags, no style attribute — just the voice name and a deliberate pause between the apology and the resolution. That pause alone does more for how “human” the response feels than most developers expect. It’s a smaller toolkit than advertised, but it’s a toolkit that actually ships a ResultReason.SynthesizingAudioCompleted instead of a canceled request.

Same Pattern in Turkish

MAI-Voice-2 Flash’s multilingual support means the same working SSML structure carries across languages — change xml:lang, the voice name, and the text:

var ssmlTurkish = """
    <speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="tr-TR">
        <voice name="tr-TR-Elif:MAI-Voice-2-Flash">
            Siparişinizin hasarlı ulaştığını duyduğuma üzüldüm. Hemen bir iade işlemi başlatıyorum, birkaç saniye sürecek.
        </voice>
    </speak>
    """;

using var ssmlResultTr = await synthesizer.SpeakSsmlAsync(ssmlTurkish);

var ssmlTurkish = """

Siparişinizin hasarlı ulaştığını duyduğuma üzüldüm. Hemen bir iade işlemi başlatıyorum, birkaç saniye sürecek.

</voice>

</speak>

""";

using var ssmlResultTr = await synthesizer.SpeakSsmlAsync(ssmlTurkish);

Translation for reference: “I’m sorry to hear your order arrived damaged. I’m starting a return right away — it will just take a few seconds.”

This is the actual payoff of a multilingual low-latency voice model for a call center: one codebase, one SpeakSsmlAsync call, and the only thing that changes per market is the xml:lang, the voice name, and the translated text. You’re not maintaining a separate TTS integration per region.

📝 Note: Voice names and available express-as styles for MAI-Voice-2 Flash are still being finalized during public preview. Check the Foundry model catalog or Speech Studio’s voice gallery for the exact identifiers available in your region — including Turkish — before shipping this to production.

Why Run It Through Azure Speech (Not a Separate Vendor)

If you’re already using Azure Speech for any part of your stack, this is close to a zero-integration-cost upgrade:

Same SDK, same auth pattern — no new NuGet package beyond what you likely already have
Enterprise reliability and scale — the infrastructure Azure Speech already runs on
Same Responsible AI and governance guardrails as the rest of Foundry
Regional deployment options to keep voice data processing where compliance requires it

For teams already invested in Azure Speech for STT or existing TTS voices, swapping in MAI-Voice-2 Flash for your latency-sensitive scenarios is a configuration change, not a rewrite.

Final Thoughts

MAI-Voice-2 Flash is a narrow, well-aimed release. It’s not trying to be the most expressive or highest-fidelity voice model Microsoft ships — that’s what MAI-Voice-2 is for. It’s optimized for the one metric that actually breaks real-time voice experiences: the gap between “user stops talking” and “assistant starts responding.”

If you’re building or maintaining call center agents, IVR systems, or conversational assistants, and users have ever complained about the pause before the response — this is worth a pilot. Point it at your existing Azure Speech integration, swap the voice name, and measure the round-trip time yourself.

If your team already runs on Azure Speech and just wants faster responses without switching vendors, this is one worth wiring in this week. 🙂