Session schedule

An agent built only on a language model knows general things, but it doesn't know your domain context. It doesn't know to master your business. AI Tools let models execute actions and integrate the data, but they don't tell it when or how to act. This keynote demo closes that gap with Agent Skills in Microsoft Agent Framework.

Working live in C#/.NET, we start with a simple agent written in a few lines of code. Next, we explain how skills work and build several of them. Finally, you will learn how to build a harness that runs three agents side by side: together they turn a complex intent into a plan and the plan into tasks, then complete those tasks by orchestrating tools and skills.

We have been hearing about artificial intelligence for a while now. The advantages of AI, new technologies, way to utilise them… But it usually starts going in a different direction: Can something go wrong with AI? A very interesting question that always veers into the scenario from a certain cheesy 1984. SF movie starring Arnold Schwarzenegger.
No, ChatGPT will not destroy the world because we made it fix our ugly React code, but there are many scenarios where irresponsible use of AI can lead to unforeseen consequences. You may have already experienced some of them without even knowing.
This talk intends to educate the audience on a different way to talk about AI and its potential dangers. We will go over some lesser-known, but still very interesting AI scenarios and thought experiments and see what kind of future and (potential) dangers of AI they predict, how to recognise these dangers in our own products, see real-life examples of misuse of AI in software development and, most importantly, how to prevent the worst from happening.

Walk into any Microsoft customer right now and ask them which agent technology they are using. The answer will be a confident "Copilot." But hidden in the closet there is a whole bench of underused talent.

Copilot Studio, Power Automate, Azure AI Foundry and three more agent platforms all live under the same Copilot umbrella, and most of them never get sent on a mission.

The result is that one tool ends up doing every job it was never designed for, while five others sit on the shelf gathering licence fees. Teams build a low-code agent for something that needed a real orchestration framework. They spin up custom code for something that out-of-the-box Dynamics 365 already does.

This session is the field guide for picking the right agent for the right mission. We walk through the six agent technologies in the Microsoft stack, what each one is actually built to do, and the kind of job each one fails at when used in the wrong place.

The point is not to pick a winner. Every mission needs a different operative, and most failed AI projects in the Microsoft ecosystem fail because someone sent in the agent they liked, not the one the mission called for.

You leave with a clear decision framework for which agent to send on the next mission and the knowledge to push back on a vendor pitch that promises one tool can do all six jobs.

With 93% AI adoption, a productivity paradox has emerged: 80% of developers feel more productive, yet systemic performance often suffers from a verification tax where time saved writing is re-spent auditing.
Since coding represents only 16% of a developer's day, real gains lie in the "outer loop" of planning and documentation.
We address the empathy gap between leadership and practitioners, noting that productivity requires joy.
Attendees will learn to transition from "authors" to orchestrators, prioritizing flow state and user-centricity to ensure AI serves as a creative amplifier rather than a generator of cognitive debt.

The most dangerous answer I ever got didn't come from an LLM — it came from a doctor. Confident, fluent, completely wrong. I lived the cost of that answer for ten years. Then I watched LLMs make the same mistake at scale, and realized: we didn't invent hallucination, we just named it.
Every mature cybersecurity product has an "unknown" verdict, but LLMs has exactly one verdict: answer. This talk is the story of building the alternative — a live production AI for women's health, in Hebrew, that refuses to answer without evidence; a feature every dashboard says is failing, and every user says is why they trust it. My doctor's certainty was meant as a kindness. It cost me ten years. So I built a machine whose kindness is honesty.

