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

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"

1

2

3

4

5

6

7

8

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);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

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. |

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

# 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."
        };
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#: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).

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

## 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#, 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"

1

2

3

4

5

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}");
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

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);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

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

1

2

3

4

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

// ⚠️ 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);

1

2

3

4

5

6

7

8

9

10

11

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);

1

2

3

4

5

6

7

8

9

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. 🙂

Resources

MAI-Image-2.5 Pro for .NET Developers — Microsoft’s Own Image Model Lands in Foundry

Taswar Bhatti July 24, 2026 No Comments

Every time a new image model ships, my first question isn’t “how pretty are the demo images.” It’s “can I actually put this in a pipeline and get consistent, controllable output.” Most image models are great at one beautiful hero shot and terrible at the boring part — generating twelve consistent product variants, or fixing one object in an image without regenerating the whole thing.

Microsoft AI just shipped MAI-Image-2.5 Pro, now available in public preview in Microsoft Foundry as an Azure Direct Model. It’s Microsoft’s own image generation and image-editing model — not a third-party model hosted in the catalog, but one built in-house by Microsoft AI.

That is worth pausing on. Alongside it, MAI-Voice-2 Flash also shipped for real-time voice through Azure Speech. This post is about the image model (I will cover MAI-Voice-2 Flash in another post), because that is the one .NET developers building content pipelines, e-commerce catalogs, or design tools will actually reach for first.

What MAI-Image-2.5 Pro Actually Does

It’s a diffusion-based text-to-image and image-to-image model. Two capabilities matter more than the others:

Generation — natural language prompt in, high-fidelity image out
Precise editing — targeted object edits, layout changes, text updates, and cleanup of artifacts like motion blur, all while preserving visual consistency across iterations

That second bullet is the interesting one. “Precise, surgical edits with consistency” is the phrase Microsoft uses, and it’s the right framing. A lot of image models will happily regenerate an entire scene when you ask for one small change — swap the color of a shirt and the model quietly redraws the face too. MAI-Image-2.5 Pro is positioned specifically to avoid that.

Why It Matters

Professional creative quality — stronger object consistency, more accurate text rendering (a famously hard problem for diffusion models), closer alignment to what you actually asked for, and better visual/world reasoning
More model choice in Foundry — you can now pick a purpose-built Microsoft model for creative workflows alongside the rest of the Foundry catalog, the same way you’d pick Kimi K2.7 Code for coding tasks or Cohere Command A+ for enterprise agents
Enterprise-ready foundations — backed by Microsoft’s safety and Responsible AI practices, running on Azure infrastructure for reliability, scale, and governance

Honestly, that last point is the one enterprises actually care about. A lot of image models are impressive right up until legal asks about content provenance and data handling.

Where This Fits — Real Use Cases

Microsoft calls out two buckets, and both map to real backlog items I’ve seen teams carry for months:

Campaigns and product content. Consistent hero assets, social media variants, retail signage, digital ads, product photography, e-commerce catalogs. The “consistency across iterations” capability is exactly what you need when you’re generating fifteen size/color variants of the same product shot and they all need to look like the same product line.

Storyboarding and regulated-industry visuals. Consistent scenes, characters, and concepts with stronger real-world accuracy — relevant for creative production, but also healthcare, financial services, and manufacturing, where “close enough” visual accuracy isn’t good enough.

If your team maintains a product catalog, a marketing asset pipeline, or anything that currently involves a human manually generating fifty variants of one image in Photoshop — this is worth a pilot.

Let’s Actually Call It from C#

Source code can be found at https://github.com/taswar/MAI-Image-2.5-Pro-Sample

Prerequisites

dotnet new console -n Mai-Image-2.5Pro-Demo
cd Mai-Image-2.5Pro-Demo
dotnet add package Azure.Core
dotnet add package Azure.Identity

1

2

3

4

dotnet new console -n Mai-Image-2.5Pro-Demo

cd Mai-Image-2.5Pro-Demo

dotnet add package Azure.Core

