Kimi K2.7 Code is Now Available in Microsoft Foundry

Taswar Bhatti July 7, 2026 No Comments

Demo code located at https://github.com/taswar/KimiFoundryDemo

There are a lot of AI model announcements these days. But every now and then one lands that feels immediately practical for real engineering work.

Kimi K2.7 Code from Moonshot AI showing up in Microsoft Foundry feels like one of those releases.

Microsoft and Moonshot AI have made Kimi K2.7 Code available in the Foundry model catalog starting July 1, 2026. It is designed for the kind of software engineering that does not happen in a single prompt — multi-file refactors, feature work spanning multiple services, debugging sessions that need to hold context across many steps.

That is a different problem space from “generate a todo app in one shot.” And honestly, that is where most development teams are today.

What Is Kimi K2.7 Code?

Kimi K2.7 Code is a coding-focused model from Moonshot AI. It builds on the K2.6 series with three focused improvements:

Long-horizon task execution — carries work across multiple files, tools, and steps
Stronger end-to-end task completion — designed to finish tasks, not just generate fragments
~30% fewer thinking tokens vs K2.6 — faster responses, lower cost, more work per context window

The 256K context window is the other number worth noting. Large codebases, long refactoring sessions, multiple files in context at once — that is the use case this model is optimized for.

Benchmark Numbers — The Honest Read

Here is how K2.7 Code stacks up against K2.6 and two frontier models:

Kimi K27 Benchmark

A few things worth flagging:

The Kimi Code Bench numbers are Moonshot AI’s own benchmark — take those as directional. MCP Mark Verified is human-verified and more credible for independent comparison. On that benchmark, K2.7 Code at 81.1 actually beats Claude Opus 4.8 at 76.4. That is the benchmark most relevant to agentic coding workflows with tool use.

On pure coding tasks (Program Bench, MLS Bench Lite), it sits between GPT-5.5 and Claude Opus 4.8. That is a reasonable position for a model priced at $0.95 in p u t /$ 4.00 output per million tokens.

Pricing

At $0.95 input, this sits below GPT-4o-class pricing. For long-running coding tasks that consume a lot of output tokens, $4.00/M output is the number to watch. Cached input at $0.19 helps when you are repeatedly loading the same large codebase context.

	Input / 1M tokens	Output / 1M tokens	Cached Input
Kimi K2.7 Code	$0.95	$4.00	$0.19

Top Use Cases

If you are evaluating this model, here is where it fits:

Software engineering agents — multi-step planning, tool use, execution across a full development workflow
Repository-scale code understanding — analyze, modernize, or refactor large codebases while keeping context across many files
Complex feature implementation — changes that span multiple services, components, and repositories
Debugging and root cause analysis — deeper code understanding over multi-step investigation workflows

That is a pretty specific profile. This is not a general-purpose chatbot. It is a model built for developer tooling and autonomous coding agents.

Enough Theory. Let’s Actually Call It from C#

Here is a working .NET console app that calls Kimi K2.7 Code through Azure AI Foundry. I am using the Azure AI Inference SDK and DefaultAzureCredential — no API key hardcoded.

Prerequisites

dotnet new console -n KimiFoundryDemo
cd KimiFoundryDemo
dotnet add package Azure.AI.Inference --prerelease
dotnet add package Azure.Identity

1

2

3

4

dotnet new console -n KimiFoundryDemo

cd KimiFoundryDemo

dotnet add package Azure.AI.Inference --prerelease

dotnet add package Azure.Identity

Set your environment variables:

# On Windows (PowerShell)
$env:AZURE_AI_CHAT_ENDPOINT="https://YOUR-RESOURCE.services.ai.azure.com/models"
az login

1

2

3

# On Windows (PowerShell)

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

az login

Program.cs

using Azure.Identity;
using Azure;
using Azure.AI.Inference;
using Azure.Core;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT")
    ?? throw new InvalidOperationException("Set AZURE_AI_CHAT_ENDPOINT environment variable.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "Kimi-K2.7-Code";

// DefaultAzureCredential handles Entra ID auth — no API key in code.
// Sign in first with: az login
var credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions
{
    ExcludeManagedIdentityCredential = true
});

// Foundry (Cognitive Services) endpoints require a token whose audience is
// https://cognitiveservices.azure.com. Force that scope regardless of the
// scope the Azure.AI.Inference SDK requests by default.
var scopedCredential = new ScopeOverrideCredential(
    credential, "https://cognitiveservices.azure.com/.default");

var client = new ChatCompletionsClient(new Uri(endpoint), scopedCredential);

var options = new ChatCompletionsOptions
{
    Model = model,
    Temperature = 0.2f,
    MaxTokens = 2000
};

options.Messages.Add(new ChatRequestSystemMessage(
    """
    You are a senior .NET architect.
    Your job is to review code and identify issues clearly and concisely.
    Be direct. Prioritize correctness over style.
    Return findings as a numbered list with severity: critical, warning, or info.
    """));

options.Messages.Add(new ChatRequestUserMessage(
    """
    Review the following C# method and identify any issues:
 
    public async Task GetUserAsync(int userId)
    {
        var user = await _dbContext.Users
            .Where(u => u.Id == userId)
            .FirstOrDefault();
 
        return user;
    }
    """));

Console.WriteLine($"Calling model: {model}");
Console.WriteLine("---");

Response<ChatCompletions> response = client.Complete(options);
System.Console.WriteLine(response.Value.Content);


// Wraps a TokenCredential and forces a fixed audience/scope, ignoring the
// scope the client pipeline asks for.
sealed class ScopeOverrideCredential : TokenCredential
{
    private readonly TokenCredential _inner;
    private readonly string[] _scopes;

    public ScopeOverrideCredential(TokenCredential inner, string scope)
    {
        _inner = inner;
        _scopes = new[] { scope };
    }

    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
        => _inner.GetToken(new TokenRequestContext(_scopes), cancellationToken);

    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
        => _inner.GetTokenAsync(new TokenRequestContext(_scopes), cancellationToken);
}

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

68

69

70

71

72

73

74

75

76

77

78

79

80

using Azure.Identity;

using Azure;

using Azure.AI.Inference;

using Azure.Core;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT")

?? throw new InvalidOperationException("Set AZURE_AI_CHAT_ENDPOINT environment variable.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "Kimi-K2.7-Code";

// DefaultAzureCredential handles Entra ID auth — no API key in code.

// Sign in first with: az login

var credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions

{

ExcludeManagedIdentityCredential = true

});

// Foundry (Cognitive Services) endpoints require a token whose audience is

// https://cognitiveservices.azure.com. Force that scope regardless of the

// scope the Azure.AI.Inference SDK requests by default.

var scopedCredential = new ScopeOverrideCredential(

credential, "https://cognitiveservices.azure.com/.default");

var client = new ChatCompletionsClient(new Uri(endpoint), scopedCredential);

var options = new ChatCompletionsOptions

{

Model = model,

Temperature = 0.2f,

MaxTokens = 2000

};

options.Messages.Add(new ChatRequestSystemMessage(

"""

You are a senior .NET architect.

Your job is to review code and identify issues clearly and concisely.

Be direct. Prioritize correctness over style.

Return findings as a numbered list with severity: critical, warning, or info.

"""));

options.Messages.Add(new ChatRequestUserMessage(

"""

Review the following C# method and identify any issues:

public async Task GetUserAsync(int userId)

{

var user = await _dbContext.Users

.Where(u => u.Id == userId)

.FirstOrDefault();

return user;

}

"""));

Console.WriteLine($"Calling model: {model}");

Console.WriteLine("---");

Response<ChatCompletions> response = client.Complete(options);

System.Console.WriteLine(response.Value.Content);

// Wraps a TokenCredential and forces a fixed audience/scope, ignoring the

// scope the client pipeline asks for.

sealed class ScopeOverrideCredential : TokenCredential

{

private readonly TokenCredential _inner;

private readonly string[] _scopes;

public ScopeOverrideCredential(TokenCredential inner, string scope)

{

_inner = inner;

_scopes = new[] { scope };

}

public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)

=> _inner.GetToken(new TokenRequestContext(_scopes), cancellationToken);

