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

5 Highlights Thursday | 23th April 2026 (#109 Edition)

Taswar Bhatti April 23, 2026 No Comments

Published: 2026-04-23
Source: https://www.linkedin.com/pulse/5-highlights-thursday-23th-april-2026-109-edition-taswar-bhatti-1exif

Here is the #109 edition of 5 Highlights Thursday. Happy Childrens Day if you are in Turkiye. 👶 I hope this newsletter will help you in your Azure journey and keep you informed. Feel free to forward this alng to anyone who you think may enjoy or better ask them to subscribe.

1. Microsoft Agent Framework releasing version 1.0

Watch this video on YouTube

Microsoft Agent Framework has reached version 1.0 — making production-grade agent development feel like normal software development. In this episode, Jorge Arteiro, Shawn Henry and @Rong Lu walk through what’s new in the v1.0 GA release: stable APIs, multi-agent orchestration with handoff patterns, and support for Python and .NET.

2. Using Microsoft Agent Framework with Foundry managed memory

Watch this video on YouTube

In this episode, Jorge Arteiro, Amy Boyd and Lewis Liu dive into Memory in Foundry Agent Service — a managed, long-term memory layer that turns stateless LLM calls into stateful, continuous agents. Lewis Liu and Amy Boyd walk through how memory is natively integrated with Microsoft Agent Framework and LangGraph, enabling agents to persist user preferences, conversation context, and task outcomes across sessions — with zero infrastructure overhead. See how per-user memory scoping, automatic memory extraction, and CRUD APIs give developers full control while keeping enterprise governance built in.

3. Azure confidential computing in the sovereign cloud era

Watch this video on YouTube

Join Vikas Bhatia, head of product for Azure Compute Security & Confidential Computing, as he presents the latest innovations in Azure Confidential Computing and Microsoft Sovereign Cloud. This session explores how Azure empowers organizations to achieve digital sovereignty, secure sensitive data, and meet global compliance requirements. Learn about real-world use cases, hardware advancements, and strategies for resilient, mission-critical workloads—directly from the leader driving Azure’s security vision.

4. Discover, manage, and secure AI agents with Microsoft Agent 365

Watch this video on YouTube

In this session from Vasu Jakkal RSAC 2026 Main Stage keynote, see how Microsoft Agent 365 helps organizations discover, manage, and secure AI agents at scale. Learn how IT and security teams gain centralized visibility into agent activity, apply consistent policies, and protect data across the agent lifecycle, no matter where agents are built or deployed.

5. From code to cloud: Deploy an AI agent to Microsoft Foundry in minutes with azd

Embedded content: From code to cloud: Deploy an AI agent to Microsoft Foundry in minutes with azd

This post walks through the full end-to-end workflow: deploying an AI agent to Microsoft Foundry, invoking it remotely, running it locally for development, and monitoring it in real time—all from Visual Studio (VS) Code.

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, Microsoft Azure, security

gpt-image-2-microsoft-foundry-for-developers

GPT‑Image‑2 Comes to Microsoft Foundry: What Developers Need to Know

Taswar Bhatti April 22, 2026 No Comments

Generative AI for images has gone from “cool demo” to something teams actually run in production. Microsoft has now made OpenAI’s GPT‑image‑2 generally available in Microsoft Foundry, and it’s a meaningful upgrade for developers building image-heavy workflows at scale.

This isn’t just “another image model.” GPT‑image‑2 focuses on instruction accuracy, higher resolution output, localization, and enterprise‑ready scaling—all crucial if you’re building real products instead of playing with prompts.

Let’s break down what’s new, why it matters, and how this changes image generation inside Microsoft Foundry.

Key Improvements in GPT‑Image‑2

1. Stronger Real‑World Context

GPT‑image‑2 is trained with knowledge up to December 2025, giving it better awareness of:

Current products
Modern design patterns
Recent cultural references

More importantly, it uses enhanced “thinking” capabilities to:

Refine outputs
Self-check generated content
Create multiple image variations from a single request

That makes it feel less like a static image generator and more like a creative assistant you can automate.

2. Built‑In Multilingual and Localization Support

One standout improvement is better multilingual understanding, especially for:

Japanese
Korean
Chinese
Hindi
Bengali

This matters when you need:

Text rendered correctly inside images
Culturally accurate visuals
Region-specific variations generated automatically

For global products, this alone removes a huge amount of downstream manual work.

Example of image created with GPT-Image-2 vs MAI-Image-2e

var prompt = “Create a simple poster-style graphic with 3 panels showing the same message rendered in Japanese, Korean, and Hindi. The message should be short and generic like ‘Hello World’. Use clean typography, white text on colored blocks, modern UI style, high legibility, no logos.”;

GPT Image 2	MAI Image 2e
GPT-Image-2	MAI-Image-2e

3. High‑Resolution Image Generation (Up to 4K)

GPT‑image‑2 introduces 4K image support, making it viable for:

Marketing assets
Product mockups
High-quality digital content

Important technical constraints to keep in mind:

Maximum pixel count: ~8.3 million pixels
Minimum pixel count: ~655k pixels
Dimensions must be multiples of 16
Requests exceeding limits are automatically resized

Supported resolutions include:

1024 × 1024
1536 × 1024
1024 × 1536
4K custom-sized images (within limits)

This brings image generation much closer to production-grade quality, not just prototyping.

Intelligent Routing: Less Guesswork for Developers

One of the more subtle—but important—features is the intelligent routing layer.

Instead of forcing developers to manually pick image sizes every time, Foundry can now automatically select the best configuration based on the request.

Routing Mode 1: Legacy Size Selection

If you’ve used previous image APIs, this mode maps your request to familiar tiers (small, standard, large) without you changing anything.

Routing Mode 2: Token‑Based Size Buckets

A more advanced mode where requests are routed using token buckets (16 → 96 tokens), offering more granular scaling while still abstracting complexity away from the app layer.

The net result: cleaner code, fewer hardcoded decisions, and more consistent outputs.

C# Code to generate your own image

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

class Program
{
    static async Task Main(string[] args)
    {

        string endpoint_gpt = GetEnvironmentVariable("AZURE_GPT_ENDPOINT") ??
            "https://xyz.cognitiveservices.azure.com/openai/deployments/gpt-image-2/images/generations?api-version=2024-02-01";
                
        string gptModelName = GetEnvironmentVariable("AZURE_GPT_MODEL") ?? "gpt-image-2";
        string prompt = "Create a simple poster-style graphic with 3 panels showing the same message rendered in Japanese, Korean, and Hindi. The message should be short and generic like 'Hello World'. Use clean typography, white text on colored blocks, modern UI style, high legibility, no logos.";        

        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 gpt_payload = new
        {
            prompt,
            model = gptModelName,
            size = "1024x1024",
            quality = "medium",
            output_compression = 100,
            output_format = "png",
            n = 1
        };
        
        using var content = new StringContent(
            JsonSerializer.Serialize(gpt_payload),
            Encoding.UTF8,
            "application/json");

        using HttpResponseMessage response = await http.PostAsync(endpoint_gpt, 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("GPT Image 2 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, "generated_image.png");
        await File.WriteAllBytesAsync(outputPath, imageBytes);
        Console.WriteLine($"Image saved to: {outputPath}");
    }

    static string? GetEnvironmentVariable(string name) => Environment.GetEnvironmentVariable(name);
}

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

using Azure.Identity;

using Azure.Core;

using System.Net.Http.Headers;

using System.Text;

using System.Text.Json;

class Program

{

static async Task Main(string[] args)

{

string endpoint_gpt = GetEnvironmentVariable("AZURE_GPT_ENDPOINT") ??

"https://xyz.cognitiveservices.azure.com/openai/deployments/gpt-image-2/images/generations?api-version=2024-02-01";

string gptModelName = GetEnvironmentVariable("AZURE_GPT_MODEL") ?? "gpt-image-2";

string prompt = "Create a simple poster-style graphic with 3 panels showing the same message rendered in Japanese, Korean, and Hindi. The message should be short and generic like 'Hello World'. Use clean typography, white text on colored blocks, modern UI style, high legibility, no logos.";

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 gpt_payload = new

{

prompt,

model = gptModelName,

size = "1024x1024",

quality = "medium",

output_compression = 100,

output_format = "png",

n = 1

};

using var content = new StringContent(

JsonSerializer.Serialize(gpt_payload),

Encoding.UTF8,

"application/json");

using HttpResponseMessage response = await http.PostAsync(endpoint_gpt, 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("GPT Image 2 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, "generated_image.png");

await File.WriteAllBytesAsync(outputPath, imageBytes);

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

}

static string? GetEnvironmentVariable(string name) => Environment.GetEnvironmentVariable(name);

}

Final Thoughts

GPT‑image‑2 is less about flashy demos and more about operational reality:

Fewer retries
Better instruction adherence
Cleaner localization
Higher‑quality visuals at scale

If you’re building AI‑powered apps, internal tools, or content pipelines on Azure, this model is a strong signal that image generation is now a serious enterprise capability, not an experiment.

AI

AI, GPT, GPT-Image-2

5 Highlights Thursday | 16th April 2026 (#108 Edition)

Taswar Bhatti April 16, 2026 No Comments

Published: 2026-04-16
Source: https://www.linkedin.com/pulse/5-highlights-thursday-16th-april-2026-108-edition-taswar-bhatti-boevf

Here is the #108 edition of 5 Highlights Thursday to 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. Use AI to Achieve Operational Excellence with the Well-Architected Framework practices

Watch this video on YouTube

If you’re a cloud architect, platform engineer, or developer responsible for operating systems in production, this video Boris Scholl & Niels Buit will help you understand Well Architected Framework and how to apply AI practically, assess risks and tradeoffs in real-world environments.

2. Next-Level SQL in VS Code: GitHub Copilot Custom Instructions, Plan Mode & Skills

Watch this video on YouTube

GitHub Copilot already generates awesome SQL code but awesome is different from aligned with your team. In this episode, Anna Hoffman & Carlos Robles explore how to take full control of GitHub Copilot context inside VS Code using the MSSQL extension.

3. The future of identity protection with Predictive Shielding

Watch this video on YouTube

In this episode, we explore how predictive shielding anticipates attacks before they unfold. Nimrod Roimy my and Aviv Sharon join us to share how Microsoft is the first vendor to leverage attack path graphs to detect early signs of compromise, pioneering a way to harden devices that store critical identities and proactively block domain-wide breaches.

4. Migrate Oracle Workloads to PostgreSQL Using AI-Powered Tools in the VS Code PostgreSQL Extension

Watch this video on YouTube

This week on Azure Friday, Scott Hanselman talks with Jonathon Frost about AI-enhanced migration from Oracle to PostgreSQL using the VS Code PostgreSQL extension. See how developers can automate schema conversion, transform application code, and validate results using an intelligent, agent-driven workflow.

5. Is Postgres the wave of the future?

Watch this video on YouTube

In this episode of The Shift, members of the Microsoft Azure Database team, Eric Hudson , Marko Hotti , Claire Giordano and Abinav Rameesh explore a question from you, our community and the question in mind is Is Postgres the wave of the future?

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, PostgreSQL, security

5 Highlights Thursday | 9th April 2026 (#107 Edition)

Taswar Bhatti April 9, 2026 No Comments

Published: 2026-04-09
Source: https://www.linkedin.com/pulse/5-highlights-thursday-9th-april-2026-107-edition-taswar-bhatti-bgcyf

Here is the #107 edition of 5 Highlights Thursday to 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. Tech Brief: Agentic DevOps with GitHub Copilot (April 28th)

Tech Brief: Agentic DevOps with GitHub Copilot

Join the Tech Brief if you are building intelligent applications requires more than just powerful AI models—it also demands a seamless, adaptive development life cycle. Join us to explore how agentic DevOps is transforming the way that teams build, deploy, and scale AI-powered applications on Microsoft Azure. This session is designed for technology and development decision-makers.

2. Network-layer data protection with Microsoft Entra GSA and Purview DLP

Watch this video on YouTube

Watch the session to learn how this Network Data Security integration allows Purview DLP policies to inspect and control sensitive file traffic in transit through GSA Internet Access, preventing data from reaching unsanctioned cloud apps, generative AI platforms, and cloud storage services.

3. Clean Architecture with ASP .NET Core 10

Watch this video on YouTube

ASP.NET Core provides better support for clean, testable, maintainable architectures than any of its predecessors. Learn the underlying principles that apply to project/solution organization, how best to arrange your projects to support loosely coupled, maintainable code, and how to refactor existing solutions toward this architecture.

4. Building a Real-Time Multi-Agent UI with AG-UI and Microsoft Agent Framework Workflows

Embedded content: Building a Real-Time Multi-Agent UI with AG-UI and Microsoft Agent Framework Workflows | Microsoft Agent Framework

This post shows what a better answer looks like. It build’s a customer support workflow that pairs Microsoft Agent Framework (MAF) handoffs with AG-UI,

5. GitHub Copilot CLI in Action: Getting Started

Watch this video on YouTube

GitHub Copilot CLI provides a terminal-based AI coding companion that can be used to explain code, generate code, do code reviews, work with PRs, run and generate tests, and much more. In this video you’ll learn about what Copilot CLI is, how you can get started using it, and examples of it in action.

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 DevOps, Azure Weekly Digest, Cloud Computing, GitHub Copilot, Microsoft Azure, Networking, security

5 Highlights Thursday | 2nd April 2026 (#106 Edition)

Taswar Bhatti April 2, 2026 No Comments

Published: 2026-04-02
Source: https://www.linkedin.com/pulse/5-highlights-thursday-2nd-april-2026-106-edition-taswar-bhatti-u3pxf

Here is the #106 edition of 5 Highlights Thursday to 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. Native Regex in SQL Server 2025

Watch this video on YouTube

REGEX in Microsoft SQL (SQL Server, Azure SQL, SQL database in Fabric) – did you know we have T-SQL functions for this and it just works? Join Anna Hoffman & Ed Pollack where they take us through it, on #DataExposed #MVPEdition.

2. Foundry IQ: Querying the Multi-Source AI Knowledge Bases

Watch this video on YouTube

The third episode of The IQ Series opens with Amanda Silver introducing Knowledge Bases and how multiple Knowledge Sources unify behind a single endpoint. Pamela Fox and Matthew Gotteiner then walk through topic-centric Knowledge Bases and demonstrate a multi-source query path, showing how Foundry IQ moves from isolated data pipelines to reusable, queryable knowledge. The episode closes with Tomomi Imura visual doodles, illustrating how this shift unlocks a more connected and scalable knowledge architecture.

3. Developer Tools for Agent ID: SDKs, CLIs & Samples

Watch this video on YouTube

Join Kyle Marsh on how to accelerate agent and app development with the Microsoft Entra developer toolchain in this deep‑dive session focused on real‑world identity scenarios. Explore SDKs, sample repositories, and ready‑to‑run resources that help you acquire tokens, implement consent flows, and securely call downstream APIs with confidence.

4. Modernizing Legacy .NET applications with GitHub Copilot

Watch this video on YouTube

Modernizing legacy .NET applications is often intimidating: no one wants to be the developer who breaks code in production. But what if you could approach it with low risk and high confidence? In this live coding session, Jorge Balderas, will demonstrate how GitHub Copilot CLI and the modernize-dotnet custom agent can be used to safely and systematically modernize legacy code.

5. Decision Matrix: API vs MCP Tools — The Great Integration Showdown

Embedded content: Decision Matrix: API vs MCP Tools — The Great Integration Showdown 🥊 | Microsoft Community Hub

Here is a blog post by Sabyasachi Samaddar on deep dive of API vs MCP.

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, AKS, azure, Azure AI Foundry, Azure SQL, Azure Weekly Digest, Cloud Computing, Databases, GitHub Copilot, Kubernetes, Microsoft Azure, security

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

Let’s build something real with C# with EntraID

Create the project and add your endpoint to environment variables

Program.cs

Final thoughts

Resources

1. STATE-Bench – Memory-agnostic Benchmark

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

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

4. Security Copilot chat experience in Microsoft Defender

5. Azure MCP and Azure Skills

What’s intresting about Grok 4.3?

Where I see this being useful

C# Example of Calling Grok

Prerequisites

C# Sample Code

My Take on this

Resources

1. AI Memory Patterns: Save Tokens, Cut Costs

2. Getting Started with Security Copilot

3. How do we draw agentic borders?

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

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

Why this release is different

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

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

2) Coding + debugging that feels closer to real engineering

3) Long-context reasoning that stays coherent

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

5) Token efficiency for long-running workflows

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

A) Software engineering workflows (repo-scale)

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

C) Agentic business process automation

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

E) Spreadsheet reasoning (structured data)

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

Minimal “hello world” – Chat Completions (Python)

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

Bonus

1. Microsoft Agent Framework releasing version 1.0

2. Using Microsoft Agent Framework with Foundry managed memory

3. Azure confidential computing in the sovereign cloud era

4. Discover, manage, and secure AI agents with Microsoft Agent 365

5. From code to cloud: Deploy an AI agent to Microsoft Foundry in minutes with azd

Key Improvements in GPT‑Image‑2

1. Stronger Real‑World Context

2. Built‑In Multilingual and Localization Support

Example of image created with GPT-Image-2 vs MAI-Image-2e

3. High‑Resolution Image Generation (Up to 4K)

Intelligent Routing: Less Guesswork for Developers

Routing Mode 1: Legacy Size Selection

Routing Mode 2: Token‑Based Size Buckets

C# Code to generate your own image

Final Thoughts

1. Use AI to Achieve Operational Excellence with the Well-Architected Framework practices

2. Next-Level SQL in VS Code: GitHub Copilot Custom Instructions, Plan Mode & Skills

3. The future of identity protection with Predictive Shielding

4. Migrate Oracle Workloads to PostgreSQL Using AI-Powered Tools in the VS Code PostgreSQL Extension

5. Is Postgres the wave of the future?

1. Tech Brief: Agentic DevOps with GitHub Copilot (April 28th)

2. Network-layer data protection with Microsoft Entra GSA and Purview DLP

3. Clean Architecture with ASP .NET Core 10

4. Building a Real-Time Multi-Agent UI with AG-UI and Microsoft Agent Framework Workflows

5. GitHub Copilot CLI in Action: Getting Started

1. Native Regex in SQL Server 2025

2. Foundry IQ: Querying the Multi-Source AI Knowledge Bases

3. Developer Tools for Agent ID: SDKs, CLIs & Samples

4. Modernizing Legacy .NET applications with GitHub Copilot

5. Decision Matrix: API vs MCP Tools — The Great Integration Showdown

Opinions are my own and not the views of my employer

LinkedIn

Archives