Što ako bi doći do poslovnih podataka bilo jednostavno kao postaviti pitanje? Bez pisanja SQL upita, bez ručne pretrage dokumenata i bez čekanja na izvještaj. Pitate, a podaci odgovaraju.
Organizacije danas raspolažu golemim količinama podataka, ali put od sirovih podataka do korisne informacije i dalje je dug i spor. Veliki jezični modeli (LLM) i AI agenti mogu to promijeniti: pristup podacima može postati jednostavniji, prirodniji i dostupan znatno širem krugu ljudi nego što je to danas slučaj u većini organizacija.
U predavanju ćemo predstaviti tehnologije koje omogućuju razgovor s poslovnim podacima. Krenut ćemo od pristupa Retrieval-Augmented Generation (RAG) za rad s dokumentima, nastaviti s Text-to-SQL rješenjima i semantičkim slojevima za strukturirane podatke, a završiti s AI agentima koji samostalno planiraju i izvršavaju složene analitičke zadatke. Na praktičnim primjerima pokazat ćemo kako se ti pristupi mogu spojiti u hibridno rješenje koje u jedinstvenom sučelju objedinjuje različite izvore podataka.
No što se događa kad svatko može pitati gotovo bilo što? Posebnu pozornost posvetit ćemo sigurnosti, kontroli pristupa, zaštiti osjetljivih podataka i pouzdanosti generiranih odgovora. Cilj nije samo natjerati podatke da progovore, nego i osigurati da pritom govore točno, sigurno i u skladu s poslovnim pravilima.

Extending core enterprise systems without creating fragile monoliths requires modern, side-by-side architectures. Building on SAP Business Technology Platform (BTP) using Java microservices provides the scalability enterprise apps need, but integrating LLM capabilities and AI coding assistants changes the development game entirely.

In this practical, live-demo-driven session, I will walk through building secure, enterprise-grade Java microservices on SAP BTP using the Cloud Application Programming (CAP) model and Spring Boot. We will examine how AI co-pilots streamline boilerplate generation, API consumption, and unit testing, while showcasing how to safely expose enterprise data to modern AI models without compromising governance or security.

Being an Offensive Security Engineer is an interesting job. You have clients who understand the meaning of a time-restricted assessment and whitelist everything for you. You have others that don't really know what they want, just expect results, but won't actually make it easy for you, so you have to fight your way through their defenses. And then, there is the holy grail of clients...the one that on a beautiful Monday morning will send you an email and request an adversary simulation using malware, and in specific, a Wiper!

Challenge Accepted!...I hear you say, and so did my team. As a result, we researched it to the bone. Not only the instance we were gonna execute, but also the whole story behind Wipers. When was the first appearance of this kind of malware? How did it evolve through the years? What mechanisms or tactics do adversaries use to deliver it to the victims? Why did it resurface in recent years? And most importantly....did we delete all the client's data?

These questions and many more will be answered in this talk. In this session, I'll present the evolution of the "Wiper" malware family through the lense of an offensive security engagement. Furthermore, I'll explain in depth the technical aspect, analyzing their functionality and you will witness how this malware can be integrated in offensive operations. Finally, we'll explore the way Wipers are used today, the role they play in hybrid warfare, and what the future holds for malware in general.

In this session, we’ll explore how to architect Android applications that combine on-device intelligence with powerful serverless backends to deliver smarter, more efficient user experiences.

Using Firebase AI Logic and the Gemini Developer API, we’ll demonstrate how to integrate generative and multimodal models without managing infrastructure. You’ll learn how to connect, configure, and interact with AI services, implement hybrid on-device and cloud inference, and handle real-world challenges like latency, privacy, and cost.

Through practical examples, we’ll show how to build mobile apps that reason, adapt, and scale from edge inference to serverless orchestration.

Many organizations nowadays invest in data and AI while overlooking the human side of it all. The result: users end up like Alice in Wonderland, dropped into an unfamiliar world full of possibility, with no idea which way to go. We design experiences that feel powerful in demos but confusing in real life.

In this session, we'll explore how decades of Human Computer Interaction research can help us design better AI agents in Copilot Studio. We'll draw on principles like the Blank Canvas Paradox, cognitive load, and mental models to understand what makes an interaction feel effortless rather than exhausting.

Using Microsoft's Human AI Experience (HAX) guidelines as a foundation, we'll translate psychological UX principles into practical Copilot Studio design patterns that can be applied immediately. You'll walk away with a practical toolkit for designing agents in Copilot Studio that are user friendly and effective.

Whether you're a maker, consultant, designer, or architect, this session will give you a practical framework for designing Copilot Studio agents people actually understand how to use. Let's give Alice some directions.

