Predavanja

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.

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.

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.

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.

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

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.

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

AI agents are moving beyond generating answers, they can now reason, use tools, interact with enterprise systems, and execute multi-step workflows.
But moving from an impressive demo to a dependable production system introduces a very different set of challenges.
This session explores what happens when AI agents move from demos into real-world use, looking at practical examples, what works, where things can go wrong, and what organisations learn along the way.
We’ll explore where agents can create real value, what level of autonomy makes sense, and how to build systems that can be trusted.
Because building an agent is one thing; knowing when to use one is another.
Attendees will leave with practical lessons for thinking about, building, and using agentic AI in the real world.

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.

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

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!

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.

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.

Building an app is now ridiculously fast. Getting someone to actually use it hasn't sped up nearly as much.
Using Cjenici.parra.hr, we walk through the whole path: the need, the prompt, actually building it and all the unexpected legal, marketing and support steps that it took to get to the real users in only one week.

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.

AI agents promise autonomous workflows, but production systems often have an expensive problem hiding beneath the surface: the same task can trigger redundant LLM calls, repeated reasoning, and inconsistent execution.

As agentic workflows scale, this is not just a performance problem. It directly affects cost, latency, reliability, and predictability.

This talk introduces idempotent AI agents and our patented i-Check framework, a practical approach for making agent behaviour more consistent while reducing unnecessary LLM computation. Check out our white paper (https://drive.google.com/file/d/1tnIqY8k9EETBYnK8ovPjSDVC24FItgC2/view?usp=sharing) and open-source implementation (https://github.com/knowledge-verse-ai/I-Check) for those who want to dive deeper into our innovation.

Across 1,000+ real enterprise workflows, i-Check achieved over 90% response stability, 40% token savings, and 37% cost reductions. The approach can reduce LLM costs by up to 50% in suitable workflows by identifying repeatable work and avoiding unnecessary regeneration. We will explain how agent idempotency works and how it can be added to existing agentic pipelines without rebuilding the underlying architecture.

The session includes a live demonstration, showing i-Check integrated into an existing workflow using our Python library. Attendees will see how a previously executed request can be recognized and handled without repeating unnecessary LLM computation. We will apply the idea to practical scenarios including RAG pipelines, customer-support agents, coding agents, tool-calling workflows, and multi-agent systems. For example, a customer-support agent can avoid regenerating an equivalent response, while a multi-agent workflow can prevent downstream agents from repeatedly performing identical reasoning or tool calls.

Key takeaways

- Learn how idempotency can be applied to AI agents and autonomous workflows.
- Understand how to reduce unnecessary LLM execution and achieve up to 50% token-cost savings.
- See results from 1,000+ enterprise workflows, including 90%+ response stability, 40% token savings, and 37% cost reduction across RAG, tool calling, coding agents, and multi-agent systems

Generative AI, when approached with understanding and skill, can act as the ultimate personal tutor. It can help us uncover insights, solve problems, and expand our intellectual horizons.
This is in brief motto and recommendation of last year’s session. However, as we all are occupied with our jobs, ever increasing pace and volume of our requested deliveries, we simply have no time to reskill. This is my learning over last year, but also there are some new imminent threats appearing imperceptibly.
Deskilling and never-skilling, making our professionals credentials hollow, and us not being capable to acquire new, sometimes crucial skills. These phenomena are not universal, they appear in specific area of our professional life, and main problem is that they are invisible, until the harm is done. Thus, affecting our reputation and career.
But working with, not against Gen AI, you can mitigate them, learning and applying some quite simple steps, techniques consolidated under Hold. Rethink. Continue. principle.

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.

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.

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.

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.

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.

Session donosi potpuno novi pristup aktualnoj temi o 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. Predlaže se kao mogućnost panel sa web developerom koji ima iskustva u primjeni anti-scrapping mjera na stranicama i da li je ovo kraj poruke " Ovo web-mjesto upotrebljava sigurnosnu uslugu u svrhu zaštite protiv zlonamjernih botova. Ova se stranica prikazuje dok web-mjesto provjerava niste li bot."

Predavač: Anamarija Jengić Bujan, Intellectual property specialist

AI agents that answer questions are becoming increasingly common. The next challenge is enabling them to interact with the systems and processes behind those answers.

Once an agent can trigger a workflow, update a record, call a business API, or interact with enterprise applications, the architecture changes significantly. Identity, permissions, tool access, governance, auditability, and failure handling become just as important as the agent itself.

In this session, we'll explore how the Model Context Protocol (MCP) provides a standardized interface between AI agents and enterprise tools and services, and how it complements Microsoft Foundry and Microsoft Fabric in modern enterprise AI architectures.

Through practical scenarios and architecture patterns, we'll examine how agents can combine trusted enterprise data, business context, and external tools to move from information retrieval to business actions. We'll also explore the boundaries between agents, tools, business systems, and data platforms, and discuss the controls that become necessary when AI systems are allowed to act on behalf of users.

Rather than focusing on another agent demo, this session focuses on the architectural realities of deploying action-oriented agents in enterprise environments. We'll cover authentication, authorization, governance, human approval patterns, tool access controls, and failure handling strategies that help organizations maintain control while enabling powerful AI-driven experiences.

Whether you're building AI agents today or designing the next generation of enterprise AI solutions, you'll leave with practical patterns for connecting agents to enterprise systems while keeping control over what they can access, what they can do, and how their actions are governed.

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!

AI agents are becoming increasingly autonomous, but autonomy without self-awareness creates a dangerous failure mode: an agent can confidently answer, retrieve, execute code, or call a tool even when it does not have enough knowledge to do so reliably.

For agentic AI, accuracy alone is not enough. A trustworthy system needs to recognize its own boundaries and decide when to answer, retrieve more information, ask for verification, delegate, or stop.

This talk introduces KnowRL (https://arxiv.org/abs/2510.11407), a lightweight framework for improving LLM self-knowledge using internal feedback and consensus, without external supervision or expensive human-labelled datasets. In experiments with LLaMA-3.1-8B and Qwen-2.5-7B, KnowRL achieved up to 28% higher accuracy and 12% higher F1 for self-knowledge, using minimal data and no human feedback.

We will explain how the approach works and, more importantly, how this capability can be integrated into practical AI architectures. We will also discuss the implications for AI governance and responsible deployment. A model that can better recognize its limitations provides an additional signal for escalation, observability, and human oversight.

For RAG, a model can recognize when its internal knowledge is insufficient and trigger additional retrieval instead of generating an unsupported answer. A coding agent can identify uncertain tasks and request verification before executing a solution. A tool-using agent can distinguish between situations where it has enough confidence to act and those where additional information is required. In multi-agent systems, self-knowledge can help determine when an agent should delegate rather than confidently continue.

Key takeaways
- Understand why self-knowledge is critical for trustworthy agentic AI.
- See how KnowRL uses internal feedback without external supervision or human labelling for up to 28% higher accuracy and 12% higher F1 in self-knowledge.
- Learn practical applications across RAG, coding agents, tool calling, and multi-agent workflows and see how self-awareness can support AI governance, escalation, reliability, and human oversight.

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.

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.

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.

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.

Can an application be both a monolith and microservices at the same time? Spoiler alert: yes!

In this session, we will explore a TypeScript codebase that challenges traditional boundaries. Much like Schrödinger's famous thought experiment, the application exists in multiple states simultaneously during development, but its true form is only revealed at the moment of deployment. We’ll uncover tools that empower developers to seamlessly transition between monoliths and microservices, embracing the fluidity of modern development.

Whether you're a seasoned developer, a curious architect, or simply excited about real software agility, this session is for you!

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.

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.

AI can write the code. It can't sit in the meeting.

Last summer I got a client with a hacked website, a hundred unpublished videos on a hard drive, and a habit of answering email three weeks late. She runs a small health-education practice from a paper notebook, and she told me she feels sick every time she has to be "the admin". Six weeks later she had a production learning platform (.NET 10, Angular SSR, Azure), launched on time, on a fixed budget, running for about 70 euros a month. Writing the code, with a team of AI agents doing most of the typing, turned out to be the easy part.

In this talk I'll show the agentic workflow that got us there. Every conversation is recorded, and an agent turns the transcript into facts about how the client really works, marking how sure it is about each one. Then I correct what it got wrong, because it never met her, and my corrections always win. She never gets questions she can't answer, only prototypes she can say yes or no to. Every decision is written down, so nobody (human or agent) argues it twice.

You'll see the workflow live on a synthetic client, including the moment the human has to step in, and the real decisions it produced: no booking calendar, card payments approved for time rather than money, a WhatsApp link instead of an API integration, and an admin panel with three buttons. You'll leave knowing how to turn a business conversation into a spec that AI can actually build from.

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

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?

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.

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!