dotnet add package Azure.Identity

Set your environment variables:

# On Windows (PowerShell)
$env:AZURE_AI_FOUNDRY_ENDPOINT = "https://YOUR-RESOURCE.services.ai.azure.com"
$env:AZURE_AI_IMAGE_MODEL = "MAI-Image-2.5-Pro"

1

2

3

# On Windows (PowerShell)

$env:AZURE_AI_FOUNDRY_ENDPOINT = "https://YOUR-RESOURCE.services.ai.azure.com"

$env:AZURE_AI_IMAGE_MODEL = "MAI-Image-2.5-Pro"

Program.cs — Generate a Product Image

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

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_FOUNDRY_ENDPOINT")
    ?? throw new InvalidOperationException("Set AZURE_AI_FOUNDRY_ENDPOINT.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_IMAGE_MODEL") ?? "MAI-Image-2.5-Pro";

var prompt = """
    A minimalist product photo of a stainless steel water bottle on a plain
    white background, studio lighting, soft shadow beneath the bottle,
    e-commerce catalog style, no text on the label.
    """;

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

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);

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

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

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

if (!response.IsSuccessStatusCode)
{
    Console.WriteLine($"Image generation failed: {(int)response.StatusCode} {response.ReasonPhrase}");
    Console.WriteLine(responseBody);
    throw new InvalidOperationException($"{model} image generation request failed.");
}

using JsonDocument json = JsonDocument.Parse(responseBody);
string? b64 = json.RootElement
    .GetProperty("data")[0]
    .GetProperty("b64_json")
    .GetString();

if (string.IsNullOrWhiteSpace(b64))
{
    throw new InvalidOperationException("Response did not contain data[0].b64_json.");
}

byte[] imageBytes = Convert.FromBase64String(b64);
string outputPath = Path.Combine(Environment.CurrentDirectory, "product-bottle.png");
await File.WriteAllBytesAsync(outputPath, imageBytes);
Console.WriteLine($"Image saved to: {outputPath}");

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

using Azure.Core;

using Azure.Identity;

using System.Net.Http.Headers;

using System.Text;

using System.Text.Json;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_FOUNDRY_ENDPOINT")

?? throw new InvalidOperationException("Set AZURE_AI_FOUNDRY_ENDPOINT.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_IMAGE_MODEL") ?? "MAI-Image-2.5-Pro";

var prompt = """

A minimalist product photo of a stainless steel water bottle on a plain

white background, studio lighting, soft shadow beneath the bottle,

e-commerce catalog style, no text on the label.

""";

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

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);

var mai_payload = new

{

prompt = prompt,

model = model,

width = 1024,

height = 1024,

output_compression = 100,

output_format = "png",

n = 1

};

using var content = new StringContent(

JsonSerializer.Serialize(mai_payload),

Encoding.UTF8,

"application/json");

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

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

if (!response.IsSuccessStatusCode)

{

Console.WriteLine($"Image generation failed: {(int)response.StatusCode} {response.ReasonPhrase}");

Console.WriteLine(responseBody);

throw new InvalidOperationException($"{model} image generation request failed.");

}

using JsonDocument json = JsonDocument.Parse(responseBody);

string? b64 = json.RootElement

.GetProperty("data")[0]

.GetProperty("b64_json")

.GetString();

if (string.IsNullOrWhiteSpace(b64))

{

throw new InvalidOperationException("Response did not contain data[0].b64_json.");

}

byte[] imageBytes = Convert.FromBase64String(b64);

string outputPath = Path.Combine(Environment.CurrentDirectory, "product-bottle.png");

await File.WriteAllBytesAsync(outputPath, imageBytes);

Console.WriteLine($"Image saved to: {outputPath}");

Editing an Existing Image — Targeted, Not a Full Regeneration

This is the part that matters more than pure generation. Here’s how you make one precise change to an existing product shot — swap the bottle color without touching the background, lighting, or shadow:

var editPrompt = """
    Change the bottle color from stainless steel to matte black.
    Keep the background, lighting, shadow, and camera angle exactly the same.
    """;

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

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

byte[] sourceImageBytes = await File.ReadAllBytesAsync(outputPath);
var imagePart = new ByteArrayContent(sourceImageBytes);
imagePart.Headers.ContentType = new MediaTypeHeaderValue("image/png");
editContent.Add(imagePart, "image", "product-bottle.png");

Console.WriteLine("Editing image...");

using HttpResponseMessage editResponse = await http.PostAsync(editUrl, editContent);
string editResponseBody = await editResponse.Content.ReadAsStringAsync();

if (!editResponse.IsSuccessStatusCode)
{
    Console.WriteLine($"Image edit failed: {(int)editResponse.StatusCode} {editResponse.ReasonPhrase}");
    Console.WriteLine(editResponseBody);
    throw new InvalidOperationException($"{model} image edit request failed.");
}

using JsonDocument editJson = JsonDocument.Parse(editResponseBody);
string? editB64 = editJson.RootElement
    .GetProperty("data")[0]
    .GetProperty("b64_json")
    .GetString();

if (string.IsNullOrWhiteSpace(editB64))
{
    throw new InvalidOperationException("Edit response did not contain data[0].b64_json.");
}

byte[] editedImageBytes = Convert.FromBase64String(editB64);
string editedOutputPath = Path.Combine(Environment.CurrentDirectory, "product-bottle-black.png");
await File.WriteAllBytesAsync(editedOutputPath, editedImageBytes);
Console.WriteLine($"Image saved to: {editedOutputPath}");

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

var editPrompt = """

Change the bottle color from stainless steel to matte black.

Keep the background, lighting, shadow, and camera angle exactly the same.

""";

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

using var editContent = new MultipartFormDataContent

{

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

{ new StringContent(model), "model" }

};

byte[] sourceImageBytes = await File.ReadAllBytesAsync(outputPath);

var imagePart = new ByteArrayContent(sourceImageBytes);

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

editContent.Add(imagePart, "image", "product-bottle.png");

Console.WriteLine("Editing image...");

using HttpResponseMessage editResponse = await http.PostAsync(editUrl, editContent);

string editResponseBody = await editResponse.Content.ReadAsStringAsync();

if (!editResponse.IsSuccessStatusCode)

{

Console.WriteLine($"Image edit failed: {(int)editResponse.StatusCode} {editResponse.ReasonPhrase}");

Console.WriteLine(editResponseBody);

throw new InvalidOperationException($"{model} image edit request failed.");

}

using JsonDocument editJson = JsonDocument.Parse(editResponseBody);

string? editB64 = editJson.RootElement

.GetProperty("data")[0]

.GetProperty("b64_json")

.GetString();

if (string.IsNullOrWhiteSpace(editB64))

{

throw new InvalidOperationException("Edit response did not contain data[0].b64_json.");

}

byte[] editedImageBytes = Convert.FromBase64String(editB64);

string editedOutputPath = Path.Combine(Environment.CurrentDirectory, "product-bottle-black.png");

await File.WriteAllBytesAsync(editedOutputPath, editedImageBytes);

Console.WriteLine($"Image saved to: {editedOutputPath}");

Expected Output

Generating image with MAI-Image-2.5-Pro...
Saved: product-bottle.png
Editing image...
Saved: product-bottle-black.png

1

2

3

4

5

Generating image with MAI-Image-2.5-Pro...

Saved: product-bottle.png

Editing image...

Saved: product-bottle-black.png

Two files. Same lighting, same shadow, same camera angle. One bottle color changed. That is the workflow you’d wire into a service that generates every SKU variant overnight instead of a designer doing it by hand.

📝 Note: The exact SDK surface for Foundry image models is still settling as this model is in public preview — check the Foundry Model Catalog page for the current API reference before you wire this into production. The calling pattern above follows the standard Http Client image generation shape; MAI-Image models aren’t compatible with the Azure.AI.OpenAI SDK’s ImageClient — they require the raw REST call. Do confirmed against the latest docs, since things change very fast.