Low-code doesn’t have to mean moving your entire application onto a low-code platform.

A different approach is to bring low-code principles into the application itself: identify the parts of a system that benefit from frequent change, make that logic configurable through a UI, and execute it dynamically at runtime while keeping the surrounding architecture, codebase, and deployment model under your control.

This session explores how to design systems where users can define rules, calculations, and other application logic without requiring every change to go through a development and release cycle. We’ll look at the architectural ideas behind visual logic builders, representing logic as data, runtime interpretation, and exposing configurable behavior through APIs.

We’ll also explore where AI fits into this model. Instead of relying on users to manually construct increasingly complex logic, AI can translate natural-language intent into structured expressions while taking the wider application context into account.

The result is a practical middle ground between traditional hard-coded applications and full low-code platforms: systems that remain owned and engineered by development teams, while giving users far more control over how they behave.

AI applications introduce new security risks, from prompt injection and malicious content to abuse, excessive resource consumption, and changes to the underlying cloud environment. In this session, we’ll explore how to start protecting AI applications built with Azure OpenAI in Microsoft Foundry by using Azure-native telemetry and Microsoft Sentinel.

Through practical demos, we’ll bring together Foundry Prompt Shields, application telemetry, Azure OpenAI diagnostics, and Azure Activity data to detect prompt attacks, identify repeated malicious behavior, monitor unusual AI usage, create Sentinel analytics rules, and investigate activity across the application and Azure control plane.

We’ll also briefly discuss how this approach can be extended with the broader Microsoft Security stack, including services such as Microsoft Defender for Cloud, Defender XDR, and Microsoft Purview, for organizations that want more integrated posture management, threat protection, investigation, and governance.

The goal is to provide a practical entry point into AI application security and understand what can already be done with Microsoft Sentinel and Azure-native telemetry, then see how the wider Microsoft Security ecosystem can build on that foundation.

We will walk through a case using an AWS Cognito-based authentication system implemented for MG Motors, a UK-based car manufacturer.

We will showcase a setup using Cognito User Pool groups and resource servers to provide a highly secure authentication setup that covers both human users, by implementing cross-environment Single Sign-On, and external integrators and MCP/Agentic access to query and interact with data, using granular access scoped to tenants in 30+ markets across Europe.

AI now writes an application that works. The code passes its tests and can go to production.

The problem is that we have spent years talking about software mostly through code. Projects rarely fail on code. They fail because nobody understood the process, the rules and the exceptions, or because people never actually used it.

The talk walks through what sits between "works on my machine" and a system somebody actually uses: the domain and the people, business rules and exceptions, non-functional requirements, data migration, rollout and change management. Three examples from practice, invoice approval as the process everyone knows, and sixty years of programming history where the same pattern keeps repeating.

The second half is about why the domain stays with us. If you don't know the field, you can't write a good prompt or judge the answer you get back. That holds for any profession, not just software.

For engineers, managers, and anyone who commissions or delivers business software.

AI agenti više ne samo odgovaraju na pitanja, sada i djeluju: izdaju račune, čitaju knjige, šalju podatke dalje. Model Context Protocol (MCP) omogućava da ih spojimo na vlastiti sustav. Ali… Jesmo li se zapitali što bi se dogodilo kada bi agent dobio pristup financijskim podacima tisuća tvrtki? Tko je zapravo autenticiran, korisnik ili agent? Kako agentu dati pristup samo jednoj tvrtki, kada isti korisnik radi za njih deset? I što ako agent odluči fiskalizirati račun koji se više ne može povući? Kroz stvarni primjer MCP servera za Parra platformu proći ćemo OAuth autorizaciju za MCP, multi-tenant model ovlasti, dizajn alata koji razlikuje sigurne od nepovratnih akcija. Dođite na ovo predavanje i saznajte kako AI agenta pustiti u produkciju, a da ne izgubite san. Vidimo se!

