Azure | The .NET Blog

Azure MCP Server Is Nu een .mcpb — Installeer het Zonder Runtime

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Klik hier voor de originele versie.

Weet je wat vervelend was aan het instellen van MCP-servers? Je had een runtime nodig. Node.js voor de npm-versie, Python voor pip/uvx, .NET SDK voor de dotnet-variant.

De Azure MCP Server heeft dat net veranderd. Het is nu beschikbaar als .mcpb — een MCP Bundle — en de installatie is slepen en neerzetten.

Wat is een MCP Bundle?

Denk eraan als een VS Code-extensie (.vsix) of een browserextensie (.crx), maar voor MCP-servers. Een .mcpb-bestand is een zelfstandig ZIP-archief met de serverbinary en alle afhankelijkheden.

Hoe te installeren

1. Download de bundle voor uw platform

Ga naar de GitHub Releases-pagina en download het .mcpb-bestand voor uw OS en architectuur.

2. Installeer in Claude Desktop

Het gemakkelijkst: sleep het .mcpb-bestand naar het Claude Desktop-venster terwijl u op de pagina Extensie-instellingen bent (☰ → Bestand → Instellingen → Extensies). Bekijk de serverdetails, klik op Installeren, bevestig.

3. Verifieer bij Azure

az login

Aan de slag

Download: GitHub Releases
Repository: aka.ms/azmcp
Docs: aka.ms/azmcp/docs

Bekijk het volledige bericht.

GPT-5.5 Is Er en Komt naar Azure Foundry — Wat .NET-Ontwikkelaars Moeten Weten

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Klik hier voor de originele versie.

Microsoft heeft zojuist aangekondigd dat GPT-5.5 algemeen beschikbaar is in Microsoft Foundry. Als u agents op Azure bouwt, is dit de update waarop u wachtte.

De GPT-5 progressie

GPT-5: combineerde redenering en snelheid in één systeem
GPT-5.4: sterkere meerstaps-redenering, vroege agentische mogelijkheden voor enterprise
GPT-5.5: diepere langecontextredenering, betrouwbaardere agentische uitvoering, betere tokenefficiëntie

Wat er echt veranderd is

Verbeterde agentische codering: GPT-5.5 behoudt context over grote codebases, diagnosticeert architectuurfouten en anticipeert op testvereisten. Het model redeneert over wat anders een oplossing beïnvloedt voordat het actie onderneemt.

Tokenefficiëntie: Hogere kwaliteitsoutputs met minder tokens en minder pogingen. Direkt lagere kosten en latency voor productie-deployments.

Prijzen

Model	Invoer ($/M tokens)	Gecachte invoer	Uitvoer ($/M tokens)
GPT-5.5	$5,00	$0,50	$30,00
GPT-5.5 Pro	$30,00	$3,00	$180,00

Waarom Foundry belangrijk is

Foundry Agent Service stelt u in staat agents in YAML te definiëren of ze te verbinden met Microsoft Agent Framework, GitHub Copilot SDK, LangGraph of OpenAI Agents SDK — en ze uit te voeren als geïsoleerde gehoste agents met een persistent bestandssysteem, een eigen Microsoft Entra-identiteit en scale-to-zero prijsstelling.

AIAgent agent = aiProjectClient
 .AsAIAgent("gpt-5.5", instructions: "U bent een behulpzame assistent.", name: "MijnAgent");

Bekijk de volledige aankondiging voor alle details.

Foundry Toolboxes: Eén endpoint voor alle tools van je AI-agenten

Emiliano Montesdeoca — Thu, 23 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Voor de originele versie, klik hier.

Er is een probleem dat triviaal lijkt totdat je het zelf tegenkomt: de organisatie bouwt meerdere AI-agenten, elk heeft tools nodig, en elk team configureert die van de grond af. Dezelfde webzoekintegratie, dezelfde Azure AI Search-configuratie, dezelfde GitHub MCP-serververbinding — maar in een ander repository, door een ander team, met andere credentials en zonder gedeeld beheer.

Microsoft Foundry heeft zojuist Toolboxes uitgebracht in public preview — een directe oplossing voor dit probleem.

Wat is een Toolbox?

Een Toolbox is een benoemde, herbruikbare toolbundel die je eenmalig definieert in Foundry en beschikbaar stelt via één MCP-compatibel endpoint. Elke agent-runtime die MCP spreekt, kan het consumeren — geen lock-in bij Foundry Agents.

De belofte is eenvoudig: build once, consume anywhere. Definieer de tools, configureer authenticatie centraal (OAuth passthrough, Entra beheerde identiteit), publiceer het endpoint. Elke agent die die tools nodig heeft, verbindt zich eenmalig en krijgt ze allemaal.

De vier pijlers (twee vandaag beschikbaar)

Pijler	Status	Wat het doet
Discover	Binnenkort	Goedgekeurde tools vinden zonder handmatig zoeken
Build	Beschikbaar	Tools samenvoegen in een herbruikbare bundel
Consume	Beschikbaar	Één MCP-endpoint stelt alle tools beschikbaar
Govern	Binnenkort	Centrale authenticatie + observability voor alle tool-calls

Praktisch voorbeeld

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
import os

client = AIProjectClient(
 endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
 credential=DefaultAzureCredential()
)

toolbox_version = client.beta.toolboxes.create_toolbox_version(
 toolbox_name="customer-feedback-triaging-toolbox",
 description="Zoek in documentatie en reageer op GitHub-issues.",
 tools=[
 {"type": "web_search", "description": "Zoek openbare documentatie"},
 {"type": "azure_ai_search", "index_name": "internal-docs"},
 {"type": "mcp_server", "server_url": "https://your-github-mcp-server.com"}
 ]
)

Na publicatie geeft Foundry een uniform endpoint. Één verbinding, alle tools.

Geen lock-in bij Foundry Agents

Toolboxes worden aangemaakt en beheerd in Foundry, maar het consumptieoppervlak is het open MCP-protocol. Ze zijn bruikbaar vanuit eigen agents (Microsoft Agent Framework, LangGraph), GitHub Copilot en andere MCP-compatibele IDEs.

Waarom dit nu belangrijk is

De multi-agent golf bereikt productie. Elke nieuwe agent is een nieuw oppervlak voor gedupliceerde configuratie, verlopen credentials en inconsistent gedrag. De Build + Consume-basis is voldoende om met centraliseren te beginnen. Wanneer de Govern-pijler komt, beschikt men over een volledig observeerbare, centraal gestuurde tool-laag voor de gehele agentenvloot.

Conclusie

Dit is nog vroeg — public preview, Python SDK eerst, met Discover en Govern nog in aantocht. Maar het model is degelijk en het MCP-native design zorgt dat het werkt met de tools die al worden gebouwd. Alle details in de officiële aankondiging.