Why Run It Through Microsoft Foundry

Same reasoning as every other model I’ve covered in this series — Kimi K2.7 Code, Cohere Command A+ — but with one extra point specific to this model:

It’s a first-party Microsoft model. Support, roadmap, and Responsible AI documentation come from the same team building the platform you’re deploying on.
Entra ID auth — no separate API key management for yet another vendor.
Governance and safety tooling built into the platform, which matters more for image generation than most other model types — content policy and provenance questions come up fast in creative workflows.
Side-by-side evaluation against other Foundry models if you’re also experimenting with other image generation options.

Final Thoughts

MAI-Image-2.5 Pro is Microsoft betting on its own first-party model for a category — image generation — that has mostly been third-party territory in Foundry until now. The pitch isn’t “prettiest demo image.” It’s “precise edits with consistency,” which is the actual bottleneck for anyone trying to move image generation from a design toy into a production content pipeline.

If your team maintains product catalogs, marketing assets, or storyboards and you’re currently paying a human to manually generate every size and color variant — this is worth a pilot. Start with the generate-then-edit pattern above, point it at a real product shot, and see how many variants you can produce in a loop before lunch.

Resources

5 Highlights Thursday | 23rd July 2026 (#117 Edition)

Taswar Bhatti July 23, 2026 No Comments

Published: 2026-07-23
Source: https://www.linkedin.com/pulse/5-highlights-thursday-23rd-july-2026-117-edition-taswar-bhatti-s6rkf

Hope everyone is enjoying some summer break and here is the #117 edition of 5 Highlights Thursday. 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. Free Book – Prompt Engineering for .NET Developers

Excited to share something I’ve been working on…After many late nights of writing, testing, and refining, I’ve finished my FREE ebook: Prompt Engineering for .NET Developers. You can read the entire book from leanpub or from my github repo. taswar/PromptEngineeringForDotNetDevelopers: A free ebook for .NET developers building real AI-powered apps in C# — no Python, no hype.

2. Build Agents you Can Trust on Windows

Watch this video on YouTube

Through live demos, you’ll see how agents identify available capabilities, plan and take meaningful actions, and how Windows layers permission scoping, inspection, developer tool capabilities, and rollback to keep developers in control.

3. Claude Opus 4 + RAG: Build an AI App with Embeddings & Knowledge Graphs

Watch this video on YouTube

In this episode, host Justin Garrett sits down with Microsoft MVP Michael Washington to explore how he built AI Story Builders—an open-source (MIT) app that uses structured story data, embeddings, and Retrieval Augmented Generation (RAG) to help authors write coherent, consistent fiction.

4. Work IQ: Tooling with MCP & CLI

Watch this video on YouTube

Jared Spataro, CVP of AI Solutions opens this episode of Work IQ by explaining how Work IQ MCP tools enable agents to safely consume and act on Microsoft 365 workloads. Paolo Pialorsi
, Sr Cloud Advocate, then demonstrates using MCPs and Copilot CLI to observe, reason over, and take actions across M365 surfaces like files, meetings, and messages, before our visualization expert, Tomomi Imura , brings it all together.

5. Stop Stitching Models Together — Cohere Command A+ Lands in Microsoft Foundry

Embedded content: Stop Stitching Models Together — Cohere Command A+ Lands in Microsoft Foundry – Taswar Bhatti

Here a blog post of mine that talks about Cohere Command A+ with sample code also in github. Read about how to get Cohere Command A+ up and running on Microsoft Foundry.

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

Have a wonderful Thursday 😉

Taswar

Newsletter

.net, AI, azure, Azure AI Foundry, Azure Weekly Digest, Cloud Computing, GitHub Copilot, Microsoft Azure, Networking

prompt.engineering.for.dot.net.developers

Prompt Engineering for .NET Developers

Taswar Bhatti July 20, 2026 No Comments

Most prompt engineering content out there assumes you’re writing Python. Jupyter notebooks, pip install, Conda environments — none of it maps to how most of us actually ship software.

If you’re a .NET developer who wants to build real AI-powered features — not toy demos — into your applications, I wrote a free ebook for exactly that: Prompt Engineering for .NET Developers.

Why I Wrote This

Every prompt engineering tutorial I found was Python-first. Meanwhile, Microsoft.Extensions.AI gives .NET developers a clean, unified abstraction over LLM providers — LM Studio, OpenAI, Azure AI Foundry — using the exact same IChatClient interface. There was no practical, runnable guide to prompt engineering that met C# developers where they already live.

So I built one.

What’s Inside

Seven focused chapters, each ending in a runnable C# project:

The .NET Developer’s AI Landscape — the cost spectrum and Microsoft’s AI stack
Setting Up Your AI Dev Environment — LM Studio, OpenAI, Azure AI Foundry, all via the same interface
How LLMs Work — just enough theory to write better prompts, no transformer lecture
Anatomy of a Great Prompt — you’ll build a fluent PromptBuilder class
Core Prompting Techniques — zero-shot, few-shot, chain-of-thought, and how to handle sycophancy (the silent failure mode where the model just tells you what you want to hear)
Structured Outputs and Advanced Patterns — defensive JSON parsing, streaming, resilience
Prompt Patterns for Real Developer Workflows — you’ll carry PromptBuilder into DevToolkit, a console app that does AI-powered code review, test generation, commit messages, and docs

No Jupyter. No Python. Just dotnet new console and code that runs.

Try It in 5 Minutes

git clone https://github.com/taswar/PromptEngineeringForDotNetDevelopers
cd PromptEngineeringForDotNetDevelopers/chapter-04/src/PromptBuilder
dotnet run

1

2

3

git clone https://github.com/taswar/PromptEngineeringForDotNetDevelopers

cd PromptEngineeringForDotNetDevelopers/chapter-04/src/PromptBuilder

dotnet run

That’s the PromptBuilder fluent class from Chapter 4, running against a local model — zero API cost.

Get It

📥 Download free on Leanpub (pay-what-you-want, including $0)
⭐ Star it on GitHub if it’s useful — it’s the best free way to help other .NET devs find it
🐛 Found a typo or have a suggestion? Open an issue

If you’ve been putting off learning prompt engineering because every guide assumes Python, this is for you. Would love to hear what you build with it — drop a comment or open a GitHub discussion.

.NET, AI

.net, AI, Azure AI Foundry, C#, Developer Tools, ebook, LM Studio, Microsoft.Extensions.AI, OpenAI, prompt engineering

5 Highlights Thursday | 16th July 2026 (#116 Edition)

Taswar Bhatti July 16, 2026 No Comments

Published: 2026-07-16
Source: https://www.linkedin.com/pulse/5-highlights-thursday-16th-july-2026-116-edition-taswar-bhatti-nj6df

Hope everyone is enjoying some summer break and here is the #116 edition of 5 Highlights Thursday. 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. Using GitHub Copilot for Linux performance troubleshooting on Azure

Watch this video on YouTube

Linux performance troubleshooting on Azure isn’t usually limited by a lack of data — it’s limited by knowing what to investigate next. In this session, Karl Abbott shows how GitHub Copilot can help move from performance signals to answers faster. Using a real Azure Linux VM scenario, he demonstrates how Copilot can diagnose high load, identify CPU saturation, connect signals across CPU, memory, and disk I/O, explain the root cause, apply a fix, and verify recovery. Join Karl Abbott where you’ll see how Copilot acts as a knowledgeable pair partner for Linux performance analysis — choosing diagnostic tools, interpreting output, and making troubleshooting knowledge easier to share across teams.

2. How Sprinklr leverages Microsoft Azure Cobalt 100 VMs for massive scale

Watch this video on YouTube

See how Sprinklr is transforming customer experience at global scale with Microsoft Azure Cobalt 100 VMs. By modernizing on Arm-based infrastructure, Sprinklr is boosting efficiency, lowering compute costs, and powering real-time insights across billions of customer interactions. Learn how Sprinklr and Microsoft are helping brands understand and serve customers better than ever.

3. Install & Configure the Azure Migrate Appliance: Discovery, Readiness & Business Case

Watch this video on YouTube

In this tutorial, you’ll learn how to install and configure the Azure Migrate appliance, run discovery of your VMware environment, assess migration readiness, generate a migration business case, and prepare your Azure landing zone.

4. Turning Coding Agents into an Azure Cosmos DB Expert with the Agent Kit

Watch this video on YouTube

In this Azure Friday episode, Scott Hanselman and Sajeetharan Sinnathurai demonstrate the Azure Cosmos DB Agent Kit — a skill you install with one command that gives your coding agent 100+ Cosmos DB best-practice rules across data modeling, partitioning, query optimization, and SDK usage and much more. Using a multi-agent fitness coaching app as an example, they show how the kit caught a missing partition key filter that was leaking member data across tenants, recommended hierarchical partitioning for multi-tenant scale, and fixed a fan-out query—all before the code shipped to production

5. Kimi K2.7 Code is Now Available in Microsoft Foundry

Embedded content: Kimi K2.7 Code is Now Available in Microsoft Foundry – Taswar Bhatti

Kimi K2 7B Code is now available in Microsoft Foundry, bringing strong code generation and development capabilities into the platform developers already use to build AI-powered applications. In this post, I walk through what Kimi K2 7B Code is, why it matters for developers, and how you can quickly get started experimenting with it in Foundry. If you’re exploring AI-assisted development, coding agents, or the latest open models in the Microsoft ecosystem, this is worth a look.

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 on LinkedIn

Have a wonderful Thursday 😉

Taswar

Newsletter

AI, azure, Azure AI Foundry, Azure Weekly Digest, Cloud Computing, Cost Optimization, Databases, GitHub Copilot, Microsoft Azure

5 Highlights Thursday | 9th July 2026 (#115 Edition)

Taswar Bhatti July 9, 2026 No Comments

Published: 2026-07-09
Source: https://www.linkedin.com/pulse/5-highlights-thursday-9th-july-2026-115-edition-taswar-bhatti-gwdjf

Hope everyone is enjoying some summer break and here is the #115 edition of 5 Highlights Thursday. 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. Discovering Power App Data with M365 Copilot using MCP | DEM360

Watch this video on YouTube

With millions of users world-wide, Power Apps and Dataverse now sit atop critical business data, but developers face challenges with discoverability and schema understanding. This session Christine Flora (her/she) introduces Power Apps Model Context Protocol (MCP), which empowers M365 Copilot to access app metadata, Dataverse schemas, relationships, and permissions. Learn how MCP enables Copilot to answer natural-language queries, aggregate data, and deliver real-time insights, plus best practices for Copilot-ready apps.

2. What are AI ‘hallucinations’ and can we fix LLMs so that they don’t happen?

Watch this video on YouTube

Can we eliminate AI hallucinations? Mark Russinovich explains why large language models make mistakes, what developers can do to reduce them, and why they remain a fundamental limitation of today’s AI systems.

3. Microsoft Defender: Extending critical protection for emerging threats in Team

Watch this video on YouTube

This episode dives into the attacks targeting Microsoft Teams—phishing, impersonation, malicious calls, and other social engineering techniques used by threat actors today. Dive in as Jeremy Beckley and Malvika Balaraj explain how Defender XDR detections are being developed to help SOC teams gain visibility into these attacks, and recent Microsoft Defender for Office 365 capabilities that help customers protect, detect, investigate, and respond to emerging Teams-based threats.

4. Meet Azure HorizonDB, the new Postgres on Azure

Watch this video on YouTube

Azure HorizonDB is a new Postgres service on Azure built for scale, availability, and performance across any workload. In this episode of Azure Friday, Scott Hanselman & Charles Feddersen look at how HorizonDB delivers predictable performance with built‑in zone resilience. They also explore new in‑database AI features like AI Model Management and AI Pipelines, and walk through the developer experience in VS Code to build, query, and manage efficiently using AI.

5. Microsoft Dataverse plugin: unleashing coding agents on the enterprise

Watch this video on YouTube

Coding agents are powerful, but without domain tooling they hallucinate and produce broken solutions. The Dataverse plugin solves this by giving AI agents guardrailed access to tables, columns, relationships, views, security and solutions. See how a natural language request triggers multi-step provisioning, data imports and validation. All executed autonomously. Join Elaiza Benitez , where Kent Weare
shows demos the plugin architecture, MCP server integration and patterns that make agent-driven Dataverse development reliable at scale.

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 on LinkedIn

Have a wonderful Thursday 😉

Taswar

Newsletter

AI, azure, Azure Weekly Digest, Cloud Computing, Databases, GitHub Copilot, Microsoft Azure, Microsoft Defender, Networking, PostgreSQL, security

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

2. Modernizing .NET Applications

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

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

5. .NET Developer Productivity with AI

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

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

What MAI-Thinking-1 Actually Is

Why This Matters for .NET Developers Specifically

Getting Started: The Boring Setup Part

A Multi-Step Reasoning Example

Sample output

Tool-Augmented Reasoning (The Agentic Part)

Output

Where This Fits (and Where It Doesn’t)

Wrapping Up

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

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

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

4. Microsoft Defender for Office 365 | Zero to Hero

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

6. How AMD and Azure Push the Boundaries of Compute

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

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

2. What’s New in SQL MCP Server 2.0

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

4. How Nationwide Stays Ahead of Attackers with Project Perception

5. Inside Codename MDASH: Built to Protect

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

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

What MAI-Voice-2 Flash Actually Does

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

Where This Fits — Real Use Cases

Pricing

Setting Up Azure Speech — Full Instructions

Step 1: Create a Speech Resource in Azure

Step 2: Get Your Key and Region

Step 3: Store Secrets Properly

Step 4: Install the Speech SDK

Let’s Actually Call It from C#

Program.cs — Basic Synthesis

Expected Output

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

Using SSML for Turn-Level Control — What Actually Works

What Does Work: Plain SSML for Voice, Pacing, and Pauses

Same Pattern in Turkish

Why Run It Through Azure Speech (Not a Separate Vendor)

Final Thoughts

Resources

What MAI-Image-2.5 Pro Actually Does

Why It Matters

Where This Fits — Real Use Cases

Let’s Actually Call It from C#

Prerequisites

Program.cs — Generate a Product Image

Editing an Existing Image — Targeted, Not a Full Regeneration

Expected Output

Why Run It Through Microsoft Foundry

Final Thoughts

Resources

1. Free Book – Prompt Engineering for .NET Developers

2. Build Agents you Can Trust on Windows

3. Claude Opus 4 + RAG: Build an AI App with Embeddings & Knowledge Graphs

4. Work IQ: Tooling with MCP & CLI

5. Stop Stitching Models Together — Cohere Command A+ Lands in Microsoft Foundry

Why I Wrote This

What’s Inside

Try It in 5 Minutes

Get It

1. Using GitHub Copilot for Linux performance troubleshooting on Azure

2. How Sprinklr leverages Microsoft Azure Cobalt 100 VMs for massive scale

3. Install & Configure the Azure Migrate Appliance: Discovery, Readiness & Business Case

4. Turning Coding Agents into an Azure Cosmos DB Expert with the Agent Kit

5. Kimi K2.7 Code is Now Available in Microsoft Foundry

1. Discovering Power App Data with M365 Copilot using MCP | DEM360

2. What are AI ‘hallucinations’ and can we fix LLMs so that they don’t happen?

3. Microsoft Defender: Extending critical protection for emerging threats in Team

4. Meet Azure HorizonDB, the new Postgres on Azure

5. Microsoft Dataverse plugin: unleashing coding agents on the enterprise

Opinions are my own and not the views of my employer