public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)

=> _inner.GetTokenAsync(new TokenRequestContext(_scopes), cancellationToken);

}

Expected Output

I am running az login so that I am not using API_KEY

Something like:

Calling model: kimi-k2-7-code
---
1. **Critical — `Task` return type does not match returned value**  
   The method returns `user`, but the signature returns non-generic `Task`. Change it to `Task<User?>` (or `Task<User>` if nullability is disabled).

2. **Critical — Synchronous `FirstOrDefault` used in an async method**  
   `.FirstOrDefault()` executes the query synchronously and is not awaitable. Use `.FirstOrDefaultAsync()` (and pass a `CancellationToken`).

3. **Warning — Missing `CancellationToken`**  
   Async methods should accept `CancellationToken cancellationToken = default` and forward it to `FirstOrDefaultAsync(cancellationToken)`.

4. **Info — Consider `FindAsync` for primary-key lookups**  
   Since the query is by primary key, `_dbContext.Users.FindAsync(userId, cancellationToken)` is more idiomatic and can be faster due to EF change-tracker short-circuiting.

1

2

3

4

5

6

7

8

9

10

11

12

13

Calling model: kimi-k2-7-code

---

1. **Critical — `Task` return type does not match returned value**

The method returns `user`, but the signature returns non-generic `Task`. Change it to `Task<User?>` (or `Task<User>` if nullability is disabled).

2. **Critical — Synchronous `FirstOrDefault` used in an async method**

`.FirstOrDefault()` executes the query synchronously and is not awaitable. Use `.FirstOrDefaultAsync()` (and pass a `CancellationToken`).

3. **Warning — Missing `CancellationToken`**

Async methods should accept `CancellationToken cancellationToken = default` and forward it to `FirstOrDefaultAsync(cancellationToken)`.

4. **Info — Consider `FindAsync` for primary-key lookups**

Since the query is by primary key, `_dbContext.Users.FindAsync(userId, cancellationToken)` is more idiomatic and can be faster due to EF change-tracker short-circuiting.

That is the kind of output you want from a code review tool — specific, actionable, severity-tagged.

Why Run It in Foundry vs Directly?

If you are already in Azure, Foundry gives you a few things you do not get with a direct Moonshot API key:

Enterprise security and compliance — governance, data protection, responsible AI tooling built in
Side-by-side evaluation — compare Kimi K2.7 Code against GPT-5.5, Claude Opus 4.8, or any other Foundry model using the same evaluation dataset
GitHub Copilot and VS Code integration — native compatibility with the developer tools your team already uses
No separate infrastructure — model is already deployed, monitored, and scaled for you

That last point matters more than it sounds. The jump from “I tried this in a notebook” to “this is running in our CI pipeline” is usually infrastructure, not capability. Foundry removes that friction.

Final Thoughts

Kimi K2.7 Code in Microsoft Foundry is interesting for developers because it is not just a benchmark improvement. It is a model positioned for the kind of work that is genuinely hard to automate well: long-running, multi-step, multi-file engineering tasks.

The MCP Mark Verified score beating Claude Opus 4.8 is the number I would keep an eye on as agentic coding workflows mature. If your team is building AI-assisted developer tooling or coding agents, this is one worth evaluating.

If you are already on Azure AI Foundry, the model is in the catalog now. Start with the C# code above, swap in your own endpoint, and run it against a real method from your codebase. That will tell you more than any benchmark.

Resources

Cohere Command A-Plus Lands in Microsoft Foundry

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

Taswar Bhatti June 26, 2026 No Comments

Sample code located at https://github.com/taswar/CohereCommandAPlusDemo

Enterprise AI teams have a familiar problem. You need multilingual support because your users are in Germany, Japan, and Brazil. You need document understanding because half your data lives in scanned PDFs and screenshots. You need tool calling because your agents have to actually do things, not just talk about them. And you need reasoning across long contexts because business decisions rarely fit in 4K tokens.

Historically, that meant stitching together three or four models. One for translation. One for OCR. One for reasoning. Something in the middle to orchestrate all of it. That is a lot of moving parts to keep in production.

Cohere Command A+ in Microsoft Foundry is designed to collapse that stack.

Announced as a Direct from Azure model, Command A+ is Cohere’s latest open enterprise model — and their first mixture-of-experts (MoE) architecture. It brings together reasoning, long-context understanding, tool use, multilingual support, and multimodal input in a single model.

Honestly, this is the sort of release that matters more than the benchmark numbers suggest.

What Makes Command A+ Different

Three things are worth understanding before you evaluate this model.

It is a Mixture-of-Experts Model

218 billion total parameters. 25 billion active per token. That is roughly 11.5% activation.

If you have not worked with MoE architectures before, the short version: instead of every token going through every parameter, the model routes each token to a subset of “expert” sub-networks. You get the knowledge coverage of a large model at the inference cost of a much smaller one.

For enterprise workloads, this matters. Cohere lists hardware requirements of 1× B200 or 2× H100 at W4A4 quantization. That is a genuinely deployable footprint for a model with this level of capability.

It Speaks 48 Languages

Not “supports” — actually speaks. All official EU languages included. If you are building for a global enterprise, that is a compliance requirement in many places, not a nice-to-have.

It Handles Text and Images Together

Command A+ accepts text and image inputs. That opens up document processing scenarios where the useful information lives in charts, tables, screenshots, or scanned records — not just plain text.

The Full Spec Sheet

cohere_foundry_spec_table

Where This Model Actually Fits

Cohere positions Command A+ for four workload types. Each one lines up with a real problem developers deal with in production.

1. Enterprise Agents

Agents that reason, plan, and call tools across multi-step workflows. Command A+ handles all four capabilities — reasoning, planning, tool use, and long context — in one model. If you are building agentic systems today with three different models glued together, this is worth evaluating as a consolidation play.

2. Knowledge Assistants and RAG

RAG applications over internal documents, policies, contracts, and knowledge bases. The 128K context window means you can fit a lot of retrieved chunks into a single call without aggressive truncation. Combined with multilingual support, this is well suited to global enterprises where the same knowledge base needs to answer questions in multiple languages.

3. Document Analysis Workflows

Summarising reports, extracting terms from contracts, comparing policies, analysing research papers. The multimodal input means it handles documents that mix text with charts, tables, and images — the kind of enterprise content where “just OCR it and pass to an LLM” produces bad results.

4. Multilingual Applications

Global customer support. Regional compliance reporting. Cross-market analytics. Command A+ was designed with 48-language coverage as a first-class feature, not a translation layer bolted on afterward.

That is a pretty focused positioning. This is not a general-purpose chatbot model — it is an enterprise agent and document processing model.

Enough Theory. Let’s Actually Call It from C#

Here is a working .NET console app that calls Command A+ through Azure AI Foundry. I am using the Azure AI Inference SDK with DefaultAzureCredential for Entra ID auth — no API keys in code.

Prerequisites

dotnet new console -n CohereCommandAPlusDemo
cd CohereCommandAPlusDemo
dotnet add package Azure.AI.Inference --prerelease
dotnet add package Azure.Identity

1

2

3

4

dotnet new console -n CohereCommandAPlusDemo

cd CohereCommandAPlusDemo

dotnet add package Azure.AI.Inference --prerelease

dotnet add package Azure.Identity

Set your environment variables:

# On Windows (PowerShell)
$env:AZURE_AI_CHAT_ENDPOINT = "https://YOUR-RESOURCE.services.ai.azure.com/models"
$env:AZURE_AI_MODEL = "cohere-command-a-plus"

1

2

3

# On Windows (PowerShell)

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

$env:AZURE_AI_MODEL = "cohere-command-a-plus"

Program.cs — Contract Analysis Example

Rather than a “tell me a joke” demo, let’s do something that actually shows what Command A+ is good at. Here is a service that analyses a business contract and returns a structured summary — the kind of workflow you might drop into a document management pipeline.

using Azure.AI.Inference;
using Azure.Identity;
using Azure.Core;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT")
    ?? throw new InvalidOperationException("Set AZURE_AI_CHAT_ENDPOINT environment variable.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "cohere-command-a-plus";

// DefaultAzureCredential handles Entra ID auth — no API key in code.
// Sign in first with: az login
var credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions
{
    ExcludeManagedIdentityCredential = true
});