azd + GitHub Copilot: AI-gedreven projectopzet en slimme foutoplossing

Emiliano Montesdeoca — Tue, 21 Apr 2026 00:00:00 +0000

Ken je dat moment waarop je een bestaande app naar Azure wilt deployen en je naar een lege azure.yaml staart, terwijl je probeert te herinneren of je Express API Container Apps of App Service moet gebruiken? Dat moment is zojuist een stuk korter geworden.

De Azure Developer CLI (azd) integreert nu met GitHub Copilot op twee concrete manieren: AI-ondersteunde projectscaffolding tijdens azd init, en intelligente foutoplossing wanneer deployments mislukken. Beide functies blijven volledig in de terminal.

Setup met Copilot tijdens azd init

Wanneer je azd init uitvoert, is er nu een optie “Set up with GitHub Copilot (Preview)”. Selecteer die en Copilot analyseert je codebase om de azure.yaml, infrastructuursjablonen en Bicep-modules te genereren — gebaseerd op je echte code.

azd init
# Selecteer: "Set up with GitHub Copilot (Preview)"

Vereisten:

azd 1.23.11 of nieuwer — controleer met azd version of update met azd update
Actief GitHub Copilot-abonnement (Individual, Business of Enterprise)
GitHub CLI (gh) — azd vraagt om login als dat nodig is

Wat ik echt nuttig vind: het werkt in beide richtingen. Bouw je van de grond af? Copilot helpt je de juiste Azure-services vanaf het begin te configureren. Heb je een bestaande app die je wilt deployen? Wijs Copilot daarop en het genereert de configuratie zonder dat je iets hoeft te herstructureren.

Wat het eigenlijk doet

Stel je hebt een Node.js Express API met een PostgreSQL-afhankelijkheid. In plaats van handmatig te kiezen tussen Container Apps en App Service en dan Bicep van de grond af te schrijven, detecteert Copilot je stack en genereert:

Een azure.yaml met de juiste language-, host- en build-instellingen
Een Bicep-module voor Azure Container Apps
Een Bicep-module voor Azure Database for PostgreSQL

En het voert voorafgaande controles uit voor wijzigingen — verifieert dat je git-werkdirectory schoon is, vraagt van tevoren toestemming voor MCP-servertools. Niets gebeurt zonder dat je precies weet wat er gaat veranderen.

Foutoplossing met Copilot

Deployment-fouten zijn onvermijdelijk. Ontbrekende parameters, toestemmingsproblemen, SKU-beschikbaarheid — en het foutbericht vertelt je zelden het enige dat je echt moet weten: hoe je het oplost.

Zonder Copilot ziet de lus er zo uit: kopieer de fout → zoek in docs → lees drie irrelevante Stack Overflow-antwoorden → voer wat az CLI-opdrachten uit → probeer opnieuw en hoop. Met Copilot geïntegreerd in azd stort deze lus in. Wanneer een azd-opdracht mislukt, biedt het onmiddellijk vier opties:

Explain — uitleg in begrijpelijke taal van wat er mis ging
Guidance — stapsgewijze instructies om het probleem op te lossen
Diagnose and Guide — volledige analyse + Copilot past de oplossing toe (met jouw goedkeuring) + optioneel opnieuw proberen
Skip — zelf afhandelen

Het cruciale punt: Copilot heeft al context over je project, de mislukte opdracht en de foutdetails. Zijn suggesties zijn specifiek voor jouw situatie.

Een standaardgedrag instellen

Als je altijd dezelfde optie kiest, sla de interactieve prompt over:

azd config set copilot.errorHandling.category troubleshoot

Waarden: explain, guidance, troubleshoot, fix, skip. Je kunt ook automatisch herstellen en opnieuw proberen inschakelen:

azd config set copilot.errorHandling.fix allow

Op elk moment terug naar de interactieve modus:

azd config unset copilot.errorHandling.category

Samenvatting

Voer azd update uit voor de nieuwste versie en probeer azd init op je volgende project.

Lees de originele aankondiging hier.

Foundry RFT Is Goedkoper en Slimmer Geworden — Dit Is Wat Er Veranderd Is

Emiliano Montesdeoca — Sat, 18 Apr 2026 00:00:00 +0000

Als je .NET-apps bouwt die op fijnafgestelde modellen vertrouwen, zijn de Foundry-updates van deze maand de moeite waard.

De volledige details staan in de officiële aankondiging.

Globale training voor o4-mini

o4-mini is het go-to-model voor redeneerwerk en agentische workloads. Je kunt nu fine-tuning-taken starten vanuit 13+ Azure-regio’s met lagere per-token-trainingstarieven.

"trainingType": "globalstandard"

Nieuwe modelbeoordelaars: GPT-4.1-familie

Drie nieuwe opties: GPT-4.1, GPT-4.1-mini en GPT-4.1-nano.

Indelingsstrategie:

GPT-4.1-nano voor eerste iteraties. Lage kosten, snelle feedbacklussen.
GPT-4.1-mini zodra de beoordelingsrubric stabiel is.
GPT-4.1 voor productiebeoordeling.

De RFT-gegevensformaatval

RFT-gegevensformaat verschilt van SFT. Het laatste bericht in elke rij moet de rol User of Developer hebben — niet Assistant.

Waarom dit belangrijk is voor .NET-ontwikkelaars

Goedkopere training betekent agressiever kunnen itereren. De best practices-gids op GitHub bespaart echte debugging-tijd.

Je AI-experimenten op Azure Verbranden Geld — Hier is Hoe je Dat Oplost

Emiliano Montesdeoca — Sat, 18 Apr 2026 00:00:00 +0000

Als je momenteel AI-aangedreven apps bouwt op Azure, heb je waarschijnlijk iets opgemerkt: je cloudfactuur ziet er anders uit. Niet alleen hoger — vreemder. Grillig. Moeilijk te voorspellen.

Microsoft heeft zojuist een geweldig stuk gepubliceerd over cloud cost optimization-principes die nog steeds relevant zijn.

Waarom AI-workloads anders zijn

Traditionele .NET-workloads zijn relatief voorspelbaar. AI-workloads? Niet echt. Je test meerdere modellen, draait GPU-infrastructuur op, en maakt API-aanroepen naar Azure OpenAI waarbij tokenverbruik enorm varieert.

Beheer vs. optimalisatie — ken het verschil

Beheer: bijhouden en rapporteren.
Optimalisatie: daadwerkelijk beslissingen nemen. Heb je echt die S3-laag nodig? Zit die altijd-aan instantie in het weekend te niets doen?

Wat echt werkt

Tag je resources — als je niet kunt zien welk project je budget opeet, kun je niets optimaliseren
Stel vangrails in vóór experimenten — gebruik Azure Policy om dure SKU’s te beperken
Pas de grootte voortdurend aan — bekijk aanbevelingen van Azure Advisor
Denk aan de levenscyclus — dev-resources moeten worden afgesloten
Meet waarde, niet alleen kosten — een duurder model dat significant betere resultaten levert, kan de juiste keuze zijn