This session demonstrates how to build a fully observable .NET Blazor application using OpenTelemetry instrumentation provided by .NET Aspire, combined with Grafana Cloud for centralized metrics, logs, and traces. In this session I will demonstrate how to configure Aspire’s OTLP pipeline, stream telemetry into Grafana Cloud, and consume Prometheus‑compatible APIs to display real‑time operational insights directly inside the Blazor UI. The session covers practical architecture patterns, multi‑tenant data handling, and production‑ready techniques for integrating cloud observability into modern .NET applications.

In this talk, we’ll explore how to run machine learning models directly on Android devices using lightweight runtimes and optimized architectures.

You’ll learn how to prepare and load models, run inference efficiently, and integrate with tools like MediaPipe for real-time computer vision and natural language experiences. We’ll look at how to optimize models for size and performance, chain multiple models together, and handle input and output tensors on-device.

Through practical code examples and lessons learned from real projects, you’ll see how on-device AI enables faster responses, offline capabilities, and stronger privacy while keeping your app lightweight and responsive.

Napraviti aplikaciju danas je suludo brzo. Doći do nekoga tko će je stvarno koristiti i dalje nije.

Na primjeru Cjenici.parra.hr prolazimo cijeli put: potrebu, prompt, samu izradu i sve neočekivane pravne, marketinške i korake podrške koji su bili potrebni da u samo tjedan dana dođemo do stvarnih korisnika.

AI can now write code, docs and reviews, and the line between engineers and designers is fading. We're all builders now. What still sets people apart is judgment, taste and product sense.

My talk covers five practices engineers can start making today: question first, remember you're not the user, treat information architecture as a deal breaker, understand the context, and say no to decorative elements, to build a better product. Each comes with a real product story, plus tools to put it into practice.

An agent that does the job for you and frees your time — that is the promise. This session is about the moment before you accept it.

For decades, IT professionals have decided whether to trust a system in the same way: a proof of concept, testing, bug fixes, an approved version. The method works because software is predictable. The same input gives the same output, a proof of concept generalizes to similar cases, and a bug once found stays fixed. Equipment works as advertised; what fails is a bug, not a probability.

Agents break these assumptions. Their capability is jagged — excellent on one task, unexpectedly wrong on a similar one. They can pass a test without doing the job. Their errors often look right. And what you adopt is not just a model but the model plus everything built around it — and any part of that can change without you noticing. The familiar question — can we check the outcome? — is no longer enough. It becomes: how will we find out whether the agent is reliable for this job — in what time, at what cost, and with what precision?

The session gives no verdicts on tools or vendors. In the spirit of my last year's lecture, Reskilling for GenAI, this one puts Socratic questioning at the start: the criteria to put first to yourself, and then to whoever proposes an agentic solution.

Hold — stop the hype, and ask whether this is a task for an agent at all.
Rethink — the new criteria for reliability, and where they come from.
Continue — what to ask of vendors, and why trust has to be renewed task by task.

More and more companies want AI agents, but they can't send sensitive data to public cloud APIs. That leaves one option: running agents locally, on their own infrastructure, over their own data. This is where most projects get stuck. The model is the easy part. The hard part is everything around it.

This session covers what it really takes to run AI agents in-house. On the infrastructure side: GPU sizing, serving open-weight models on Kubernetes, and the trade-offs between model size, latency and cost. On the data side: data that agents can actually understand, a semantic layer that gives business context, RAG and vector search over internal data, and connecting agents to internal systems through MCP.

We'll also cover a problem that local deployment doesn't solve by itself: security. Agents must act with the user's permissions, not as an admin. That means row-level security, auditing every query, and protecting against prompt injection hidden inside company data.

Through a live demo, we'll take a naive local agent that leaks data and gives wrong answers, and turn it step by step into a secure, production-ready setup. Attendees leave with a practical checklist for making their data and infrastructure agent-ready.

The Active Directory tiering model is designed to protect privileged identities and reduce the risk of lateral movement—but real-world administration often introduces challenges that aren't covered in the documentation.

In this session, we'll walk through practical scenarios that administrators encounter when managing Microsoft Failover Clusters while maintaining a secure tiering model. You'll learn how to perform day-to-day cluster management without violating administrative boundaries, how to recover and repair a failover cluster without breaking tiering, and which common operational practices can unintentionally weaken your security posture.