// Foundry (Cognitive Services) endpoints require a token whose audience is
// https://cognitiveservices.azure.com. Force that scope regardless of the
// scope the Azure.AI.Inference SDK requests by default.
var scopedCredential = new ScopeOverrideCredential(
    credential, "https://cognitiveservices.azure.com/.default");

var client = new ChatCompletionsClient(new Uri(endpoint), scopedCredential);

var options = new ChatCompletionsOptions
{
    Model = model,
    Temperature = 0.1f,
    MaxTokens = 2000
};

options.Messages.Add(new ChatRequestSystemMessage(
    """
    You are a senior contracts analyst reviewing enterprise agreements.
 
    Your job is to extract key terms and flag risks. Be precise and cite the exact
    contract language when identifying issues. If a required clause is missing,
    say so explicitly rather than guessing at its content.
 
    Return your analysis as structured JSON with these fields:
    -parties: array of parties to the agreement
    - effective_date: string or "not specified"
    - term_length: string or "not specified"
    - renewal_terms: string or "not specified"
    - key_obligations: array of strings
    - liability_cap: string or "not specified"
    - termination_clauses: array of strings
    - risks: array of { severity: "high"|"medium"|"low", description: string}
    """));

options.Messages.Add(new ChatRequestUserMessage(
    """
    Analyze the following service agreement excerpt:
 
    ---
    SOFTWARE LICENSING AGREEMENT
 
    This Agreement is entered into on 1 August 2026 between Zeytin Software Ltd
    ("Licensor") and GlobalCorp Industries GmbH ("Licensee").
 
    1.LICENSE GRANT.Licensor grants Licensee a non-exclusive, non-transferable
       license to use the Software during the Term.
 
    2. TERM. This Agreement shall commence on the Effective Date and continue
       for an initial period of three (3) years, automatically renewing for
       successive one (1) year periods unless either party provides ninety (90)
       days written notice of non-renewal.
 
    3. FEES. Licensee shall pay an annual license fee of EUR 250,000.
 
    4. LIABILITY. IN NO EVENT SHALL LICENSOR'S AGGREGATE LIABILITY EXCEED THE
       FEES PAID BY LICENSEE IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
 
    5. TERMINATION. Either party may terminate this Agreement for material
       breach if such breach is not cured within thirty (30) days of written
       notice.
    ---
    """));

Console.WriteLine($"Calling model: {model}");
Console.WriteLine("---");

var response = await client.CompleteAsync(options);

Console.WriteLine(response.Value.Content);


// Wraps a TokenCredential and forces a fixed audience/scope, ignoring the
// scope the client pipeline asks for.
sealed class ScopeOverrideCredential : TokenCredential
{
    private readonly TokenCredential _inner;
    private readonly string[] _scopes;

    public ScopeOverrideCredential(TokenCredential inner, string scope)
    {
        _inner = inner;
        _scopes = new[] { scope };
    }

    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
        => _inner.GetToken(new TokenRequestContext(_scopes), cancellationToken);

    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
        => _inner.GetTokenAsync(new TokenRequestContext(_scopes), cancellationToken);
}

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

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

using Azure.AI.Inference;

using Azure.Identity;

using Azure.Core;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT")

?? throw new InvalidOperationException("Set AZURE_AI_CHAT_ENDPOINT environment variable.");

var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "cohere-command-a-plus";

// DefaultAzureCredential handles Entra ID auth — no API key in code.

// Sign in first with: az login

var credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions

{

ExcludeManagedIdentityCredential = true

});

// Foundry (Cognitive Services) endpoints require a token whose audience is

// https://cognitiveservices.azure.com. Force that scope regardless of the

// scope the Azure.AI.Inference SDK requests by default.

var scopedCredential = new ScopeOverrideCredential(

credential, "https://cognitiveservices.azure.com/.default");

var client = new ChatCompletionsClient(new Uri(endpoint), scopedCredential);

var options = new ChatCompletionsOptions

{

Model = model,

Temperature = 0.1f,

MaxTokens = 2000

};

options.Messages.Add(new ChatRequestSystemMessage(

"""

You are a senior contracts analyst reviewing enterprise agreements.

Your job is to extract key terms and flag risks. Be precise and cite the exact

contract language when identifying issues. If a required clause is missing,

say so explicitly rather than guessing at its content.

Return your analysis as structured JSON with these fields:

-parties: array of parties to the agreement

- effective_date: string or "not specified"

- term_length: string or "not specified"

- renewal_terms: string or "not specified"

- key_obligations: array of strings

- liability_cap: string or "not specified"

- termination_clauses: array of strings

- risks: array of { severity: "high"|"medium"|"low", description: string}

"""));

options.Messages.Add(new ChatRequestUserMessage(

"""

Analyze the following service agreement excerpt:

---

SOFTWARE LICENSING AGREEMENT

This Agreement is entered into on 1 August 2026 between Zeytin Software Ltd

("Licensor") and GlobalCorp Industries GmbH ("Licensee").

1.LICENSE GRANT.Licensor grants Licensee a non-exclusive, non-transferable

license to use the Software during the Term.

2. TERM. This Agreement shall commence on the Effective Date and continue

for an initial period of three (3) years, automatically renewing for

successive one (1) year periods unless either party provides ninety (90)

days written notice of non-renewal.

3. FEES. Licensee shall pay an annual license fee of EUR 250,000.

4. LIABILITY. IN NO EVENT SHALL LICENSOR'S AGGREGATE LIABILITY EXCEED THE

FEES PAID BY LICENSEE IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.

5. TERMINATION. Either party may terminate this Agreement for material

breach if such breach is not cured within thirty (30) days of written

notice.

---

"""));

Console.WriteLine($"Calling model: {model}");

Console.WriteLine("---");

var response = await client.CompleteAsync(options);

Console.WriteLine(response.Value.Content);

// Wraps a TokenCredential and forces a fixed audience/scope, ignoring the

// scope the client pipeline asks for.

sealed class ScopeOverrideCredential : TokenCredential

{

private readonly TokenCredential _inner;

private readonly string[] _scopes;

public ScopeOverrideCredential(TokenCredential inner, string scope)

{

_inner = inner;

_scopes = new[] { scope };

}

public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)

=> _inner.GetToken(new TokenRequestContext(_scopes), cancellationToken);

public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)

=> _inner.GetTokenAsync(new TokenRequestContext(_scopes), cancellationToken);

}

Expected Output

Command A+ should return something like:

Calling model: Cohere-command-a-plus-05-2026
---
```json
{
  "parties": [
    "Zeytin Software Ltd (Licensor)",
    "GlobalCorp Industries GmbH (Licensee)"
  ],
  "effective_date": "1 August 2026",
  "term_length": "3 years (initial)",
  "renewal_terms": "Automatic renewal for successive one-year periods unless either party provides ninety (90) days written notice of non-renewal.",
  "key_obligations": [
    "Licensor grants Licensee a non-exclusive, non-transferable license to use the Software during the Term.",
    "Licensee shall pay an annual license fee of EUR 250,000."
  ],
  "liability_cap": "Licensor's aggregate liability is capped at the fees paid by Licensee in the twelve (12) months preceding the claim.",
  "termination_clauses": [
    "Either party may terminate for material breach if the breach is not cured within thirty (30) days after written notice.",
    "Non-renewal terminates the Agreement upon provision of ninety (90) days written notice."
  ],
  "risks": [
    {
      "severity": "high",
      "description": "Liability cap limited to fees paid in the prior 12 months may be insufficient to cover actual damages, exposing Licensee to significant risk if a major incident occurs."
    },
    {
      "severity": "high",
      "description": "Material breach clause lacks definition of what constitutes a material breach, creating uncertainty and potential disputes over termination rights."
    },
    {
      "severity": "high",
      "description": "No provision for warranties, indemnities, or remedies for software defects, leaving Licensee without recourse for faulty software."
    },
    {
      "severity": "medium",
      "description": "Governing law and dispute resolution mechanisms are absent, which may complicate enforcement and litigation."
    },
    {
      "severity": "medium",
      "description": "No confidentiality or data protection provisions, increasing risk of unauthorized disclosure or misuse of sensitive information."
    },
    {
      "severity": "medium",
      "description": "License is non-transferable, limiting Licensee's ability to assign or sublicense the software in future corporate restructurings."
    },
    {
      "severity": "low",
      "description": "Automatic renewal may lead to unintended continued licensing if the parties forget to provide the ninety‑day non‑renewal notice."
    }
  ]
}
```

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