Azure MCP-tools zijn nu Ingebouwd in Visual Studio 2022 — Geen Extensie Nodig

Emiliano Montesdeoca — Thu, 16 Apr 2026 00:00:00 +0000

Als je de Azure MCP-tools in Visual Studio hebt gebruikt via de afzonderlijke extensie, ken je de procedure — VSIX installeren, herstarten, hopen dat het niet stukgaat, versieverschillen beheren. Die wrijving is weg.

Yun Jung Choi kondigde aan dat Azure MCP-tools nu rechtstreeks worden meegeleverd als onderdeel van de Azure-ontwikkelworkload in Visual Studio 2022. Geen extensie. Geen VSIX.

Hoe in te schakelen

Update naar Visual Studio 2022 17.14.30 of hoger
Zorg ervoor dat de workload Azure development is geïnstalleerd
Open GitHub Copilot Chat
Klik op de knop Tools selecteren (het pictogram met twee moersleutels)
Zet Azure MCP Server aan

Blijft ingeschakeld tussen sessies.

Kanttekening

De tools zijn standaard uitgeschakeld — je moet ze inschakelen. Voor .NET-ontwikkelaars in Visual Studio verwijdert dit nog een reden om context te wisselen naar de Azure-portal.

Aspire 13.2 Krijgt MongoDB EF Core en Azure Data Lake — Twee Integraties Die het Proberen Waard Zijn

Emiliano Montesdeoca — Wed, 15 Apr 2026 00:00:00 +0000

Aspire 13.2 is geland met twee nieuwe database-integraties die de moeite waard zijn: MongoDB Entity Framework Core en Azure Data Lake Storage.

MongoDB ontmoet EF Core in Aspire

Aspire ondersteunde MongoDB al een tijdje, maar het was altijd de ruwe driver — geen EF Core, geen DbContext, geen LINQ-query’s. Nu krijg je de volledige EF Core-ervaring met MongoDB, samen met Aspire’s automatische health checks en service discovery.

Instellingen in AppHost:

var mongodb = builder.AddMongoDB("mongodb")
 .WithDataVolume()
 .WithLifetime(ContainerLifetime.Persistent);

var apiService = builder.AddProject<Projects.ApiService>("api")
 .WithReference(mongodb);

In het verbruikende project:

dotnet add package Aspire.MongoDB.EntityFrameworkCore

Registreer je DbContext:

builder.AddMongoDbContext<MyDbContext>("mongodb", "mydb");

De integratie regelt connection pooling, OpenTelemetry-traces en health checks achter de schermen.

Azure Data Lake Storage doet mee

In AppHost:

var storage = builder.AddAzureStorage("azure-storage");
var dataLake = storage.AddDataLake("data-lake");
var fileSystem = storage.AddDataLakeFileSystem("data-lake-file-system");

var analyticsService = builder.AddProject<Projects.AnalyticsService>("analytics")
 .WithReference(dataLake)
 .WithReference(fileSystem);

In het verbruikende project:

builder.AddAzureDataLakeServiceClient("data-lake");
builder.AddAzureDataLakeFileSystemClient("data-lake-file-system");

Geen handmatig beheer van verbindingsstrings, geen zoektocht naar inloggegevens.

Samenvatting

Aspire 13.2 is een incrementele release, maar de MongoDB EF Core en Data Lake-integraties vullen echte gaten. Upgrade naar 13.2 en probeer ze uit.

azd update — Één Opdracht voor Al je Package Managers

Emiliano Montesdeoca — Wed, 15 Apr 2026 00:00:00 +0000

Ken je dat bericht “Een nieuwe versie van azd is beschikbaar” dat elke paar weken verschijnt? De boodschap die je wegklikt omdat je niet meer weet of je azd via winget, Homebrew of dat curl-script van zes maanden geleden hebt geïnstalleerd? Dat is eindelijk opgelost.

Microsoft heeft zojuist azd update uitgebracht — één opdracht die de Azure Developer CLI bijwerkt naar de nieuwste versie, ongeacht hoe je het oorspronkelijk hebt geïnstalleerd.

Hoe het werkt

azd update

Dat is alles. Voor vroege toegang tot nieuwe functies:

azd update --channel daily
azd update --channel stable

De opdracht detecteert je huidige installatiemethode en gebruikt het juiste updatemechanisme.

De kleine vangst

azd update wordt geleverd vanaf versie 1.23.x. Als je een oudere versie hebt, moet je één laatste handmatige update uitvoeren. Daarna regelt azd update alles.

Waarom het uitmaakt

Dit is een kleine kwaliteitsverbetering, maar voor degenen onder ons die azd dagelijks gebruiken voor het implementeren van AI-agents en Aspire-apps naar Azure, is het bijblijven belangrijk.

Lees de volledige aankondiging.

Azure Smart Tier is GA — Automatische Blob Storage Kostenoptimalisatie Zonder Levenscyclusregels

Emiliano Montesdeoca — Wed, 15 Apr 2026 00:00:00 +0000

Als je ooit tijd hebt besteed aan het afstemmen van Azure Blob Storage-levenscyclusbeleid en dit zag instorten wanneer toegangspatronen veranderden, is dit voor jou. Microsoft heeft zojuist de algemene beschikbaarheid van smart tier voor Azure Blob en Data Lake Storage aangekondigd.

Wat smart tier eigenlijk doet

Smart tier evalueert continu de tijd van laatste toegang van elk object in je opslagaccount. Frequent geraadpleegde gegevens blijven in hot, inactieve gegevens worden na 30 dagen naar cool verplaatst, daarna na nog eens 60 dagen naar cold. Wanneer gegevens opnieuw worden geopend, worden ze direct terug gepromoveerd naar hot.

Geen levenscyclusregels om te configureren. Geen handmatige afstemming.

Tijdens de preview meldde Microsoft dat meer dan 50% van de door smart tier beheerde capaciteit automatisch naar koelere lagen is verschoven.

Waarom dit belangrijk is voor .NET-ontwikkelaars

Praktische scenario’s:

Applicatietelemetrie en logboeken — hot bij foutopsporing, zelden geopend na een paar weken
Datapijplijnen en ETL-uitvoer — intensief benaderd tijdens verwerking, daarna meestal cold
Door gebruikers gegenereerde content — recente uploads zijn hot, oudere content koelt geleidelijk af

De afweging

De tieringregels van smart tier zijn statisch (30 dagen → cool, 90 dagen → cold). Als je aangepaste drempels nodig hebt, zijn levenscyclusregels nog steeds de weg te gaan.

Waar Moet Je je AI-Agents op Azure Hosten? Een Praktische Beslissingswijzer