Through real-world examples, we'll explore common pitfalls, explain why they happen, and demonstrate practical solutions that allow you to keep both your infrastructure highly available and your privileged access model intact. Whether you're responsible for Active Directory, Windows Server, or clustered workloads, you'll leave with actionable guidance that can be applied immediately in your environment.

Agent 365 isn’t just another AI announcement — it’s Microsoft’s vision for how companies will manage an entire workforce of AI agents. Fresh out of preview and now generally available, Agent 365 introduces a new “control plane” for AI inside Microsoft 365, giving organizations the ability to discover, govern, secure, and scale autonomous agents across Teams, Outlook, SharePoint, Windows, and even third-party platforms.

In this session, we’ll unpack why Microsoft believes the future of work will involve billions of AI agents acting as digital teammates — and why governance, security, and visibility suddenly matter more than ever. From “shadow AI” running on employee devices to intelligent agents capable of taking action across enterprise systems, Agent 365 is redefining how organizations think about productivity, automation, and trust. Expect real-world scenarios, launch insights, and a practical look at what happens when AI moves beyond copilots and becomes part of the operational fabric of the workplace.

CI pipelines are among the most privileged and least watched identities in a cloud account. This talk walks through replacing stored access keys with GitHub OIDC federation, then tightening in three layers:

Who can assume the role. Pin the trust to an exact repo, branch, environment, and workflow, keyed on immutable repo IDs rather than names.

What the role can do. CI only starts an orchestrator and writes build artefacts under one storage prefix. It never runs containers or passes roles directly.

Guardrails. Add explicit denies and immutable artefacts.

Session donosi potpuno novi pristup aktualnoj temi o baznim (ex sidrenim) cijenama i digitalnim cjenicima, sada s osvrtom na TDM (Opt-out) iznimku i da li Odluka Vlade RH o obaveznoj objavi digitalnim cjenika u strojno čitljivoj formi onemogućava i u kojem dijelu poduzetnike od korištenja te iznimke. Uz to daje se pregled dosadašnjih rješenja trgovaca koji tu obvezu imaju od 02.05.2025., kao i sažetak najvećih dvojbi glede obvezi koje čekaju trgovce, uz preporuke za pripremu prije stupanja na snagu pravilnika ministarstva gospodarstva, te otvaranje rasprave sa sudionicima glede onog što čeka svih koji bazne cijene i digitalne cjenike moraju implementirati na svojim stranicama ili za svoje klijente.

Join us for a hands-on exploration of modern observability with OpenTelemetry and .NET. We'll start from the basics and dive into real-world scenarios to show how to instrument your applications for distributed tracing, metrics, and logging.

Through live demos and concrete examples built with .NET, you'll learn how to gain deep insights into your system's behavior, troubleshoot issues effectively, and understand the true power of observability when applied in practice. We’ll use tools like .NET Aspire dashboard to visualize and analyze telemetry data, turning raw signals into meaningful answers.

Join this session to learn how to properly manage and secure Microsoft’s Identity as a Service, whether your organization uses it in a hybrid setup with Active Directory or as a cloud-only solution.

Learn from Tomislav's experience with many large organizations managing Entra, as he optimized the platform in terms of authentication methods, guest, application and agent access, synchronization, and password expiration and resets.

This is a must attend session for Entra admins!

Mnoge organizacije pokreću AI pilot projekte, no nekolicina ih je te projekte uspjelo pretvoriti u značajnu poslovnu vrijednost. Različita javno dostupna istraživanja upućuju na iste uzroke: nedovoljno spremne podatke, slabo upravljanje tim istim podacima i metapodacima te nejasno definirani poslovni ciljevi.
Ovo izlaganje praktičan je slijed koraka za pripremu data platforme za AI temeljen na javno dostupnim istraživanjima, industrijskim standardima i objavljenim testiranjima, a ne na pretpostavkama. Cijeli slijed počinje definiranjem ciljeva i poslovne vrijednosti, kriterija uspjeha, a zatim prelazi na pripremu podataka, uspostavu pouzdanih metrika, korištenje aktivnih metapodataka i jasno određivanje vlasništva i odgovornosti nad podacima.
Obuhvaća i zaštitu AI agenata i načelo minimalnih ovlasti kao bitne točke pristupa produkcijskim podacima, te uzimajući u obzir različite troškove od samog početka.