Calling model: Cohere-command-a-plus-05-2026

---

```json

{

"parties": [

"Zeytin Software Ltd (Licensor)",

"GlobalCorp Industries GmbH (Licensee)"

],

"effective_date": "1 August 2026",

"term_length": "3 years (initial)",

"renewal_terms": "Automatic renewal for successive one-year periods unless either party provides ninety (90) days written notice of non-renewal.",

"key_obligations": [

"Licensor grants Licensee a non-exclusive, non-transferable license to use the Software during the Term.",

"Licensee shall pay an annual license fee of EUR 250,000."

],

"liability_cap": "Licensor's aggregate liability is capped at the fees paid by Licensee in the twelve (12) months preceding the claim.",

"termination_clauses": [

"Either party may terminate for material breach if the breach is not cured within thirty (30) days after written notice.",

"Non-renewal terminates the Agreement upon provision of ninety (90) days written notice."

],

"risks": [

{

"severity": "high",

"description": "Liability cap limited to fees paid in the prior 12 months may be insufficient to cover actual damages, exposing Licensee to significant risk if a major incident occurs."

},

{

"severity": "high",

"description": "Material breach clause lacks definition of what constitutes a material breach, creating uncertainty and potential disputes over termination rights."

},

{

"severity": "high",

"description": "No provision for warranties, indemnities, or remedies for software defects, leaving Licensee without recourse for faulty software."

},

{

"severity": "medium",

"description": "Governing law and dispute resolution mechanisms are absent, which may complicate enforcement and litigation."

},

{

"severity": "medium",

"description": "No confidentiality or data protection provisions, increasing risk of unauthorized disclosure or misuse of sensitive information."

},

{

"severity": "medium",

"description": "License is non-transferable, limiting Licensee's ability to assign or sublicense the software in future corporate restructurings."

},

{

"severity": "low",

"description": "Automatic renewal may lead to unintended continued licensing if the parties forget to provide the ninety‑day non‑renewal notice."

}

]

}

```

That is structured, actionable output — the kind of thing you can pipe directly into a downstream review workflow or store as document metadata.

Multilingual Example — Same Prompt, Different Language

One of the more interesting things about Command A+ is that you can run the same structured prompt with content in any of 48 languages and get consistent output structure back. Here is the same analysis pattern with a German contract excerpt:

options.Messages.Clear();

Console.WriteLine($"Calling Multilingual: {model}");

options.Messages.Add(new ChatRequestSystemMessage(
    """
    You are a senior contracts analyst. Return your analysis in English JSON
    even if the source contract is in another language.
    """));

options.Messages.Add(new ChatRequestUserMessage(
    """
    Analysiere den folgenden Vertragsauszug:
 
    ---
    DIENSTLEISTUNGSVERTRAG


    Dieser Vertrag wird zwischen der Zeytin Software GmbH (&quot; Auftragnehmer & quot;)
    und der Berliner Handelsgesellschaft mbH (&quot; Auftraggeber & quot;) geschlossen.
 
    § 1 VERTRAGSGEGENSTAND.Der Auftragnehmer verpflichtet sich zur Bereitstellung
    von Softwareentwicklungsleistungen.
 
    § 2 LAUFZEIT. Der Vertrag beginnt am 15. September 2026 und läuft für eine
    Erstlaufzeit von zwei (2) Jahren.
 
    § 3 VERGÜTUNG. Der Auftraggeber zahlt einen monatlichen Betrag von EUR 18.500
    zzgl. gesetzlicher Umsatzsteuer.
 
    § 4 KÜNDIGUNG. Der Vertrag kann von beiden Seiten mit einer Frist von drei
    Monaten zum Ende eines Kalenderjahres gekündigt werden.
    ---
    """));

response = await client.CompleteAsync(options);
Console.WriteLine(response.Value.Content);

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

options.Messages.Clear();

Console.WriteLine($"Calling Multilingual: {model}");

options.Messages.Add(new ChatRequestSystemMessage(

"""

You are a senior contracts analyst. Return your analysis in English JSON

even if the source contract is in another language.

"""));

options.Messages.Add(new ChatRequestUserMessage(

"""

Analysiere den folgenden Vertragsauszug:

---

DIENSTLEISTUNGSVERTRAG

Dieser Vertrag wird zwischen der Zeytin Software GmbH (" Auftragnehmer & quot;)

und der Berliner Handelsgesellschaft mbH (" Auftraggeber & quot;) geschlossen.

§ 1 VERTRAGSGEGENSTAND.Der Auftragnehmer verpflichtet sich zur Bereitstellung

von Softwareentwicklungsleistungen.

§ 2 LAUFZEIT. Der Vertrag beginnt am 15. September 2026 und läuft für eine

Erstlaufzeit von zwei (2) Jahren.

§ 3 VERGÜTUNG. Der Auftraggeber zahlt einen monatlichen Betrag von EUR 18.500

zzgl. gesetzlicher Umsatzsteuer.

§ 4 KÜNDIGUNG. Der Vertrag kann von beiden Seiten mit einer Frist von drei

Monaten zum Ende eines Kalenderjahres gekündigt werden.

---

"""));

response = await client.CompleteAsync(options);

Console.WriteLine(response.Value.Content);

Sample output of Multilingual

Calling Multilingual: Cohere-command-a-plus-05-2026 { "contract_type": "Service Agreement", "parties": { "contractor": "Zeytin Software GmbH", "client": "Berliner Handelsgesellschaft mbH" }, "subject_matter": "Contractor agrees to provide software development services.", "term": { "start_date": "2026-09-15", "initial_term": "2 years" }, "compensation": { "amount_per_month": 18500, "currency": "EUR", "taxes": "plus statutory VAT" }, "termination": { "notice_period": "3 months", "termination_date_alignment": "end of calendar year", "available_to": "both parties" }, "key_provisions": [ "Monthly payment of €18,500 plus VAT.", "Either party may terminate with 3 months' notice to the end of a calendar year." ], "risk_assessment": { "early_termination_risk": "Since the contract starts on 15 September 2026, the first possible termination date is 31 December 2026, requiring notice by 30 September 2026 – only 15 days after commencement.", "scope_ambiguity": "The contract does not define the scope of software development services, deliverables, milestones, or acceptance criteria.", "payment_structure": "Fixed monthly fee without performance-based adjustments; no provision for price revisions or inflation." }, "recommendations": [ "Define service scope, deliverables, milestones, and acceptance criteria in an annex or statement of work.", "Consider adding a price review clause (e.g., annual adjustment based on CPI).", "Clarify whether termination notices must be in writing and specify the exact method of delivery.", "Include governing law and dispute resolution provisions explicitly.", "Address intellectual property rights, confidentiality, and data protection obligations." ] }

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

Calling Multilingual: Cohere-command-a-plus-05-2026
{
  "contract_type": "Service Agreement",
  "parties": {
    "contractor": "Zeytin Software GmbH",
    "client": "Berliner Handelsgesellschaft mbH"
  },
  "subject_matter": "Contractor agrees to provide software development services.",
  "term": {
    "start_date": "2026-09-15",
    "initial_term": "2 years"
  },
  "compensation": {
    "amount_per_month": 18500,
    "currency": "EUR",
    "taxes": "plus statutory VAT"
  },
  "termination": {
    "notice_period": "3 months",
    "termination_date_alignment": "end of calendar year",
    "available_to": "both parties"
  },
  "key_provisions": [
    "Monthly payment of €18,500 plus VAT.",
    "Either party may terminate with 3 months' notice to the end of a calendar year."
  ],
  "risk_assessment": {
    "early_termination_risk": "Since the contract starts on 15 September 2026, the first possible termination date is 31 December 2026, requiring notice by 30 September 2026 – only 15 days after commencement.",
    "scope_ambiguity": "The contract does not define the scope of software development services, deliverables, milestones, or acceptance criteria.",
    "payment_structure": "Fixed monthly fee without performance-based adjustments; no provision for price revisions or inflation."
  },
  "recommendations": [
    "Define service scope, deliverables, milestones, and acceptance criteria in an annex or statement of work.",
    "Consider adding a price review clause (e.g., annual adjustment based on CPI).",
    "Clarify whether termination notices must be in writing and specify the exact method of delivery.",
    "Include governing law and dispute resolution provisions explicitly.",
    "Address intellectual property rights, confidentiality, and data protection obligations."
  ]
}