Emiliano Montesdeoca — Wed, 15 Apr 2026 00:00:00 +0000

Als je momenteel AI-agents bouwt met .NET, heb je waarschijnlijk iets opgemerkt: er zijn veel manieren om ze te hosten op Azure. Container Apps, AKS, Functions, App Service, Foundry Agents, Foundry Hosted Agents.

Microsoft heeft zojuist een uitgebreide gids voor Azure AI agent-hosting gepubliceerd.

De zes opties in één oogopslag

Optie	Beste voor	Je beheert
Container Apps	Volledige containercontrole zonder K8s	Observabiliteit, staat, levenscyclus
AKS	Enterprise-naleving, multi-cluster	Alles
Azure Functions	Event-gedreven, korte taken	Bijna niets
App Service	Eenvoudige HTTP-agents	Implementatie, schaling
Foundry Agents	Optionele code-agents	Bijna niets
Foundry Hosted Agents	Aangepaste framework-agents	Alleen je agentcode

Foundry Hosted Agents — het juiste midden voor .NET agentdevelopers

Implementatie is echt eenvoudig:

azd ext install azure.ai.agents
azd ai agent init
azd up

Die ene azd up bouwt je container, stuurt hem naar ACR, richt het Foundry-project in en start je agent.

Mijn beslissingsraamwerk

Nul infrastructuur nodig? → Foundry Agents
Eigen agentcode maar beheerde hosting gewenst? → Foundry Hosted Agents
Event-gedreven, korte taken? → Azure Functions
Maximale containercontrole? → Container Apps
Strikte naleving en multi-cluster? → AKS

Samenvatting

Voor de meeste .NET-ontwikkelaars die bouwen met Semantic Kernel of Microsoft Agent Framework, is Hosted Agents waarschijnlijk het juiste startpunt. Bekijk de volledige gids van Microsoft.

Agent Skills in .NET Zijn Nu Serieus Flexibel

Emiliano Montesdeoca — Tue, 14 Apr 2026 00:00:00 +0000

Als je agents bouwt met Microsoft Agent Framework, ken je de werkwijze: je definieert skills, koppelt ze aan een provider en laat de agent bepalen welke hij aanroept. Nieuw is hoe je die skills schrijft — en de sprong in flexibiliteit is aanzienlijk.

De nieuwste update introduceert drie verschillende patronen voor het schrijven van agent skills: bestand-gebaseerd, klasse-gebaseerd en inline code-gedefinieerd. Alle drie koppelen aan één AgentSkillsProviderBuilder, wat betekent dat je ze kunt mixen zonder routeringslogica.

Bestand-gebaseerde skills: het startpunt

Bestand-gebaseerde skills zijn precies wat ze klinken — een map op schijf met een SKILL.md-bestand, optionele scripts en referentiedocumenten:

skills/
└── onboarding-guide/
├── SKILL.md
├── scripts/
│ └── check-provisioning.py
└── references/
└── onboarding-checklist.md

De frontmatter van SKILL.md declareert de skillnaam en beschrijving, en de instructiesectie vertelt de agent hoe scripts en referenties te gebruiken.

Je koppelt het met SubprocessScriptRunner.RunAsync:

var skillsProvider = new AgentSkillsProvider(
 Path.Combine(AppContext.BaseDirectory, "skills"),
 SubprocessScriptRunner.RunAsync);

Klasse-gebaseerde skills: leveren via NuGet

Hier wordt het interessant voor teams. Klasse-gebaseerde skills leiden af van AgentClassSkill<T> en gebruiken attributen zoals [AgentSkillResource] en [AgentSkillScript]:

public sealed class BenefitsEnrollmentSkill : AgentClassSkill<BenefitsEnrollmentSkill>
{
 public override AgentSkillFrontmatter Frontmatter { get; } = new(
 "benefits-enrollment",
 "Enroll an employee in health, dental, or vision plans.");

 [AgentSkillScript("enroll")]
 private static string Enroll(string employeeId, string planCode)
 {
 bool success = HrClient.EnrollInPlan(employeeId, planCode);
 return JsonSerializer.Serialize(new { success, employeeId, planCode });
 }
}

Een team kan dit als NuGet-pakket verpakken. Voeg het toe aan je project, stop het in de builder en het werkt naast je bestand-gebaseerde skills.

Inline skills: de snelle brug

Dat moment wanneer een ander team precies de skill bouwt die je nodig hebt, maar deze pas over een sprint beschikbaar is? AgentInlineSkill is je brug:

var timeOffSkill = new AgentInlineSkill(
 name: "time-off-balance",
 description: "Calculate remaining vacation and sick days.",
 instructions: "1. Vraag om medewerker-ID. 2. Gebruik calculate-balance. 3. Presenteer resultaten.")
 .AddScript("calculate-balance", (string employeeId, string leaveType) =>
 {
 int remaining = HrDatabase.GetAnnualAllowance(employeeId, leaveType)
 - HrDatabase.GetDaysUsed(employeeId, leaveType);
 return JsonSerializer.Serialize(new { employeeId, leaveType, remaining });
 });

Wanneer het NuGet-pakket verschijnt, vervang je de inline skill door de klasse-gebaseerde. De agent merkt het verschil niet.

Scriptgoedkeuring: human-in-the-loop

Voor .NET-ontwikkelaars die productie-agents bouwen, is dit het deel dat implementatiegesprekken daadwerkelijk deblokkert. Zet UseScriptApproval aan en de agent pauzeert voor het uitvoeren van elk script:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .UseScriptApproval(true)
 .Build();

Samenvatting

Agent skills in .NET hebben nu een echt flexibel schrijfmodel. Of je nu een prototype bouwt met bestand-gebaseerde skills of verpakte mogelijkheden via NuGet levert — alle patronen stellen samen via AgentSkillsProviderBuilder.

Bekijk de originele aankondiging en GitHub-voorbeelden.

Azure MCP Server 2.0 Net Uitgebracht — Self-Hosted Agentic Cloud Automatisering is er

Emiliano Montesdeoca — Sat, 11 Apr 2026 00:00:00 +0000

Als je recentelijk iets hebt gebouwd met MCP en Azure, weet je waarschijnlijk al dat de lokale ervaring goed werkt. Maar wanneer je die setup met je hele team moet delen? Daar werd het ingewikkeld.

Niet meer. Azure MCP Server heeft 2.0 stabiel bereikt, en de headlinefunctie is precies wat enterprise-teams hebben gevraagd: self-hosted remote MCP-serverondersteuning.

Wat is Azure MCP Server?

Azure MCP Server implementeert de Model Context Protocol-specificatie en exposeert Azure-mogelijkheden als gestructureerde, vindbare tools. De cijfers spreken voor zich: 276 MCP-tools in 57 Azure-services.

Het grote nieuws: self-hosted remote deployments

In een echt teamscenario heb je nodig:

Gedeelde toegang voor ontwikkelaars en interne agentsystemen
Gecentraliseerde configuratie
Enterprise-netwerk- en beleidslimieten
Integratie in CI/CD-pipelines

Azure MCP Server 2.0 pakt dit allemaal aan. Voor authenticatie zijn er twee opties:

Managed Identity — bij gebruik met Microsoft Foundry
On-Behalf-Of (OBO)-stroom — OpenID Connect-delegatie met de werkelijke rechten van de gebruiker

Beveiligingsverbetering

Versie 2.0 voegt sterkere endpointvalidatie, bescherming tegen injectiepatronen en strikter isolatiebeheer toe.

Aan de slag

GitHub Repo — broncode, documentatie
Docker Image — containerimplementatie
VS Code-extensie — IDE-integratie
Zelfhostinghandleiding — 2.0’s vlaggenschipfunctie

Agentic Platform Engineering Wordt Werkelijkheid — Git-APE Laat Zien Hoe

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Platform engineering is een van die termen die geweldig klinkt op conferenties maar meestal “we hebben een intern portaal en een Terraform-wrapper gebouwd” betekent. De echte belofte — self-service infrastructuur die werkelijk veilig, beheerd en snel is — was altijd een paar stappen verwijderd.

Het Azure-team heeft zojuist Deel 2 van hun agentic platform engineering-serie gepubliceerd. Ze noemen het Git-APE — een open-source project dat GitHub Copilot-agents en Azure MCP-servers gebruikt om natuurlijke taalverzoeken om te zetten in gevalideerde, geïmplementeerde infrastructuur.

Wat Git-APE eigenlijk doet

Het kernidee: in plaats van Terraform-modules te leren, praten ontwikkelaars met een Copilot-agent. De agent interpreteert de intentie, genereert Infrastructure-as-Code, valideert tegen beleid en implementeert — allemaal in VS Code.

git clone https://github.com/Azure/git-ape
cd git-ape

Open de werkruimte in VS Code, en de agent-configuratiebestanden worden automatisch gevonden door GitHub Copilot:

@git-ape deploy a function app with storage in West Europe

Opruimen is net zo eenvoudig:

@git-ape destroy my-resource-group

Waarom dit ertoe doet

Voor degenen die op Azure bouwen, verschuift dit het platform engineering-gesprek van “hoe bouwen we een portaal” naar “hoe beschrijven we onze guardrails als API’s.”

Als .NET-ontwikkelaar: Azure MCP Server en GitHub Copilot-agents werken met elke Azure-workload — je ASP.NET Core API, .NET Aspire-stack — alles kan het doel zijn van een agentische deployment flow.

Samenvatting

Git-APE is een vroeg maar concreet beeld van agentic platform engineering in de praktijk. Clone de repo en lees de volledige post.

De Moderniseringsbeoordelingstool van GitHub Copilot Is het Beste Migratiehulpmiddel Dat Je Nog Niet Gebruikt

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Het migreren van een legacy .NET Framework-app naar modern .NET is een van die taken die iedereen weet dat ze moeten doen maar niemand wil beginnen.

Jeffrey Fritz heeft zojuist een diepgaande analyse van de moderniseringsbeoordelingstool van GitHub Copilot gepubliceerd.

Het is niet alleen een code-suggestie-engine

De VS Code-extensie volgt een Beoordeel → Plan → Uitvoer-model. De beoordelingsfase analyseert je volledige codebase en produceert een gestructureerd document dat alles vastlegt.

De beoordeling wordt opgeslagen onder .github/modernize/assessment/. Elke run produceert een onafhankelijk rapport.

Twee manieren om te starten

Aanbevolen beoordeling — het snelle pad. Kies uit gecureerde domeinen (Java/.NET Upgrade, Cloud Readiness, Security).

Aangepaste beoordeling — het gerichte pad. Configureer exact wat te analyseren: doelcomputing (App Service, AKS, Container Apps), doelbesturingssysteem, containerisatieanalyse.

De probleemindeling is uitvoerbaar

Elk probleem heeft een kriticiteitsniveau:

Verplicht — moet worden opgelost of migratie mislukt
Potentieel — kan migratie beïnvloeden, vereist menselijk oordeel
Optioneel — aanbevolen verbeteringen, blokkeert migratie niet

Mijn mening

Als je legacy .NET Framework-apps hebt, is dit het hulpmiddel om mee te beginnen.

Lees de volledige walkthrough en download de VS Code-extensie.

Microsoft Foundry Maart 2026 — GPT-5.4, Agent Service GA en de SDK-vernieuwing die Alles Verandert

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

De maandelijkse ‘Wat is er nieuw in Microsoft Foundry’-berichten zijn meestal een mix van incrementele verbeteringen. De editie van maart 2026? Vrijwel allemaal headlinefuncties.

Foundry Agent Service is productieklaar

De volgende generatie agent runtime is algemeen beschikbaar — gebouwd op de OpenAI Responses API, wire-compatibel met OpenAI agents.

Belangrijkste toevoegingen: end-to-end privénetwerken, uitbreiding van MCP-auth, Voice Live-preview en hosted agents in 6 nieuwe regio’s.

GPT-5.4 — betrouwbaarheid boven ruwe intelligentie

GPT-5.4 gaat niet over slimmer zijn. Het gaat over betrouwbaarder zijn.

Model	Prijsstelling (per M tokens)	Het beste voor
GPT-5.4 (≤272K)	$2.50 / $15 output	Productieagents
GPT-5.4 Pro	$30 / $180 output	Diepgaande analyse
GPT-5.4 Mini	Kosteneffectief	Classificatie, extractie

De SDK is eindelijk stabiel

De azure-ai-projects SDK heeft stabiele releases uitgebracht in alle talen — inclusief .NET 2.0.0.

Fireworks AI brengt open modellen naar Azure

DeepSeek V3.2, gpt-oss-120b, Kimi K2.5 beschikbaar bij lancering.

Lees de volledige samenvatting.

Real-Time Multi-Agent UI's Bouwen Die Niet Aanvoelen als een Black Box

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Dit is de werkelijkheid over multi-agent systemen: ze zien er geweldig uit in demo’s. Drie agents die werk aan elkaar doorgeven, problemen oplossen, beslissingen nemen. Dan probeer je het aan echte gebruikers te tonen en… stilte. Een draaiende indicator. Geen idee welke agent wat doet of waarom het systeem gepauzeerd is. Dat is geen product — dat is een vertrouwensprobleem.

Het Microsoft Agent Framework-team heeft zojuist een fantastisch overzicht gepubliceerd over het koppelen van MAF-workflows aan AG-UI, een open protocol voor het streamen van agent-uitvoeringsgebeurtenissen naar een frontend via Server-Sent Events. En eerlijk gezegd? Dit is precies de brug die we misten.

