Sprekers

• 

  Arin Roy

  Sessie: From Prompting to Orchestrating: Building Reliable Agent Workflows with GitHub Copilot Custom Agents

  Most teams start with AI by prompting. Then reality hits: inconsistent output, brittle conventions, unclear ownership, and tool access that is either too locked down or too dangerous. The breakthrough is not a better prompt. It's a better system. In this session, we move from “chatting with Copilot” to orchestrating a practical multi-step workflow using GitHub Copilot custom agents, repository instructions, and Model Context Protocol (MCP). You'll learn how to design agent roles, enforce quality gates, and introduce safe handoffs so the AI can work independently while you stay in control. This is a hands-on session. We will live-build an agent workflow that runs through a realistic SDLC slice (plan → implement → test → document → review), using: - Repository and path-specific instructions to standardize behavior - Custom agents to separate concerns into focused “teammates” - MCP tooling to connect the agent to a controlled set of enterprise tools and APIs - Practical guardrails: approval points, drift detection, and review strategy We will also walk through the architectural trade-offs between single-agent, routed workflows, and supervisor-style orchestration and show how to pick the simplest pattern that still scales.

• 

  Chiel Kas

  Sessie: Zero Trust for Coding Agents

  I was afraid to hand a coding agent the keys, so I did what felt obvious: wrote it the rules and blocked the commands I feared — and watched it route around, ignore, and argue past every one of them. What finally worked wasn't a clever new trick but security classics that are 50 years old. This is the journey from fear to failure to a mindset that turns "can I hand it the keys?" into a design problem you can solve.

• 

  Christian Peeters

  Sessie: Getting started with Ethical Hacking

  Hacks, datalekken, randsomware… je hoort het steeds vaker in het nieuws. Om je bedrijf en/of je software goed te kunnen beveiligen moet je weten waar de kwetsbaarheden zitten. En hoe kun je daar beter achter komen, dan zelf proberen te hacken? In deze sessie kijken we naar hoe hackers te werk gaan en welke tools je kunt gebruiken om (je eigen) applicaties te hacken. Daarnaast kijken we naar de meest voorkomende types van kwetsbaarheden, hoe je kunt oefenen om deze uit te buiten en wat je kunt doen om ze te voorkomen. Met de opkomst van AI is er een heel nieuw speelveld bij gekomen. Hoe wordt dit gebruikt om te Hacken? Last but not least, wat tips om je collega's scherp te houden door het toepassen van Social Engineering.

• 

  de Kruijf, Wellenberg

  Sessie: From 10 to 10,000 Agents: Engineering a Governed AI Platform on Azure

  Building a single AI agent is easy, but engineering a platform that can support thousands of them is a different story. Have you ever tried to figure out which department is spending the most on tokens, or how to ensure every agent that ends up in production follows your safety guidelines? If you are struggling with shadow AI, you aren't alone. In this session, inspired by Citadel Foundry Platform, we will show you how to build a centrally governed AI platform on Azure. An AI engineer and an Azure platform engineer team up to walk through a reference architecture that handles token rate limiting, semantic caching, and security through APIM and Microsoft Foundry. We will look at how to manage agent identity with Entra ID and how to deploy this entire setup as a hub-and-spoke landing zone using Infrastructure as Code. On the practical side, we cover implementing an AI Gateway on APIM, setting up agent identity with Entra - everything deployed as code. Join us to see how you can move from scattered AI projects to a professional, manageable platform that your organization can actually trust.

• 

  Florian Lenz

  Sessie: Your Dependencies Are Already Compromised: A practical guide to securing your software supply chain

  Every day, millions of developers run npm install without a second thought. It is muscle memory. It is fast. It is how modern software gets built. And it is increasingly how attackers get in. Software supply chain attacks have become one of the most effective and most underreported attack vectors in the industry. Not because they are sophisticated, but because we have built our entire development workflow around trusting code we did not write, from people we have never met, installed automatically by tools we barely configure. This session is not a theoretical warning. It is a live demonstration of how a single malicious npm package silently exfiltrates your CI secrets, your cloud credentials, and your deployment tokens, while your pipeline stays green and nobody notices. And then it is a practical, immediately actionable playbook for fixing it.