You get the same JSON structure back, with German-language terms parsed correctly and the analysis delivered in English. That is genuinely useful for global enterprises where legal teams work in local languages but reporting rolls up centrally.

Why Run It on Microsoft Foundry Instead of Cohere Direct?

Cohere offers Command A+ through their own API and on Hugging Face under Apache 2.0. So why bother with Foundry?

If you are already in Azure, Foundry gives you a few things you cannot easily replicate elsewhere:

Entra ID authentication — no API keys in source, no separate credential management
Enterprise governance — data residency, compliance, audit logging built into the platform
Side-by-side model evaluation — compare Command A+ against Kimi K2.7 Code, Claude Opus 4.8, or GPT-4o on the same dataset without setting up multiple SDKs
Unified billing — one Azure invoice covers all models, not one bill per vendor
Foundry Agent Service and RAG pipelines — plug Command A+ directly into Foundry’s agentic infrastructure

For an enterprise team already invested in Azure, Foundry is the easier operational choice. For solo experimentation or non-Azure deployments, direct API or self-hosting on Hugging Face makes sense too.

Final Thoughts

Command A+ is not the flashiest model announcement of the year. It is not going to top general-purpose benchmarks. But it is genuinely positioned for a class of enterprise problems that have been underserved: multilingual agentic workflows over multimodal documents at reasonable cost.

If your team is building enterprise agents, RAG applications, or document analysis pipelines — especially with multilingual requirements — this is worth evaluating alongside your existing models. At $0.80 input / $3.20 output per million tokens, it is priced to compete for real production workloads.

The MoE architecture is also worth watching more broadly. Expect more of the frontier lab releases over the next 12 months to go this route. Command A+ is an early mainstream option to build intuition against.

If your team already builds RAG over internal documents, ships multilingual applications, or runs agentic workflows in production — this is one worth wiring into your evaluation harness. 🙂

Resources