Waarom dit belangrijk is voor .NET-ontwikkelaars

Als je AI-aangedreven apps bouwt, ben je waarschijnlijk al tegen deze muur opgelopen. Je backend-orkestratie werkt prima — agents geven werk aan elkaar door, tools worden uitgevoerd, beslissingen worden genomen. Maar de frontend heeft geen idee wat er achter de schermen gebeurt. AG-UI lost dit op door een standaardprotocol te definiëren voor het streamen van agentgebeurtenissen (RUN_STARTED, STEP_STARTED, TOOL_CALL_*, TEXT_MESSAGE_*) rechtstreeks naar je UI-laag via SSE.

De demo die ze bouwden is een klantenserviceworkflow met drie agents: een triageagent die verzoeken routeert, een terugbetalingsagent die financiële zaken afhandelt, en een orderagent die vervangingen beheert. Elke agent heeft zijn eigen tools, en de handoff-topologie is expliciet gedefinieerd — geen “bedenk het maar uit de prompt”-sfeer.

De handoff-topologie is de echte ster

Wat mij opviel is hoe HandoffBuilder je in staat stelt een gerichte routeringsgraf tussen agents te declareren:

builder = HandoffBuilder(
 name="ag_ui_handoff_workflow_demo",
 participants=[triage, refund, order],
 termination_condition=termination_condition,
)

(
 builder
 .add_handoff(triage, [refund], description="Refunds, damaged-item claims...")
 .add_handoff(triage, [order], description="Replacement, exchange...")
 .add_handoff(refund, [order], description="Replacement logistics needed after refund.")
 .add_handoff(order, [triage], description="After replacement/shipping tasks complete.")
)

Elke add_handoff maakt een gerichte koppeling met een beschrijving in natuurlijke taal. Het framework genereert handoff-tools voor elke agent op basis van deze topologie. Routeringsbeslissingen zijn daardoor gegrond in jouw orkestratiestucture, niet in wat het LLM toevallig wil doen. Dat is enorm belangrijk voor betrouwbaarheid in productie.

Human-in-the-loop die echt werkt

De demo toont twee onderbrekingspatronen die elke echte agentapp nodig heeft:

Tool-goedkeuringsonderbrekingen — wanneer een agent een tool aanroept die is gemarkeerd met approval_mode="always_require", pauzeert de workflow en stuurt een gebeurtenis. De frontend toont een goedkeuringsmodal met de toolnaam en argumenten. Geen token-verspillende herhalingsloops — gewoon een nette pauze-goedkeur-hervat-stroom.

Informatieverzoekonderbrekingen — wanneer een agent meer context van de gebruiker nodig heeft (zoals een order-ID), pauzeert het en vraagt. De frontend toont de vraag, de gebruiker antwoordt, en de uitvoering gaat verder precies waar het gestopt was.

Beide patronen worden gestreamd als standaard AG-UI-gebeurtenissen, zodat je frontend geen aangepaste logica per agent nodig heeft — het rendert gewoon wat er via de SSE-verbinding binnenkomt.

Het aansluiten is verrassend eenvoudig

De integratie tussen MAF en AG-UI is één functieaanroep:

from agent_framework.ag_ui import (
 AgentFrameworkWorkflow,
 add_agent_framework_fastapi_endpoint,
)

app = FastAPI()

demo_workflow = AgentFrameworkWorkflow(
 workflow_factory=lambda _thread_id: create_handoff_workflow(),
 name="ag_ui_handoff_workflow_demo",
)

add_agent_framework_fastapi_endpoint(
 app=app, agent=demo_workflow, path="/handoff_demo",
)

De workflow_factory maakt een nieuwe workflow per thread, zodat elke conversatie geïsoleerde toestand heeft. Het endpoint regelt alle SSE-infrastructuur automatisch. Als je FastAPI al gebruikt (of het als lichte laag kunt toevoegen), is dit vrijwel nul wrijving.

Mijn kijk

Voor ons als .NET-ontwikkelaars is de directe vraag: “Kan ik dit in C# doen?” Agent Framework is beschikbaar voor zowel .NET als Python, en het AG-UI-protocol is taalonafhankelijk (het is gewoon SSE). Dus hoewel deze specifieke demo Python en FastAPI gebruikt, is het patroon direct overdraagbaar. Je kunt een ASP.NET Core minimal API aansluiten met SSE-endpoints die hetzelfde AG-UI-gebeurtenisschema volgen.

De grotere les is dat multi-agent UI’s een prioriteit worden, geen bijzaak. Als je iets bouwt waarbij agents met mensen interageren — klantenservice, goedkeuringsworkflows, documentverwerking — is deze combinatie van MAF-orkestratie en AG-UI-transparantie het te volgen patroon.

Samenvatting

AG-UI + Microsoft Agent Framework geeft je het beste van beide werelden: robuuste multi-agent orkestratie op de backend en real-time zichtbaarheid op de frontend. Geen black-box agentinteracties meer.

Bekijk de volledige walkthrough en de AG-UI protocol repository om dieper te gaan.

SQL MCP Server — De Juiste Manier om AI-agents Databasetoegang te Geven

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Laten we eerlijk zijn: de meeste database-MCP-servers die vandaag beschikbaar zijn, zijn angstaanjagend. Ze nemen een zoekopdracht in natuurlijke taal, genereren SQL on-the-fly en voeren het uit op je productiegegevens.

Het Azure SQL-team heeft zojuist SQL MCP Server geïntroduceerd, en het neemt een fundamenteel andere aanpak.

Waarom geen NL2SQL?

Modellen zijn niet deterministisch. SQL MCP Server gebruikt een NL2DAB-aanpak. De agent werkt met de entiteitsabstractielaag van Data API builder om nauwkeurige T-SQL deterministisch te produceren.

Zeven tools, niet zevenhonderd

SQL MCP Server biedt precies zeven DML-tools:

describe_entities — ontdek beschikbare entiteiten
create_record — rijen invoegen
read_records — tabellen en views opvragen
update_record — rijen wijzigen
delete_record — rijen verwijderen
execute_entity — opgeslagen procedures uitvoeren
aggregate_records — aggregatiequery’s

In drie opdrachten aan de slag

dab init --database-type mssql --connection-string "@env('sql_connection_string')"

dab add Customers --source dbo.Customers --permissions "anonymous:*"

dab start

Het beveiligingsverhaal is solide

RBAC op elke laag, Azure Key Vault-integratie, Microsoft Entra + aangepaste OAuth.

Bekijk de volledige post en documentatie.

Verbind Je MCP-servers op Azure Functions met Foundry-agents — Dit Is Hoe

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Er is één ding dat ik geweldig vind aan het MCP-ecosysteem: je bouwt je server één keer en het werkt overal.

