A tale of .NET migration - classic to modern
This session is a technical deep dive of a real-world customer case migrating a legacy .NET "Frankenstein" (Framework 2.0 to 4.x) solution with numerous side ghouls (tools) covering a total of approx. 500,000 lines of code. This was done from the point of view of a virgin developer who has never seen the architecture of the system, any SQL Server database relations or C# code structures, or any documentation of the solution before.
Join me on a journey of code exploration and damage analysis navigating the nontransparent structures of database entities through a hell of discontinued and vulnerable dependency assemblies to discover the lost art of the missing documentation.
With the previous lead developer age-related retired from daily operations and not in reach for consulting I'm going to show how Microsoft Copilot was used to bring back the sparks of joy by breaking down the changes into multiple stages.
By the end of the talk, we will have completed the migration and achieved a modern .NET solution with clean architecture, fresh web surface, using third-party NuGet packages to resolve dependencies, and having a documented product with illustrated guides and complete API references for back-end services and front-end functionalities.
The audience will get a battle-tested roadmap on .NET modernisation and migration benefiting from the capabilities of AI.
Success factor: A single senior developer completing the migration in roughly two months of daily activities without any prior knowledge of the solution.
Agents Building Agentic Apps: AI Goes Mobile with .NET MAUI
Use AI to build the app, then give the app that same AI.
In this demo-driven session, we’ll put agents on both sides of mobile development with .NET MAUI. First, see how GitHub Copilot, MAUI AI skills, and tools such as MAUI DevFlow and Ailoha help coding agents build, inspect, interact with, and debug a running app.
Then we’ll bring AI into the app itself. Using Microsoft.Extensions.AI and emerging tools from .NET MAUI Labs, we’ll connect an assistant to app services and real actions: finding information, navigating screens, and updating app state, with user approval where it matters.
Follow one mobile app through both halves: built with help from agents, and powered by AI that does more than chat.
Beyond the Prompt: Exploring AI-Assisted Game Development with .NET
How can developers use AI to explore an unfamiliar domain such as game development? This session will follow a small game-development experiment using C#, .NET, Visual Studio Code, Unity, and accessible cloud-based AI tools. The focus will be on the development process: defining a specification, guiding an AI agent, shaping the architecture, reviewing generated code, and validating the result. Along the way, we will connect these practices to web development and other areas of software engineering. No prior game-development experience is required; the session is an exploration of how AI can help developers learn, experiment, and build beyond their usual areas of expertise.
Bringing the Edge Into Focus
I built a digital microscope that combined IoT and AI into something useful, practical, and centred on accessibility. It could see, read, and talk, and it ran entirely in the cloud. This year, the journey is moving all of it from the cloud to the edge.
Join me as we take every capability off the cloud and onto the device itself. Vision, text recognition, speech, conversational AI, and even retrieval, all shifting from hosted services to models running locally on a small device, with no connection required. We will explore what each move from cloud to edge costs, where running locally surprises you, and what living on the device makes possible that the cloud never could.
Best of all, this is all still done with .NET and Avalonia.
Going from cloud to edge means this accessibility solution now travels with me, signal or not. Hopefully the session sparks some ideas about what else becomes possible when you move the intelligence onto the device.
Bulletproof RAG: Implementing Enterprise Guardrails, Semantic Caching, and Security
Building a Retrieval-Augmented Generation (RAG) prototype is easy; securing it for production is exceptionally difficult. When deploying AI to users, organizations face a new class of threats: prompt injection attacks, sensitive data leakage, uncontrolled token costs, and dangerous LLM hallucinations.
This session dives deep into the engineering mechanisms required to secure and optimize a production-ready RAG system. Drawing on a real-world implementation built for highly regulated sectors, we will explore how to protect your AI pipelines without degrading the user experience. We will discuss the architectural patterns you can implement in your own code, and how they map to enterprise tools like Azure AI Content Safety.
Key Takeaways for Software Engineers and Security Architects:
Defeating Prompt Injection at the Source: How to build zero-dependency heuristic scanners to detect role reassignments, persona hijacks, and jailbreak markers before malicious documents ever reach your vector database.
The Multi-Tier Guardrail Architecture: A look at a robust query-time interception pattern featuring Tier 1 intent matching, Tier 2 dictionary blocking, and Tier 3 parallel LLM binary classifiers that fail-open to ensure high availability.
Semantic Answer Caching: How to drastically reduce cloud token costs and drop response latency from 5 seconds down to 100ms by intercepting queries via vector similarity search (bypassing the LLM entirely for frequent questions).
The Q&A Knowledge Loop: Preventing "Circular Reasoning Drift" by capturing user interactions, verifying them with human-in-the-loop feedback, and securely re-ingesting them as trusted RAG context.
Continuous Quality Monitoring for .NET AI Agents with Amazon Bedrock
Most teams test an AI agent by chatting with it a few times, deciding it looks fine, and shipping it. That works until someone changes the prompt, swaps the model, or edits a tool definition, and the agent starts picking the wrong tool or giving confidently wrong answers. Nothing crashes. No error gets logged. The only signal is a support ticket a few days later.
This talk covers how to catch that kind of regression before it reaches users, using Amazon Bedrock AgentCore Evaluations. We'll build and instrument a .NET agent with OpenTelemetry, then run three demos live, scoring one session against built-in evaluators for correctness, helpfulness, and tool-use accuracy; adding an evaluation step to a GitHub Actions pipeline so a pull request fails automatically when agent quality drops; and checking evaluation scores against production traffic to catch drift after release. Attendees will walk away with working code and a pattern they can apply to their own .NET agents, regardless of which agent framework they're using, since AgentCore Evaluations works off OpenTelemetry traces rather than a specific SDK.
Don't Ask, Watch: Real-Time Data and AI with .NET 11 and Foundry Local
Most AI demos wait for someone to ask a question. But a lot of real data doesn't wait: sales, sensor readings, logs and payments keep arriving, and someone has to notice when
something matters. So why not just point an AI at the stream?
In this session we try exactly that, and watch it fall over. Latency climbs, the queue backs up, and the on-screen bill counter gets painful. Then we fix it the way stream
processing has always worked: channels, windows and simple rules in plain .NET 11 do the watching, and the model is only called for the handful of moments that actually need explaining. Model calls drop from hundreds a minute to a couple, and the explanations get *better*.
Along the way you'll see `System.Threading.Channels`, `IAsyncEnumerable`, backpressure, and a live dashboard fed by Server-Sent Events, now described in OpenAPI 3.2 in
.NET 11. It all runs on one laptop, with a local model served by Microsoft's Foundry Local, no cloud required. You leave with a pattern that works with any model and any message broker, and a clear sense of where AI adds value and where it only adds cost.
Foundry Local for .NET Developers
Building AI applications usually means relying heavily on cloud-hosted models, which introduces high token costs (COGs), unpredictable latency, and strict data privacy boundaries. While tools like Ollama or LM Studio offer local alternatives, they require your end-users to install heavy, external background dependencies, complicating the app distribution and installation pipeline
Enter Microsoft Foundry Local, a lightweight, 20-megabyte, on-device AI runtime that solves these challenges. It packages a highly optimised local AI stack directly inside your process, eliminating the need for self-hosting setups, Docker containers, or external software installations
In this session, we will deep-dive into how Foundry Local leverages the performance of ONNX Runtime and WinML to automatically select and run the absolute best variant of a model for your user's specific hardware, whether they have an NVIDIA GPU, Intel/Qualcomm NPU, Apple Silicon, or a standard CPU
Seamless Navigation in .NET MAUI with Prism”
Seamless Navigation in .NET MAUI with Prism.
Navigation is one of the trickiest parts of building a cross-platform .NET MAUI app — especially once you need deep linking, tab/flyout navigation, modal flows, and passing parameters between view models without turning your code into spaghetti. Prism brings a mature, battle-tested MVVM and navigation framework to MAUI, giving you a clean, testable way to manage navigation state, dependency injection, and view model lifecycle across platforms. In this session, we'll build seamless navigation flows using Prism's navigation service, explore parameter passing and deep linking, handle navigation lifecycle events (OnNavigatedTo/From), and look at patterns for structuring larger MAUI apps so navigation stays maintainable as the app grows. You'll walk away with practical patterns you can apply directly to your own MAUI apps, and a clear sense of when Prism is the right tool for the job.
Testing Agentic AI in .NET: skUnit for IChatClient, Agents, and MCP
Modern agentic AI systems rely on many moving parts, from IChatClient pipelines to Microsoft Agent Framework agents to MCP servers that expose external tools and capabilities. As these components interact, the need for reliable, deterministic testing becomes critical.
You need to ensure:
- Agents reason correctly and follow their execution loop
- Tools are discovered and invoked with the right parameters
- Responses stay semantically accurate across iterations
- Multi‑agent and multi‑server orchestration behaves predictably
This is exactly where skUnit excels, a robust .NET testing framework purpose‑built for agentic AI units, including IChatClient, Microsoft Agent Framework agents, and MCP integrations. Whether you're validating a single agent’s reasoning step or end‑to‑end orchestration across multiple tool surfaces, skUnit gives you production‑grade confidence in your AI systems.
The AI Workforce: How Microsoft Agent Framework is Changing the Game
Microsoft Agent Framework is Microsoft’s cutting-edge platform for building intelligent, autonomous, and collaborative AI agents. It enables developers to create agents that can reason, communicate, and integrate seamlessly with enterprise systems. In this session, we’ll explore its architecture, key features, real-world applications, and how you can start building your own AI-powered solutions today.
The Hidden Cost of AI: Infrastructure, Trust, and Governance in Emerging Markets
Title: Beyond the Model: The Infrastructure and Governance Challenges Shaping Africa's AI Future
Artificial intelligence has become one of the most transformative technologies of our time, yet much of the conversation remains focused on models, benchmarks, and the race toward increasingly powerful systems. Behind every successful AI deployment lies a less visible reality: infrastructure and governance.
As organizations across Africa rush to adopt AI, they face challenges that are fundamentally different from those encountered in more mature technology markets. Energy constraints, GPU scarcity, connectivity limitations, cloud dependence, data sovereignty requirements, and regulatory obligations all influence whether an AI solution succeeds, scales, or ultimately fails.
This session explores the often-overlooked foundations of trustworthy AI systems. Drawing on perspectives from software engineering, infrastructure strategy, and legal governance, attendees will examine the hidden costs of AI beyond model training and prompt engineering. The discussion will cover the practical realities of deploying AI in emerging markets, including infrastructure resilience, latency, operational costs, privacy protection, accountability, and compliance with evolving regulatory frameworks such as POPIA and global AI governance standards.
The session will demonstrate why infrastructure decisions directly impact trust, security, compliance, and long-term sustainability. Participants will learn how architectural choices influence data ownership, auditability, explainability, and operational risk, and why governance cannot be treated as an afterthought once systems are already in production.
Attendees will be introduced to a practical framework built around three core principles: Infrastructure by Design, Compliance by Design, and Trust by Design. Through real-world examples and emerging African use cases, the session will illustrate how organizations can build AI systems that are not only technically capable, but also resilient, transparent, legally defensible, and aligned with the realities of emerging markets.
As Africa continues to define its role in the global AI ecosystem, the opportunity extends beyond adopting existing technologies. It includes building systems that reflect local needs, support digital sovereignty, strengthen public trust, and create sustainable foundations for innovation.
This session challenges the assumption that better models alone will solve tomorrow's problems. Instead, it argues that the future of AI will be determined by the infrastructure beneath it and the governance surrounding it.
The Rise of Intelligent Data Applications: .NET Meets Microsoft Fabric
In this session, we'll explore how .NET developers can build intelligent data applications using .NET, Foundry, and Microsoft Fabric. You'll learn how to connect applications with business knowledge, leverage Fabric as an intelligence platform, and build agent-powered experiences that transform raw data into actionable decisions.