5 Highlights Thursday | 25th June 2026 (#114 Edition)

Taswar Bhatti June 25, 2026 No Comments

Published: 2026-06-25
Source: https://www.linkedin.com/pulse/5-highlights-thursday-25th-june-2026-114-edition-taswar-bhatti-lopgf

Here is the #114 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. From Dev to Prod: Securing Postgres the Right Way

Watch this video on YouTube

Learn how to secure Postgres from common blind spots across development and production. Sakshi Nasha ☁️ a (Software engineer) shares her approach in her talk “From Dev to Prod: Securing Postgres the Right Way” at POSETTE: An Event for Postgres 2026.

2. pg_duckdb in Action: Accelerating Analytics on Azure Database for PostgreSQL

Watch this video on YouTube

See how pg_duckdb enables analytics directly in Postgres. Nitin Jadhav (Microsoft) demonstrates this in his talk “pg_duckdb in Action: Accelerating Analytics on Azure Database for PostgreSQL” at POSETTE: An Event for Postgres 2026.

3. My Postgres partitioning cookbook

Watch this video on YouTube

Avoid years of partitioning mistakes in Postgres. Derk van Veen (Adyen) shares lessons in his talk “My Postgres partitioning cookbook” at POSETTE: An Event for Postgres 2026.

4. .NET Day of Agentic Modernization 2026

Watch this video on YouTube

Four-Hour video on all kinds of topics on Agentic Modernization.

5.MFA Everywhere: Closing the Legacy Gap in Your Essential 8 Strategy is now available

Watch this video on YouTube

Most organizations enforce MFA for cloud apps, but attackers rarely stop there. RDP sessions, VPNs, on-prem apps, and service desks are often the real entry points exploited in modern attacks. In this session join Deepika Mahankali, Andres Canello, Vik Verma CISSP, Jai Maharaj & Merill Fernando as they show how to extend MFA to these critical areas without overhauling your existing infrastructure, helping you strengthen identity security and move toward Essential 8 Maturity Level 2 and beyond. Learn why these gaps are targeted and how to expand MFA coverage with practical, low-disruption approaches.

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

.net, AI, AKS, azure, Azure Weekly Digest, Cloud Computing, Databases, Kubernetes, Microsoft Azure, PostgreSQL, security

5 Highlights Thursday | 11th June 2026 (#113 Edition)

Taswar Bhatti June 11, 2026 No Comments

Published: 2026-06-11
Source: https://www.linkedin.com/pulse/5-highlights-thursday-11th-june-2026-113-edition-taswar-bhatti-bxojf

Here is the #113 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. Microsoft Build 2026 Day 2 LIVE | GitHub Copilot, VS Code, Foundry & Community Sessions

Watch this video on YouTube

You could watch Microsoft Build 2026 Day 2 on YouTube if you missed it! Start your morning with GitHub, VS Code, and everything Copilot, then dive into a full day of live programming and breakouts.

2. Scott and Mark learn…how agents reshape software engineering

Watch this video on YouTube

Join Scott Hanselman & Mark Russinovich on this Breakout session on how AI is changing how software is created—and what it means to be a software engineer. We’ll explore how AI agents are reshaping development: where they accelerate progress, where they fall short, and what’s changing for the profession. Along the way, we’ll share failure modes, lessons learned, and propose ways engineers and organizations can adapt. Real talk, no hype.

3. Scott and Mark learn to Vibe Check with Steve Sanderson

Watch this video on YouTube

Join Steve Sanderson & Scott Hanselman on how AI can turn an idea into a working demo faster than ever. But can that demo survive two experts who have seen every trick in the book? In this live Build showcase, developers present AI-assisted apps, agents, tools, and workflows to Mark Russinovich and Scott Hanselman. Mark and Scott will ask how it works, where the seams are, what the AI actually built, and whether the result is clever prototype, production-ready software, or something unexpectedly magical. Come for the demos. Stay for the technical reveal.

4. Fluent UI Blazor: The next step

Watch this video on YouTube

In this session, Denis Voituron and Vincent Baaij will show you what is new in the next major version of the Microsoft Fluent UI Blazor library.

5. One policy engine to govern them all: Securing agentic AI with Microsoft Purview

Watch this video on YouTube

In this episode, returning expert guest Innocent Wafula joins us to explore how organizations can securely scale Agentic AI across platforms using Microsoft Purview as the centralized policy engine. Through a live architecture walkthrough, you’ll see how agents built on Microsoft Foundry and AWS Bedrock can leverage the same Purview instance for real-time policy evaluation and unified data protection. Learn how a “build anywhere, govern once” approach empowers developers to innovate faster while enabling security teams to maintain centralized control over sensitive data.

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

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

5 Highlights Thursday | 4th June 2026 (#112 Edition)

Taswar Bhatti June 4, 2026 No Comments

Published: 2026-06-04
Source: https://www.linkedin.com/pulse/5-highlights-thursday-4th-june-2026-112-edition-taswar-bhatti-uac1f

Here is the #112 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. Microsoft Build 2026 Day 1 LIVE | Opening Keynote, Live Coding & Demos

Watch this video on YouTube

If you have missed it don’t worry you can watch the MS Build Day 1 again on Youtube.

2. OpenClaw + Windows: Microsoft Build 2026

Watch this video on YouTube

Watch Samantha Song and Scott Hanselman demo OpenClaw on Windows, and are joined on stage by @Peter Steinberger, the Claw Father himself, to talk about the latest in OpenClaw, at Microsoft Build 2026.

3. Building for the agentic web with .NET 11

Watch this video on YouTube

The demands on modern web apps are increasing. Users expect more performance, airtight security, and even agentic capabilities. What does the next generation of web apps look like on .NET? In .NET 11, ASP.NET Core and Blazor are getting faster and more secure at the core, closely integrated with Aspire for distributed app development, and a new set of building blocks — agents, tools, skills, and components — for building agentic web apps. Get ready to build for the modern agentic web with Daniel Roth

4. Claude Opus 4.8 is now available in Microsoft Foundry

Embedded content: Claude Opus 4.8 is now available in Microsoft Foundry – Taswar Bhatti

Check out my blog post on Claude Opus 4.8 on Microsoft Foundry I also have sample code on how to use it.

5. GitHub App + Rayfin: Microsoft Build 2026

Watch this video on YouTube

Cassidy Williams shows the Rayfin in the GitHub Copilot app at Microsoft Build 2026.

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

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

Claude Opus 4.8 is now available in Microsoft Foundry

Taswar Bhatti June 1, 2026 No Comments

There are a lot of AI model announcements these days, but every now and then one lands that feels immediately practical for real engineering work.

Claude Opus 4.8 showing up in Microsoft Foundry feels like one of those releases.

Microsoft is positioning Claude Opus 4.8 around coding, agentic workflows, and deeper reasoning for enterprise scenarios, while Anthropic describes it as their most intelligent generally available Opus model for coding and agents.

What makes this interesting is not just “the benchmark number went up again.” The more important part is that these newer models are getting better at actual developer workflows:

reasoning across multiple files
maintaining context longer
handling multi-step tasks
recovering from mistakes
following structured instructions
working more reliably in tooling pipelines

That is a pretty different problem space compared to “generate a todo app in one prompt.”

And honestly, that is where most teams are today.

The shift from “AI chatbot” to “AI teammate”

A lot of developers already use AI for small tasks:

regex generation
boilerplate APIs
unit tests
SQL queries
debugging weird errors at 2AM

But the new generation of models is moving into a more interesting space: helping with systems-level work.

Think things like:

reviewing architecture decisions
planning refactors
migrating legacy code
analyzing logs and incident summaries
understanding large repositories
generating implementation plans instead of isolated snippets

That is the type of workload Claude Opus 4.8 seems designed for. Microsoft’s Foundry blog specifically calls out longer-running tasks, deeper reasoning, and more reliable tool use for agentic workflows.

And if you are already building internal copilots or AI-assisted engineering workflows, having this available inside Microsoft Foundry means you can evaluate it alongside other models without building ten different integration layers.

Let’s build something real with C# with EntraID

Enough marketing though.

Let’s actually call Claude Opus 4.8 from a .NET console app using the Azure AI Inference SDK.

This is the official SDK Microsoft documents for Azure AI Foundry model inference. It supports chat completions for Foundry-hosted models using ChatCompletionsClient

This sample keeps things simple:

console app
DefaultAzureCredential
BearerTokenPolicy
no API key
a realistic prompt that asks Claude to help modernize a messy ASP.NET Core API

Create the project and add your endpoint to environment variables

dotnet new console -n ClaudeFoundryConsole
$ cd ClaudeFoundryConsole
$ dotnet add package Azure.AI.Inference --prerelease
$ dotnet add package Azure.Identity
$ export AZURE_AI_CHAT_ENDPOINT="https://YOUR-ENDPOINT.models.ai.azure.com"
$ export AZURE_AI_MODEL="claude-opus-4-8"

1

2

3

4

5

6

dotnet new console -n ClaudeFoundryConsole

$ cd ClaudeFoundryConsole

$ dotnet add package Azure.AI.Inference --prerelease

$ dotnet add package Azure.Identity

$ export AZURE_AI_CHAT_ENDPOINT="https://YOUR-ENDPOINT.models.ai.azure.com"

$ export AZURE_AI_MODEL="claude-opus-4-8"

Program.cs

using Azure.AI.Inference;
using Azure.AI.Inference.Models;
using Azure.Core.Pipeline;
using Azure.Identity;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT");
var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "claude-opus-4-8";

if (string.IsNullOrWhiteSpace(endpoint))
{
    Console.WriteLine("Please set AZURE_AI_CHAT_ENDPOINT.");
    return;
}

// Entra ID auth using DefaultAzureCredential
BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

// Create the client using Azure credentials
var client = new ChatCompletionsClient(
    new Uri(endpoint),
    new DefaultAzureCredential());

var options = new ChatCompletionsOptions
{
    Model = model,
    Temperature = 0.2f,
    MaxTokens = 1800
};

options.Messages.Add(new ChatRequestSystemMessage(
    """
    You are a senior .NET architect.

    Your job is to help developers modernize real systems without overengineering.
    Prefer practical and incremental changes over full rewrites.

    Be specific, opinionated, and implementation-focused.
    """
));

options.Messages.Add(new ChatRequestUserMessage(
    """
    I have an ASP.NET Core API with:
    - fat controllers
    - EF Core queries directly in controllers
    - duplicated business rules
    - almost no tests
    - some services using static helper classes

    Please help me improve it.

    Return:
    1. a better project structure
    2. a sample service interface and implementation
    3. DI registration suggestions
    4. one realistic unit test example
    5. a safe migration plan that avoids a big-bang rewrite
    """
));

Console.WriteLine($"Calling model: {model}");
Console.WriteLine("Sending request with DefaultAzureCredential...");
Console.WriteLine();

var response = await client.CompleteAsync(options);

foreach (var item in response.Value.Content)
{
    Console.WriteLine(item.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

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

using Azure.AI.Inference;

using Azure.AI.Inference.Models;

using Azure.Core.Pipeline;

using Azure.Identity;

var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_CHAT_ENDPOINT");

var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL") ?? "claude-opus-4-8";

if (string.IsNullOrWhiteSpace(endpoint))

{

Console.WriteLine("Please set AZURE_AI_CHAT_ENDPOINT.");

return;

}

// Entra ID auth using DefaultAzureCredential

BearerTokenPolicy tokenPolicy = new(

new DefaultAzureCredential(),

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

// Create the client using Azure credentials

var client = new ChatCompletionsClient(

new Uri(endpoint),

new DefaultAzureCredential());

var options = new ChatCompletionsOptions

{

Model = model,

Temperature = 0.2f,

MaxTokens = 1800

};

options.Messages.Add(new ChatRequestSystemMessage(

"""

You are a senior .NET architect.

Your job is to help developers modernize real systems without overengineering.

Prefer practical and incremental changes over full rewrites.

Be specific, opinionated, and implementation-focused.

"""

));

options.Messages.Add(new ChatRequestUserMessage(

"""

I have an ASP.NET Core API with:

- fat controllers

- EF Core queries directly in controllers

- duplicated business rules

- almost no tests

- some services using static helper classes

Please help me improve it.

Return:

1. a better project structure

2. a sample service interface and implementation

3. DI registration suggestions

4. one realistic unit test example

5. a safe migration plan that avoids a big-bang rewrite

"""

));

Console.WriteLine($"Calling model: {model}");

Console.WriteLine("Sending request with DefaultAzureCredential...");

Console.WriteLine();

var response = await client.CompleteAsync(options);

foreach (var item in response.Value.Content)

{

Console.WriteLine(item.Text);

}

Final thoughts

Claude Opus 4.8 in Microsoft Foundry looks genuinely interesting for developers because it is not only being framed as a better model — it is being framed as a better model for the kind of work developers actually do:

coding with context
multi-step problem solving
architecture-aware suggestions
agentic workflows
professional and enterprise reasoning

That is a much better story than “new model, now with extra adjectives.”

If your team already lives in Azure, already experiments with coding assistants, or is building internal AI tooling, this is definitely one worth trying.

Resources

Claude Opus 4.8 is now available in Microsoft Foundry Blog
Model Card

AI, Azure, Azure OpenAI

.net, Agentic AI, AI coding, Anthropic, Azure AI Foundry, Azure AI Inference, C#, Claude Opus 4.8, DefaultAzureCredential, Microsoft Foundry

5 Highlights Thursday | 21st May 2026 (#111 Edition)

Taswar Bhatti May 21, 2026 No Comments

Published: 2026-05-20
Source: https://www.linkedin.com/pulse/5-highlights-thursday-21st-may-2026-111-edition-taswar-bhatti-kwige

Here is the #111 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. STATE-Bench – Memory-agnostic Benchmark

Watch this video on YouTube

Join
Jorge Arteiro, Lewis Liu, Pablo Castro and Nishant Yadav where they introduce STATE-Bench is a new open-source benchmark designed to measure whether memory actually improves AI agent performance on realistic, stateful enterprise tasks. Instead of testing simple recall, it evaluates how agents handle procedural workflows, reliability across repeated runs, efficiency, and user experience in domains like customer support, travel, and shopping. In this episode, we’ll explore why traditional memory benchmarks fall short, how STATE-Bench closes that gap, and what it means to “bring your own memory” to a benchmark built for production readiness.

2. Estimate costs with confidence using the new Sentinel Cost Estimator

Watch this video on YouTube

Join Product Manager Shubh Khandhadia who introduces the new Microsoft Sentinel Cost Estimator, a web-based tool on the Microsoft Sentinel pricing page that helps sellers, customers, and partners estimate costs before deployment. Learn how to access and use the estimator, model ingestion, storage, and query costs, understand key meters and included benefits, and build 3-year projections to support more effective long-term planning.

3. Grok 4.3 in Microsoft Foundry: A Practical C# Guide for Developers

Content: Grok 4.3 in Microsoft Foundry: A Practical C# Guide for Developers – Taswar Bhatti

Here is a blog post I wrote about Grok 4.3 with sample code in C# on how to use it. Check it out and tell me what you think?

4. Security Copilot chat experience in Microsoft Defender

Watch this video on YouTube

Join Senior Product Manager Yuval Derman for this episode to discuss the Security Copilot chat experience in Microsoft Defender and how assistive AI is transforming modern security operations. Learn how Security Copilot serves as the AI layer across Microsoft’s integrated security platform, enabling SOC teams to work faster and more effectively through context-aware, natural language experiences embedded directly into their workflow. Discover how analysts can investigate incidents, correlate signals across alerts, identities, and devices, and accelerate response actions using real-time Defender telemetry.

5. Azure MCP and Azure Skills

Watch this video on YouTube

Explore Azure MCP Server and Azure Skills working together to extend AI capabilities across Azure services. In this video, we walk through the developer experience in VS Code, showing how to configure, run, and interact with Azure Skills seamlessly.

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

.net, AI, Azure AI Foundry, Azure Weekly Digest, Cloud Computing, Cost Optimization, GitHub Copilot, Microsoft Azure, Microsoft Defender, Microsoft Sentinel, security

Grok 4.3 in Microsoft Foundry: A Practical C# Guide for Developers

Taswar Bhatti May 14, 2026 No Comments

If you’ve been building AI-powered apps lately, you’ve probably noticed that the conversation is shifting. It’s no longer just about “generate text.” It’s about reasoning, multi-step workflows, and agents that actually do things. That’s why I got excited when I saw Grok 4.3 land in Microsoft Foundry. This isn’t just another model drop — it’s a serious step toward agentic AI systems that can reason, plan, and integrate with tools in real-world scenarios. And the best part? You can start using it today with familiar patterns in .NET.

What’s intresting about Grok 4.3?

Let me cut through the marketing and tell you what stood out to me as a developer.
From the official announcement, Grok 4.3 focuses on:

Strong instruction following (finally predictable behavior)
Better tool usage and agent workflows
Reduced hallucinations / improved truthfulness
More reliable multi-step reasoning
Support for longer conversations and context

And on Microsoft Foundry specifically, it supports up to a 200K token context window, which means:

You can feed it large documents, long histories, or complex workflows without constantly chunking everything.

What I like here is the direction: This is clearly designed for real enterprise workflows, not just chat demos.

Where I see this being useful

Based on what Microsoft shared, a few scenarios jump out immediately:

Security copilots / incident assistants
Developer copilots for large codebases
Workflow automation agents
Document-heavy use cases (legal, finance, compliance)
Multimodal reasoning (text + diagrams + structured data)

C# Example of Calling Grok

As you know me I like to go into the code of things to see how things work, so lets get practical.

Prerequisites

.NET 8+
Azure / Foundry deployment of Grok 4.3
Azure.Identity + OpenAI SDK
OpenAI-compatible v1 API pattern

C# Sample Code

using Azure.Identity;
using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;
 
#pragma warning disable OPENAI001
// Endpoint must be the base only — ChatClient appends /chat/completions automatically
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? "https://YOUR-RESOURCE.services.ai.azure.com/models";

var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "grok-4.3";

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

ChatClient client = new(
    model: deploymentName,
    authenticationPolicy: tokenPolicy,
    options: clientOptions);
 
var messages = new List<ChatMessage>
{
    new SystemChatMessage("""
        You are a senior AI assistant specializing in security and architecture.
        Be precise. If unsure, say so clearly.
        """),
    new UserChatMessage("""
        Design an incident response copilot for a security operations team.
        Include architecture, services, and data flow.
        """)
};
 
var response = await client.CompleteChatAsync(messages);
 
foreach (var part in response.Value.Content)
{
    Console.Write(part.Text);
}

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

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

using Azure.Identity;

using OpenAI;

using OpenAI.Chat;

using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

// Endpoint must be the base only — ChatClient appends /chat/completions automatically

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? "https://YOUR-RESOURCE.services.ai.azure.com/models";

var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "grok-4.3";

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

ChatClient client = new(

model: deploymentName,

authenticationPolicy: tokenPolicy,

options: clientOptions);

var messages = new List<ChatMessage>

{

new SystemChatMessage("""

You are a senior AI assistant specializing in security and architecture.

Be precise. If unsure, say so clearly.

"""),

new UserChatMessage("""

Design an incident response copilot for a security operations team.

Include architecture, services, and data flow.

""")

};

var response = await client.CompleteChatAsync(messages);

foreach (var part in response.Value.Content)

{

Console.Write(part.Text);

}

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

}

My Take on this

Personally, this is one of the more interesting additions to Microsoft Foundry recently. Not because it’s “just smarter” — but because it’s clearly designed for: Agent-based systems, Workflow automation and Real production scenarios

Resources

.NET, AI, Azure OpenAI

.net, AI Agents, Azure AI, Azure OpenAI, C#, Developer Guide, Grok 4.3, Microsoft Foundry, OpenAI API

5 Highlights Thursday | 30th April 2026 (#110 Edition)

Taswar Bhatti April 30, 2026 No Comments

Published: 2026-04-30
Source: https://www.linkedin.com/pulse/5-highlights-thursday-30th-april-2026-110-edition-taswar-bhatti-dobcf

Here is the #110 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. AI Memory Patterns: Save Tokens, Cut Costs

Watch this video on YouTube

AI systems must retain conversation history, tool outputs, and user context across multiple turns. Basic approaches can quickly inflate token usage or lose critical context. In this session, Chander D. (CEO of Cazton, 15-time Microsoft MVP) explores three memory patterns implemented using Azure Cosmos DB NoSQL

2. Getting Started with Security Copilot

Watch this video on YouTube

This session walks through what you actually need to get started with Microsoft Security Copilot. It covers the E5 inclusion requirements and provide a practical, day‑one overview of the core experiences and agents you’ll use immediately—so you can move from setup to real value faster.

3. How do we draw agentic borders?

Watch this video on YouTube

As AI agents become more capable—and more autonomous—one question rises fast: How do we draw agentic borders? For many organizations, this is also a sovereignty question: what stays in-country, who can access it, and how do you enforce policy across systems and regions? In this episode of The Shift Podcast: Agentic Edition, Evelyn Ozzie , Meena J Gowdar, Edouard de Cremiers, Karim Batthish from Microsoft Azure explore the evolving boundaries between agents, humans, systems, and responsibility—and what it takes to keep trust and accountability as AI becomes more agentic.

4.Azure SRE Agent: End to end agentic operations platform for any kind of toil and at enterprise scale

Watch this video on YouTube

In this Azure Friday session, join Scott Hanselman & Shamir Abdul Aziz walk through how to get started with Azure SRE Agent and demonstrate how agentic workflows can be applied to real operational scenarios—from help desk tickets to cost analysis and reporting and anything in between.

5.Hooking Up All the Things, Making Your Developer’s Life Easier

Watch this video on YouTube

Want to simplify distributed app development and stop wiring everything together manually? In this @VisualStudioLive session from Visual Studio Live! Las Vegas 2026, Jeffrey T. Fritz shows how to use .NET Aspire to orchestrate services, containers, and integrations so you can “hook up all the things” and make your developer life easier.

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

.net, AI, azure, Azure Weekly Digest, Cloud Computing, Cost Optimization, Databases, GitHub Copilot, Kubernetes, Microsoft Azure, security

GPT-5.5 Now in Microsoft Foundry (GA): Build Reliable Agents for Real Enterprise Work

Taswar Bhatti April 25, 2026 No Comments

OpenAI’s GPT-5.5 is now generally available (GA) in Microsoft Foundry, and this is one of those releases that matters less for “chat” and more for getting actual work done—end-to-end.

The big theme: messy, multi-step requests → completed tasks, with stronger reliability in planning, tool use, UI navigation, and recovery when something breaks mid-flow.

If you’re building internal copilots, engineering assistants, or “agentic” workflows that touch code + docs + systems, GPT-5.5 is positioned as a practical step forward in coding/debugging intelligence, long-context reasoning, computer-use accuracy, and token efficiency for longer-running workloads.

Why this release is different

In many enterprise environments, the hardest part isn’t generating an answer—it’s executing a workflow: interpret intent, plan steps, call tools, verify output, and keep going even after a failed command or a UI detour.
Microsoft frames Foundry as the “platform layer” that turns frontier models into governable systems (security, compliance, management), while GPT-5.5 brings improvements specifically tuned for sustained professional workflows.

What’s improved in GPT-5.5 (developer lens)

1) Agentic task execution (plan → act → finish)

GPT-5.5 is designed to handle multi-step execution, not just single-turn responses—planning and following through across tools and systems.
That’s exactly what you want when the task is “fix the bug, update the tests, and summarize the PR impact,” rather than “explain the bug.”

2) Coding + debugging that feels closer to real engineering

OpenAI highlights stronger performance in writing and debugging code, while Microsoft emphasizes agentic coding and more reliable execution for engineering workflows.
In practice, this maps well to: navigating large repos, doing root-cause analysis (RCA), anticipating downstream test updates, and validating changes before you ship.

3) Long-context reasoning that stays coherent

Both announcements point to GPT-5.5 handling large documents, codebases, and extended histories without losing the thread—critical for enterprise work where context is fragmented across tickets, specs, and logs.

4) Computer use (UI navigation) with better accuracy + recovery

A lot of agent workflows eventually hit a UI: portals, dashboards, admin blades, internal tools. GPT-5.5 puts emphasis on improved “computer use” accuracy—clicking the right thing, backtracking, and recovering when the workflow changes.

5) Token efficiency for long-running workflows

Long workflows can be expensive—not only because they’re long, but because retries and drift multiply tokens. GPT-5.5 is positioned as more efficient, often completing tasks with fewer tokens and fewer retries (especially in coding-style flows).

Top use cases (what I’d actually build with it)

A) Software engineering workflows (repo-scale)

Navigate large codebases and keep context across multiple files/modules.
Debug ambiguous failures, do RCA, propose fixes, and anticipate impact.
Identify test gaps and generate validation scripts (unit/integration).

B) Document + knowledge work (high-fidelity extraction)