It seems like AI agents and Skynet will soon run everything. That sounds great, but before we let them take over, shouldn’t we make sure the data center they rely on actually stays up?

Two ISPs, independent fiber routes, backup generators, redundant cooling systems, redundant controllers, clustered servers, software and databases. On paper, we’re practically invincible.

That is, until someone with an excavator finds out both 'independent' fiber routes are buried in the same trench.

Welcome to high availability in the real world.

In this session, we’ll look at what it really takes to keep a 200 MW data center campus running when things go wrong. We’ll start at the property line and see how telecom providers, electrical systems, cooling, automation, networking, and software all work together to keep everything running.

Along the way, we’ll break a few things. A fiber route gets cut. A cooling system loses capacity. A network partition leaves healthy servers arguing over who should be running what. An application fails over beautifully, only to discover its database didn’t. And naturally, the management system we need to fix everything decides to join the outage.

We’ll look at the hidden connections between systems that are supposed to be independent, from physical infrastructure to software clusters, quorum, and application-level failover. We’ll see why adding redundancy doesn’t always make things safer, and how automatic recovery can sometimes make things worse.

The real question isn’t whether you have a backup. It’s whether you know what could take out both.
So come help John Connor with a rather unusual mission: keeping Skynet online for a change.

Prije desetak godina uveli ste API gateway jer su se API-ji namnožili i trebalo je znati tko ih poziva, kako ih zaštititi i kako ih pratiti. S AI sustavima priča se ponavlja, ali s novim pravilima. Potrošnja se mjeri u tokenima, isti prompt ne daje isti odgovor, napad stiže kroz sam sadržaj, a API sve češće ne poziva korisnik nego agent. Kako postaviti token limit i chargeback po timu? Kako iskoristiti semantic caching kad odgovor nikad nije isti? Kako zaustaviti prompt injection prije nego stigne do modela? Što kad PTU deployment ostane bez kapaciteta? I kako agentu dati pristup MCP serveru bez dijeljenja ključeva? Pokazat ćemo kako je Azure API Management postao AI gateway za modele, MCP servere i agente, na primjeru platforme s više timova, modela i regija.

Traditional computer vision models are great at answering one question: “Is something wrong with this image?” But detecting an anomaly is only the beginning of an operational process.

In this session, we will explore an end-to-end architecture that combines Azure Machine Learning, specialized computer vision models such as YOLO and PatchCore, multimodal LLMs, and AI agents built with Microsoft Foundry.

A vision model first detects or scores potential anomalies in images. Instead of sending raw detections directly to operators, a multimodal model analyzes the flagged image together with the detection results, describes what happened, adds operational context, and produces structured information that another AI agent can act upon. The operational agent then decides how to handle the case using available tools and workflows, while a separate supervisory model monitors and evaluates its actions.

We will discuss the architecture, responsibilities of each model, information flow between deterministic ML and generative AI components, and why combining specialized models with multimodal LLMs and supervised agents can be more effective than trying to solve the entire problem with a single model.

Agentic AI doesn't fail like traditional software. It fails by doing exactly what it was told — badly, autonomously, and often in ways nobody anticipated. Agents have broken containment, attacked adjacent systems, and fabricated data with full confidence. These aren't hypotheticals; they're happening now, in production.
Most organizations rushing agentic AI into their workflows have no framework for what "secure" even means in this context — and no way to prove it to a regulator, an auditor, or their own board. Traditional AppSec doesn't cover autonomous decision-making. Traditional AI governance doesn't cover systems that act, not just predict. And traditional compliance checklists don't map cleanly onto agents that behave differently every run.
This talk breaks down:
Real-world agentic AI failure modes — containment breaks, cascading actions, data fabrication — and why they're structurally different from classic security incidents
Why regulatory frameworks (EU AI Act, OWASP Agentic Top 10, NIST AI RMF, ISO 42001) are converging on agentic systems specifically, and what compliance actually requires for autonomous systems versus static models
A practical Discover → Secure → Assure model that builds compliance checks in as a recurring assessment, not a one-time audit — grounded in work securing production AI systems at enterprise scale (50+ AI systems, 100+ repos assessed)
You'll leave with a mental model for where agentic AI security actually breaks, and a starting framework — including the compliance checkpoints — for assessing your own exposure.