• 

  Hans Muns

  Sessie: Event-Driven DevOps: Automating Azure with Event Grid System Topics

  Modern DevOps on Azure isn't just about pipelines, it's about making your platform reactive. With Event Grid system topics, you can automatically respond to changes in your Azure environment, triggering workflows the moment resources are created, updated, or deleted. In this session, we'll cover: - How system topics work and how they fit into DevOps workflows - Connecting Event Grid to various automation and orchestration tools - Different practical use cases for event-driven automation - A live demo where a resource change triggers a deployment-related automation After this session, you'll walk away with practical techniques to make your Azure platform more event-driven, reducing manual steps, closing feedback loops, and bringing DevOps automation to the next level.

• 

  Johnny Hooyberghs

  Sessie: Cloud-Native Superpowers with Microsoft Orleans

  Building distributed cloud-native applications is hard. Scaling them reliably is even harder. Microsoft Orleans helps make that complexity manageable with its virtual actor model: a powerful approach for building resilient, scalable, distributed systems without drowning in infrastructure code. In this code-heavy introductory session, we'll explore what Orleans is, why it exists, and how it can help you build cloud-native applications that scale. You'll learn the core concepts behind the distributed virtual actor model, including grains, silos, state management, and how Orleans handles the messy parts of distributed computing for you. Along the way, I'll show how I used Orleans in one of my own personal projects to enable flexible scaling in the real world. We'll finish by deploying the application to Azure Container Apps and looking at how Orleans fits naturally into a modern cloud-native architecture. Expect code, architecture, lessons learned, and a practical introduction to why Orleans might become your new favourite distributed systems framework.

• 

  Jos Hendriks

  Sessie: We don't need no stinkin' testers

  A world without testers, how great would that be? Just type your c# code, build things, deliver things without someone else nagging about bugs and quality. Honestly it would suck. But for different reasons than you would think! This is a session about what you as a developer can do to optimally benefit from testing, testers and how to use the presence of test expertise optimally. This session is fully packed with demos, tools and techniques. xUnit, approval testing, Aspire, playwright, reqnroll. They are all focused to prevent testing being an afterthought for someone else to solve. And be assured, we do need testers. They are even welcome to attend to this session ;)

• 

  Klaus Seiler

  Sessie: Why Your AI Needs a Knowledge Graph

  Most AI projects start with a model and a pile of documents, wire up retrieval, and hit a wall: the answers sound plausible but stay shallow, and nobody trusts them with anything that matters. The missing piece is usually not a better model. It is structure in the data. This session is about giving AI a data foundation it can reason over. You connect your information into a knowledge graph, describe it with an ontology so every system means the same thing by the same word, and let the LLM work over that instead of loose text. Microsoft Research arrived at the same place with GraphRAG, so this is not a niche direction. I will keep it concrete and draw on real projects where adding a graph changed what the AI could do. You will leave knowing when a graph earns its place and where to start.

• 

  Mart de Graaf

  Sessie: Minimal Images, Maximum Responsibility: Modern .NET Container Strategies

  Minimal container images sound appealing. They are smaller, faster, and seemingly more secure. In practice, many implicit assumptions disappear once you move from traditional Linux distributions to distroless, Wolfi, and apko. Package management, patching, CVE handling, and dependency selection shift from the distribution to the development team. Security is no longer an automatic side effect but an explicit design decision. In this session, we make that responsibility tangible. We walk through the full evolution of container images from traditional distributions to fully declarative builds using melange and apko, using a real world .NET application as our example. You will see how intentional package selection, reproducible builds, deterministic outputs, and CI CD integration improve control, auditability, and security. For organizations where security, compliance, and supply chain transparency matter, deterministic builds and SBOMs are not nice to haves but essential. After this session, you will be able to deliberately choose the container image strategy that fits your .NET applications, team maturity, and risk profile.