Pull structured insights from contracts/specs/invoices/research docs.
Synthesize across multiple sources while keeping citations/traceability in your workflow design.

C) Agentic business process automation

Plan and execute multi-step workflows across systems (CRM, ITSM, internal portals).
Generate finished artifacts (docs/sheets/decks) as part of an automated pipeline.

D) Computer-use scenarios (UI-driven automation)

Navigate UI flows more accurately; recover when a click path fails.
Great fit for repeatable tasks that don’t have clean APIs (yet).

E) Spreadsheet reasoning (structured data)

Stronger reasoning on structured tables to support summarization, anomaly detection, and transformations

Minimal “hello world” – Chat Completions (C#)

This example mirrors the OpenAI v1 pattern used by Foundry/Azure OpenAI docs and is a good baseline for API-first apps.
(You’ll plug in your endpoint + deployment name; for enterprise, prefer Entra ID flows.)

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;

// Uses Entra ID (recommended). Docs show token-based auth patterns for Foundry/OpenAI v1 usage.
var credential = new DefaultAzureCredential();
var token = credential.GetToken(
    new Azure.Core.TokenRequestContext(new[] { "https://ai.azure.com/.default" })
);

var client = new OpenAIClient(new OpenAIClientOptions
{
    Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
});

// If your SDK version expects a bearer token provider/policy, follow the latest Microsoft Learn guidance.
var chat = client.GetChatClient("YOUR-DEPLOYMENT-NAME"); // deployment name maps to GPT-5.5 deployment

var completion = chat.CompleteChat(
    new SystemChatMessage("You are a senior software engineer assistant. Be concise, validate assumptions."),
    new UserChatMessage("Given this stack trace, propose an RCA and a minimal fix plan. Ask for missing logs.")
);

Console.WriteLine(completion.Content[0].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

using Azure.Identity;

using OpenAI;

using OpenAI.Chat;

// Uses Entra ID (recommended). Docs show token-based auth patterns for Foundry/OpenAI v1 usage.

var credential = new DefaultAzureCredential();

var token = credential.GetToken(

new Azure.Core.TokenRequestContext(new[] { "https://ai.azure.com/.default" })

);

var client = new OpenAIClient(new OpenAIClientOptions

{

Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")

});

// If your SDK version expects a bearer token provider/policy, follow the latest Microsoft Learn guidance.

var chat = client.GetChatClient("YOUR-DEPLOYMENT-NAME"); // deployment name maps to GPT-5.5 deployment

var completion = chat.CompleteChat(

new SystemChatMessage("You are a senior software engineer assistant. Be concise, validate assumptions."),

new UserChatMessage("Given this stack trace, propose an RCA and a minimal fix plan. Ask for missing logs.")

);

Console.WriteLine(completion.Content[0].Text);

Minimal “hello world” – Chat Completions (Python)

Python is great for quick evaluation, prompt iteration, and building internal tooling.

import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://ai.azure.com/.default"
)

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider
)