AI coding assistants and autonomous agents produce changes faster than teams can inspect every line. The bottleneck is no longer writing code; it's reviewing it. How do we verify behavior and release safely at AI speed? How do you stay accountable when nobody can read every line that ships?

We present one delivery control system consisting of four automated layers: BDD scenarios define behavior, guardrails as code enforce policy, independent agents review every change, and observability with progressive deployment rings tests assumptions against production signals. Each catches a different class of failure and emits evidence, and every escape becomes a new rule. Humans operate above the system, analyze evidence, and act when necessary.

You will leave with a system where humans own intent, exceptions, and release decisions. Review can be automated. Accountability cannot.

Building intelligent applications is exciting, but bringing AI into real software is hard. Production-grade solutions need far more than prompt-defined agents, low-code tools or data-science prototypes. They need solid architecture, flexible integration and deliberate design.

In this demo-driven session, you’ll learn how to build applications that run multiple agents side by side and plug into any kind of application, on virtually any platform or operating system. You’ll also see how to extend agents with tools and teach them to solve complex, multi-step tasks.

There are multiple ways to implement RAG (Retrieval-Augmented Generation), a system that connects an LLM to an external knowledge base. But which RAG architecture should we choose for our specific use case? In this talk we'll explore different RAG architectures and compare their strengths and weaknesses. In the traditional RAG approach we use a vector database to store embeddings that were generated from our data. For some scenarios a better option is Graph RAG which uses a knowledge graph to map relationships between entities. We can also choose Agentic RAG, which uses autonomous AI agents. There's also Multi-Agent RAG. And the list of RAG architectures does not stop there.

A vague backlog item is poor input for AI and people. Now that AI assistants work directly with your backlog, requirement quality matters even more.

When backlog work remains manual, or teams use AI in disconnected chats, they miss the value of connected, AI-assisted workflows. We show how reusable Agent Skills for GitHub Copilot and the Azure DevOps MCP Server support governed backlog management: AI proposes and refines; people provide context, review, steer, and approve what reaches the backlog.

In a live demo, we turn a specification into a hierarchical backlog with refined descriptions, test-ready acceptance criteria, all without manual editing. You'll learn how agent skills differ from prompt templates, how MCP connects Copilot to Azure DevOps context, and how approval gates keep people in control.

From pre-production to theatrical rollout, digital workflows make filmmakers prime targets for cybercrime. This session examines the critical defense layers needed to secure the filmmaking process.We will look at combating spear-phishing, introducing phishing-resistant MFA, and enforcing Zero Trust Architecture across production pipelines. We will also examine how the arrival of quantum computing threatens film distribution and what creators and distributors must do to safeguard their intellectual property.

We will talk about FIDO2 and various options for authentication, and then focus on newly released Passkey option with various examples and use cases, including benefits from practical and security point of view, and some limitations of course. How to use it for various systems including Microsoft Entra ID

We wanted to find out whether agentic coding could work beyond demos and small projects, so we gave ourselves one constraint: developers would not write production code manually.

As the system grew, the failures became more interesting than code generation itself. Agents hallucinated, skipped work, duplicated implementations, quietly deferred difficult functionality, and sometimes changed earlier decisions when implementation became inconvenient.

Each failure changed the way we worked. Documentation became part of the development environment. We introduced explicit rules and structured specifications. Eventually, we separated planning, implementation, and verification into distinct agent roles with strict boundaries.

This talk follows how the process emerged while we built and shipped a real production product using coding agents. I’ll walk through the failures we encountered, what we changed because of them, and why our developers ended up spending less time writing code and more time understanding business problems and making architectural decisions.