Lily Ma van het Azure SDK-team publiceerde een praktische gids over het verbinden van MCP-servers die zijn geïmplementeerd op Azure Functions met Microsoft Foundry-agents.

Waarom deze combinatie logisch is

Azure Functions geeft je schaalbare infrastructuur, ingebouwde authenticatie en serverless facturering. Microsoft Foundry geeft je AI-agents die kunnen redeneren en actie ondernemen.

Authenticatie-opties

Methode	Gebruikssituatie
Sleutelgebaseerd	Ontwikkeling of servers zonder Entra auth
Microsoft Entra	Productie met beheerde identiteiten
OAuth identity passthrough	Productie met gebruikerscontext
Niet-geverifieerd	Dev/testen of alleen publieke gegevens

Instellen

Deploy je MCP-server naar Azure Functions — voorbeelden beschikbaar voor .NET
Schakel ingebouwde MCP-authenticatie in
Haal de endpoint-URL op — https://<FUNCTION_APP_NAME>.azurewebsites.net/runtime/webhooks/mcp
Voeg de MCP-server toe als tool in Foundry

Lees de volledige gids.

azd Laat Je Nu AI-Agents Lokaal Uitvoeren en Debuggen — Dit Veranderde in Maart 2026

Emiliano Montesdeoca — Thu, 02 Apr 2026 00:00:00 +0000

Zeven releases in één maand. Dat is wat het Azure Developer CLI (azd)-team in maart 2026 uitbracht, en de hoofdfunctie is waar ik op wachtte: een lokale loop voor uitvoeren en debuggen van AI-agents.

AI-agents uitvoeren en debuggen zonder implementeren

Dit is de grote. De nieuwe extensie azure.ai.agents voegt een reeks opdrachten toe:

azd ai agent run — start je agent lokaal
azd ai agent invoke — stuurt berichten naar hem (lokaal of geïmplementeerd)
azd ai agent show — toont containerstatus en gezondheid
azd ai agent monitor — streamt containerlogs in real-time

Voorheen betekende het testen van een AI-agent telkens implementeren naar Microsoft Foundry. Nu kun je lokaal itereren.

GitHub Copilot maakt je azd-project aan

azd init biedt nu een optie “Set up with GitHub Copilot (Preview)”. Een Copilot-agent maakt de configuratie voor je projectstructuur.

Container App Jobs en implementatieverbeteringen

Container App Jobs: azd implementeert nu Microsoft.App/jobs via de bestaande host: containerapp-config
Configureerbare implementatie-time-outs: Nieuwe --timeout-vlag op azd deploy
Lokale build-fallback: Wanneer remote ACR-build mislukt, schakelt azd automatisch terug naar lokale Docker/Podman
Lokale preflight-validatie: Bicep-parameters worden lokaal gevalideerd vóór implementatie

Samenvatting

De lokale AI-agent debuggingloop is de ster van deze release. Bekijk de volledige releasenotes.

KubeCon Europe 2026: Waar .NET-ontwikkelaars Echt Op Moeten Letten

Emiliano Montesdeoca — Sun, 29 Mar 2026 00:00:00 +0000

Microsoft publiceerde zojuist hun volledige KubeCon Europe 2026-samenvatting.

mTLS zonder service mesh-belasting

Azure Kubernetes Application Network geeft je onderlinge TLS, applicatiebewuste autorisatie en verkeerstelemetrie — zonder een volledige sidecar-mesh. Je ASP.NET Core API’s die met achtergrondworkers communiceren — alles versleuteld op netwerkniveau, zonder wijzigingen in applicatiecode.

GPU-observeerbaarheid

AKS toont nu GPU-metrics native in beheerde Prometheus en Grafana. Geen aangepaste exporteurs.

Netwerken over clusters heen

Azure Kubernetes Fleet Manager levert nu cross-cluster-netwerken — unified connectivity, globaal serviceregister.

Veiligere upgrades

Blauw-groene agent pool-upgrades maken een parallel knooppuntpool. Agent pool-terugdraaien laat je terugkeren naar de vorige versie.

Waar te beginnen

Observeerbaarheid eerst — schakel GPU-metrics en netwerkstroomlogboeken in
Probeer blauw-groene upgrades — test de terugdraaiworkflow
Pilot identiteitsbewust netwerken — schakel mTLS in voor één servicepad

SQL MCP Server, Copilot in SSMS en een Database Hub met AI-agents: Wat Er Echt Toe Doet van SQLCon 2026

Emiliano Montesdeoca — Sat, 28 Mar 2026 00:00:00 +0000

Microsoft heeft zojuist SQLCon 2026 gelanceerd naast FabCon in Atlanta. Ik sla de enterprise-prijsslides over en focus op de onderdelen die ertoe doen voor ontwikkelaars die met Azure SQL en AI bouwen.

SQL MCP Server is in openbare preview

Dit is de kop voor mij. Azure SQL Database Hyperscale heeft nu een SQL MCP Server in openbare preview waarmee je SQL-gegevens veilig kunt verbinden met AI-agents en Copilots via het Model Context Protocol.

Voor .NET-ontwikkelaars die AI-agents bouwen met Semantic Kernel of Microsoft Agent Framework opent dit een schoon integratiepad. Je agent moet voorraad controleren? Een klantrecord opzoeken? Een bestelling valideren? MCP geeft het een gestructureerde manier om dat te doen zonder aangepaste data-ophaalcode.

GitHub Copilot in SSMS 22 is nu GA

Als je tijd doorbrengt in SQL Server Management Studio, is GitHub Copilot nu algemeen beschikbaar in SSMS 22. Dezelfde Copilot-ervaring die je al gebruikt in VS Code en Visual Studio, maar voor T-SQL.

De praktische waarde is direct: op chat gebaseerde hulp bij het schrijven van query’s, refactoring van opgeslagen procedures, het oplossen van prestatieproblemen en beheertaken.

Vectorindexen kregen een serieuze upgrade

Azure SQL Database heeft nu snellere, capabelere vectorindexen met volledige ondersteuning voor invoegen, bijwerken en verwijderen. Dat betekent dat je vectorgegevens in real-time actueel blijven — geen batchherindexering nodig.

Wat nieuw is:

Kwantisering voor kleinere indexgroottes zonder te veel nauwkeurigheid te verliezen
Iteratief filteren voor preciezere resultaten
Tightere query-optimizer-integratie voor voorspelbare prestaties

Als je RAG doet met Azure SQL als vectoropslag, zijn deze verbeteringen direct bruikbaar.

Database Hub in Fabric: agentisch beheer

Microsoft kondigde de Database Hub in Microsoft Fabric aan (vroege toegang), die één venster biedt over Azure SQL, Cosmos DB, PostgreSQL, MySQL en SQL Server via Arc.

AI-agents bewaken continu je database-omgeving, signaleren wat veranderd is, leggen uit waarom het belangrijk is en stellen voor wat je vervolgens moet doen.