resp = client.chat.completions.create(
    model="YOUR-DEPLOYMENT-NAME",  # your GPT-5.5 deployment name
    messages=[
        {"role": "system", "content": "You are a debugging assistant. Provide RCA + fix + tests."},
        {"role": "user", "content": "Here is the error log... (paste). What’s the likely root cause?"}
    ]
)

print(resp.choices[0].message.content)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

import os

from openai import OpenAI

from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(

DefaultAzureCredential(),

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

)

client = OpenAI(

base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",

api_key=token_provider

)

resp = client.chat.completions.create(

model="YOUR-DEPLOYMENT-NAME", # your GPT-5.5 deployment name

messages=[

{"role": "system", "content": "You are a debugging assistant. Provide RCA + fix + tests."},

{"role": "user", "content": "Here is the error log... (paste). What’s the likely root cause?"}

]

)

print(resp.choices[0].message.content)

Conclusion: GPT-5.5 is built for “execution,” not just “answers”

If your AI roadmap includes agents that:

touch multiple tools,
reason across long contexts,
navigate UIs,
generate real artifacts (code/docs/sheets/decks),
and keep going when workflows break…

…then GPT-5.5 in Microsoft Foundry is a release worth testing early—because it targets the exact failure modes that show up when you move from demo to production.
And with Foundry’s deployment model + enterprise governance story, you can evaluate and productionize without reinventing the operational layer every time a new frontier model lands.

Bonus

Watch this video on YouTube

.NET, AI, Azure

AI Agents, Azure AI Foundry, Azure OpenAI, C#, Developer Tools, GPT-5.5, Microsoft Foundry, python