How do you know where several million items, across a few hundred item types, sit in their lifecycle, when you cannot go and inspect them, and when that lifecycle shifts with both time and external events?
We started where most teams start: one very large table, cron jobs and triggers, then an LLM to keep it up to date. The lesson came early: we first needed a formal description of the item type and of the item itself, and then a lifecycle we could observe and control.
Our first attempt modelled both as state-machine workflows. The lifecycle rules turned out to be a poor fit for AI, and workflows brought their own problems at this data volume. The alternative, running models straight against the big table, was no better.
Digital twins gave us the model we were missing. We moved through several implementations, from fixed lifecycle rules to an AI-driven lifecycle, and now run on Fabric Digital Twins with AI agents driving item lifecycle - a ship-of-Theseus migration where the system keeps running while every part is replaced.
This session is the data and AI view of that journey, with a live demo of what we run today - and a chocolate-sweet finish, as always.
Key takeaways:
Where a “big table plus cron plus LLM” approach breaks, and the signals that tell you before it does
Why rule-based state machines and AI-driven lifecycle prediction pull in opposite directions
How to split responsibilities between the twin model and the agents acting on it

AI agents are already in your tenant. They read mail, query data and call APIs, usually as a service principal with a forgotten secret and nobody accountable for it. When something goes wrong, the first question is simple: who approved that agent? Most organizations can't answer it.

Microsoft Entra Agent ID gives agents what users have had for years: their own identity, a human sponsor, Conditional Access and a lifecycle. In this demo-driven session we publish an agent in Microsoft Foundry and follow it from creation to retirement. We'll see where its identity comes from, block it with a Conditional Access policy built for agents, give it time-limited access through an access package, and make sure it isn't left without an owner when its sponsor leaves the company. And because not every agent lives in Microsoft's cloud, we'll bring an agent running in Google Cloud into Microsoft Agent 365 and see what you can, and can't, control there.

You'll leave with a clear picture of what Agent ID does, which licenses it really needs, and a five-step checklist you can start applying in your own tenant on Monday.

Which one makes you want to puke the most? NIS2-ready, next-gen, AI-powered, zero trust in a box, single pane of glass? And what about the alphabet soup of SIEM, SOAR, XDR, NDR, EDR and DLP, where every vendor promises the one platform to rule them all? Security has more buzzwords than real solutions, and they cost us money, time and focus.

Large language models (LLMs) have changed the way we build software. Writing code is no longer the bottleneck in building a product. AI writes code, tests it, writes automated tests, reviews pull requests, and refactors legacy code. As a result, developers today need a different skill set than they did just two years ago.
Communication, teamwork, and an understanding of users and the domain have never been more important. Through everyday situations from business software development, we'll talk about the importance of engineering fundamentals, understanding code and architecture, and what it even means to be a developer in 2026 and beyond – and whether that role still exists at all. Does this shift demand more knowledge and learning from developers than ever before?

SQL Server 2025 is here! 🚀
Still running an older version of SQL Server and wondering whether it’s really worth upgrading? Let’s take a closer look at what Microsoft has been cooking up in the SQL Server kitchen and explore the new features and enhancements introduced in SQL Server 2025.
This session is packed with practical examples and real-world scenarios, showcasing features that can make a difference for database developers—from new capabilities and improvements to familiar areas that have received a fresh upgrade.
The primary focus will be on database developers, with plenty of demos and examples to help you understand not only what’s new, but also where and when you might want to use it.
And if time allows, we’ll also take a quick trip through some useful features introduced in previous SQL Server versions that may have slipped under your radar.
Come hungry for some SQL Server goodness!

In order to solve very complex tasks, we can use an AI agent swarm, a collection of multiple autonomous AI agents that collaborate, divide tasks, and use collective intelligence to reach their goal. We'll compare this multi-agent pattern to other patterns and find out in which scenarios this pattern is the best choice. There are multiple benefits, including improved resilience and scalability. We'll also discuss their downsides and how best to handle them. There are frameworks for building these kinds of multi-agent systems. In this talk we will look at the real-world applications of AI agent swarm because that is the best way to understand their full potential.