Wat dit betekent voor .NET-ontwikkelaars

Probeer SQL MCP Server als je AI-agents bouwt — de schoonste manier om agents databasetoegang te geven.
Schakel Copilot in SSMS in als je dat nog niet hebt gedaan.
Kijk naar vectorindexen als je RAG doet en momenteel een aparte vectoropslag gebruikt.

Bekijk de volledige aankondiging van Shireesh Thota en schrijf je in voor vroege toegang tot Database Hub.

Achtergrondreacties in Microsoft Agent Framework: Geen Timeout-angst Meer

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

Als je ooit iets hebt gebouwd met redeneermodellen zoals o3 of GPT-5.2, ken je de pijn. Je agent begint een complexe taak te verwerken, de client zit te wachten en ergens treedt een verbindingstime-out op.

Microsoft Agent Framework heeft zojuist achtergrondreacties uitgebracht — en eerlijk gezegd is dit een van die functies die er vanaf dag één had moeten zijn.

Hoe vervolgingstokens werken

In plaats van te blokkeren start je de agenttaak en krijg je een vervolgingstoken terug. Denk eraan als een klaim-ticket bij een reparatiewinkel:

Stuur je verzoek met AllowBackgroundResponses = true
Als de agent achtergrondverwerking ondersteunt, krijg je een vervolgingstoken
Poll op je planning totdat het token null terugkeert

AgentRunOptions options = new()
{
 AllowBackgroundResponses = true
};

AgentSession session = await agent.CreateSessionAsync();
AgentResponse response = await agent.RunAsync(
 "Write a detailed market analysis for the Q4 product launch.", session, options);

while (response.ContinuationToken is not null)
{
 await Task.Delay(TimeSpan.FromSeconds(2));
 options.ContinuationToken = response.ContinuationToken;
 response = await agent.RunAsync(session, options);
}

Console.WriteLine(response.Text);

Wanneer dit te gebruiken

Complexe redeneer taken — meerstapsanalyse, diepgaand onderzoek
Lange contentgeneratie — gedetailleerde rapporten, meerdelige documenten
Onbetrouwbare netwerken — mobiele clients, edge-implementaties
Asynchrone UX-patronen — taak indienen, iets anders doen, terugkomen voor resultaten

Bekijk de volledige documentatie.

Azure DevOps MCP Server Beschikbaar in Microsoft Foundry: Wat Dit Betekent voor je AI-Agents

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

MCP (Model Context Protocol) heeft z’n moment. Als je het AI-agent-ecosysteem volgt, heb je waarschijnlijk MCP-servers overal zien opduiken.

Nu is de Azure DevOps MCP Server beschikbaar in Microsoft Foundry, en dit is een van die integraties die je laat nadenken over de praktische mogelijkheden.

Wat er eigenlijk gebeurt

Microsoft heeft de Azure DevOps MCP Server al uitgebracht als publieke preview. Nieuw is de Foundry-integratie. Je kunt de Azure DevOps MCP Server nu toevoegen aan je Foundry-agents rechtstreeks vanuit de toolcatalogus.

Instellen

De instelling is verrassend eenvoudig:

Ga in je Foundry-agent naar Tools toevoegen > Catalogus
Zoek op “Azure DevOps”
Selecteer de Azure DevOps MCP Server (preview) en klik op Aanmaken
Voer je organisatienaam in en verbind

Toegang beheren

Je kunt opgeven welke tools beschikbaar zijn voor je agent. Principe van minste privileges, toegepast op je AI-agents.

Waarom dit interessant is voor .NET-teams

Sprint-planningsassistenten — agents die werkitems ophalen en sprintcapaciteit voorstellen
Code review-bots — agents die PR-context begrijpen
Incident response — agents die werkitems aanmaken en bugs correleren
Onboarding — echte antwoorden gebaseerd op projectdata

Samenvatting

Bekijk de volledige aankondiging voor details.

Foundry Agent Service is GA: Wat Er Echt Toe Doet voor .NET Agent-bouwers

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

Laten we eerlijk zijn — het bouwen van een AI-agentprototype is het gemakkelijke deel. Het moeilijke deel is alles erna.

De Foundry Agent Service is GA gegaan, en deze release is precies gericht op die “alles erna”-kloof.

Gebouwd op de Responses API

De volgende generatie Foundry Agent Service is gebouwd op de OpenAI Responses API. De architectuur is bewust open — je bent niet gebonden aan één modelprovider.

Privénetwerken: de enterprise-blokkade verwijderd

Geen publieke egress — agentverkeer raakt nooit het openbare internet
Container/subnet-injectie in je netwerk
Toolconnectiviteit inbegrepen — MCP-servers, Azure AI Search via privépaden

MCP-authenticatie

Auth-methode	Wanneer te gebruiken
Sleutelgebaseerd	Eenvoudige gedeelde toegang
Entra Agent Identity	Service-to-service
Entra Managed Identity	Per-project-isolatie
OAuth Identity Passthrough	Gebruikersdelegatie

Voice Live

Voice Live vouwt STT, LLM en TTS samen in één beheerde API.

Evaluaties

Kant-en-klare evaluatoren — coherentie, relevantie, grounding
Aangepaste evaluatoren — je eigen bedrijfslogica
Continue evaluatie — steekproeven van live productieverkeer

Bekijk de quickstart-gids en de GA-aankondiging.

Van Laptop naar Productie: AI-agents Implementeren naar Microsoft Foundry met Twee Opdrachten

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

Ken je die kloof tussen ‘het werkt op mijn machine’ en ‘het is geïmplementeerd en verwerkt verkeer’? Voor AI-agents was die kloof pijnlijk breed.

De Azure Developer CLI heeft dit een zaak van twee opdrachten gemaakt.

De nieuwe `azd ai agent` workflow

azd ai agent init
azd up

Dat is alles. azd ai agent init maakt een infrastructuur-als-code-skelet in je repo, en azd up richt alles in op Azure en publiceert je agent.

Wat er onder de motorkap gebeurt

De init-opdracht genereert echte, inspecterbare Bicep-sjablonen in je repo — Foundry Resource, Foundry Project, modelimplementatieconfiguratie, beheerde identiteit met RBAC.

Dev inner loop

azd ai agent run # agent lokaal starten
azd ai agent invoke # testprompts sturen
azd ai agent monitor --follow # real-time logs streamen

De volledige opdrachtset

Opdracht	Wat het doet
`azd ai agent init`	Foundry-agentproject scaffolden met IaC
`azd up`	Middelen inrichten en agent implementeren
`azd ai agent invoke`	Prompts sturen naar externe of lokale agent
`azd ai agent run`	Agent lokaal uitvoeren
`azd ai agent monitor`	Real-time logs streamen
`azd down`	Alle Azure-middelen opruimen

Bekijk de volledige walkthrough.