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.

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"

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

The post Claude Opus 4.8 is now available in Microsoft Foundry appeared first on Taswar Bhatti.

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

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

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

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

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

The post 5 Highlights Thursday | 21st May 2026 (#111 Edition) appeared first on Taswar Bhatti.

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

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

• Introducing Grok 4.3 on Microsoft Foundry
• Chat Completions in Microsoft Foundry (Microsoft Learn)
• Grok Model Catalog (Azure AI Foundry)

The post Grok 4.3 in Microsoft Foundry: A Practical C# Guide for Developers appeared first on Taswar Bhatti.

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

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

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?

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

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

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

The post 5 Highlights Thursday | 30th April 2026 (#110 Edition) appeared first on Taswar Bhatti.

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

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)

 

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

The post GPT-5.5 Now in Microsoft Foundry (GA): Build Reliable Agents for Real Enterprise Work appeared first on Taswar Bhatti.

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

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

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

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

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

The post 5 Highlights Thursday | 23th April 2026 (#109 Edition) appeared first on Taswar Bhatti.

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

---

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.

The post GPT‑Image‑2 Comes to Microsoft Foundry: What Developers Need to Know appeared first on Taswar Bhatti.

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

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

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

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

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?

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

The post 5 Highlights Thursday | 16th April 2026 (#108 Edition) appeared first on Taswar Bhatti.

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

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

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

The post 5 Highlights Thursday | 9th April 2026 (#107 Edition) appeared first on Taswar Bhatti.

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

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

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

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

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

The post 5 Highlights Thursday | 2nd April 2026 (#106 Edition) appeared first on Taswar Bhatti.