• 

  Maurice Peters

  Sessie: Two blind dreamers and a critic

  I built an MVU framework for .NET alone, with a team of sixteen agents — a Mealy machine kernel underneath, and event sourcing, actors and resilience on top. It holds its own against Blazor. This talk is not about the framework. The interesting question about AI-assisted development stopped being whether a model can write code. It's what happens at the third agent, the seventh pull request, and the first time two of them confidently write to the same file. I spend real time crafting what I ask for — but no prompt survives the seventh pull request. That takes a topology where the wrong outcome is unreachable. You'll see the machinery. Two design agents reasoning about the same problem while being structurally unable to see each other's work — one of them has no web access and no memory at all, so its independence from prior art is enforced by construction rather than by instruction. A critic that attacks the plan and never the code. A reviewer that is a terminal node: there is no path from "code changed" to "merged" that goes around it, and administrators are not exempt. Then the same idea one level down, inside the code itself — pure transition functions, effects as data, analyzers that reject invalid markup at compile time, a benchmark gate that fails the build. And the part that usually doesn't make it into an abstract: what none of this solved. A topology that makes wrong outcomes unreachable has nothing to say about whether you're building the right thing. That judgement never left my desk — and it's the one part of this I can't hand off.

• 

  Michiel Hamers

  Sessie: The Accidental Architect: When Responsibility Finds You

  Many architects did not plan to become architects. They became one because someone had to make decisions, connect the dots, and take responsibility when systems grew beyond a single team. In this session I focus on the role of the accidental architect. The senior developer or cloud engineer who slowly becomes responsible for architecture, cost, performance and stability, often without the formal title. I will discuss: - Common challenges for people growing into an architectural role - Making decisions without slowing teams down - Balancing technical depth with communication and trust - Learning architecture by doing, not by frameworks alone This session is aimed at people who already influence architecture today, even if it is not written on their business card.

• 

  Paul Stolk

  Sessie: Testing the Untestable: Getting Started with Agent Evaluation in C#

  Building an AI agent that works once on your machine is a great feeling. But how do you confidently deploy it when the output is non-deterministic and changes on every run? When dealing with Generative AI, traditional unit tests like Assert.AreEqual() completely fall apart. In this session, we are tackling the new frontier of AI development: Evaluation. Using the Microsoft Agent Framework in C#, I will introduce you to the fundamental concepts of testing AI applications, moving from "vibes-based" guesswork to actual metrics. We will start with the basics, looking at fast, Local Evaluators to run simple sanity checks in your C# code, like verifying if your agent actually called the tool it was supposed to. Then, we will gently introduce the concept of "LLM-as-a-judge" using Azure AI Foundry, showing how you can use another AI model to score the relevance and coherence of your agent's responses. Whether you are just starting with AI in .NET or looking for ways to stabilize your first intelligent applications, this session will give you the practical foundation you need to test with confidence.

• 

  Willem Koeter

  Sessie: Distributed Tracing in .NET: From W3C Spec to Production Observability

  Modern distributed systems make debugging and performance analysis challenging. A single user request can span dozens of services, and when something goes wrong, finding where is half the battle. Distributed tracing solves this by linking spans across service boundaries into a single coherent trace. In this session we explore how distributed tracing works from the ground up: what problem it solves, how the W3C Trace Context specification defines the wire format, and how .NET supports this out of the box through System.Diagnostics.Activity and ActivitySource. We then look at how OpenTelemetry builds on top of this foundation to deliver full maturity and cross-platform interoperability — including context propagation, sampling, and exporters. Along the way we take a practical look at how traces come to life in Application Insights and the .NET Aspire dashboard, and how the Aspire agent can collect and interpret telemetry to give you immediate insight into your running system. You will leave this session with a clear understanding of how distributed tracing flows through a .NET application, and the practical knowledge to enable and observe it in your own systems.