The One Person Company - Disruptive AI Models

In the wake of Large Language Models (LLM) such as ChatGPT and GPT-4, Microsoft fully bets on integrating AI everywhere. But what does it all mean to regular businesses?

This session we will look at the capabilities of large AI models and their integration in our software and business landscape.
We will conduct a thought experiment: Could you replace a whole organization with just one person?
This thought experiment will be underpinned by showing hands-on how many aspects of setting up and running a business can leverage capabilities of large AI models.

Please join us for a demo-heavy glimpse of how large AI models can transform all aspects of running a business.

Let's focus on Embeddings

Embeddings are a semantic representation of content. You hear about them all the time in the context of vector databases for example.
In this session we will focus on embeddings, look deeper why they are important, and what you can do with them.

Through examples we will also explore challenges when working with embeddings and look at strategies to overcome those challenges.

Let's focus on useful AI Agent Interactions

When you are building AI Agentic applications, often you will have more than one agent, and those are supposed to collaborate in some way.
In this session we want to focus on that collaboration, how agents can be set up to work together as a team to get things done.

Part of this conversation includes:
How do you define what an agent should do or shouldn't do?
How can agents relate to human counterparts?
How do you organize or re-organize a team of agents?
How do agents share information?
How do you orchestrate complex agent interactions?

In our approach we will stay hands-on with specific examples and provide some concrete implementations.

Join me to look at defining multi-agent systems.

Microsoft's PyRIT Tool to Red Team Generative AI applications

Recognizing that Generative AI applications have their own types of vulnerabilities, Microsoft created the Python Risk Identification Tool for generative AI (PyRIT).

When you incorporate Generative AI capabilities, you want to minimize your risks, and thus having tools available that can effectively red team your applications is very important.

In this session we are giving a quick overview about what PyRIT can do for you, how you can use it, and see PyRIT in action.

The one person (or less) AI company?

As a thought experiment in this geek out we will ask, could you plan, build, and run a company with AI?

We will talk about different aspects of creating and running a company and match them up with the AI powered building blocks that could reduce human workload dramatically there.

Things they don't tell you about AI vulnerabilities

So you are ready to develop AI applications in .NET?
You absolutely are, but take pause to consider things you may not have thought about.

In the brave new world of Generative AI people talk about "prompt injection" and other Generative AI related vulnerabilities.

This is the session you want to attend to understand some of the current Generative AI risks through different attack vectors and get information about the current mitigation attempts and strategies.

We will cover both immediate attacks as well as strategies where attackers may be playing "the long game".

You will see actionable examples and understand what people can learn about systems through "attack-like" behavior.

Windows Copilot Runtime and friends - Local models the Microsoft way

Besides of running those large models in the cloud, a modern computer can do amazing things in the world of AI given it's hardware is capable enough.
In this session we will look at what Microsoft is cooking up to enable you to develop applications that run on Windows based devices. This includes the Microsoft Copilot Runtime as part of the larger Copilot stack.

Join me to explore running AI locally - the Microsoft way.

Your Prompt Engineering needs Engineering

Overhyped "prompt engineering" without substance is one of the big problems of Generative AI. The term is associated with lists of the "100 BEST PROMPTS" and people are misled that what they are seeing is actually engineering. Unfortunately those prompts are mostly a game of luck as when AI models and model version change, model behavior also can change.

Let's cut through the hyperbole: We need methods and engineering.

In this session we will discuss how you could approach Prompt Engineering with an engineering mindset, how to use a mix of intuition, the power of Generative AI itself, and then leverage tools, testing, and automation to improve your craft.

So, join me to put some "engineering" into "prompt engineering", and maybe, just maybe, Prompt Engineering can become a proper engineering discipline.

Unity3D with IL2CPP - what is it and how does it work?

Unity3D is a popular multi-platform gaming engine increasingly often used to develop enterprise applications and Microsoft's first choice to develop applications for Mixed Reality.
Unity3D's default scripting language is C#, typically edited, debugged, and deployed in Visual Studio.
But Unity3D was built on Mono to support multiple platforms and that mapped to .NET when running on Windows. Today Unity uses IL2CPP (Intermediate Language To C++) for many target platforms, which then compiles to native code for the target device. In this session, the developer user experience, from project creation, code editing, to deployment and debugging will be demonstrated and discussed.

Mixed Reality Workshop - Building AR/VR Applications

In this 1 day workshop, attendees will learn about the various concepts and technologies that comprise Mixed Reality applications.

The typical tool chain to develop applications will be demonstrated and explained. This is a technical workshop and active participation of attendees using their own notebook computers is strongly suggested.

The Metaverse - Beyond the buzzword

The last few months in 2023 saw partial divesting of various large companies, including Microsoft, in the Metaverse field. Hence it is even more important than ever to look beyond the "buzz" and look at what the foundations of Metaverse applications can be.
The buzz started 2021 when Microsoft, then Nvidia and finally Facebook even rebranding itself to "Meta" started using the term "Metaverse", all types of businesses and products suddenly had to do something to do with it.
In this session we will look at common capabilities that are generally understood as contributing to the "Metaverse". But we will look beyond the buzzword and talk about what value those capabilities provide, specifically those that are already part of Microsoft Azure or related to Microsoft Azure.

Our goal is to look at what can you leverage today to build the Metaverse solutions of tomorrow and why does it make sense to do so.

Particularly we will look at aspects of the industrial metaverse and what it has to do with IoT, we will talk about how to interact with and understand physical environments.

To be more specific, you may see appearances of technologies such as Azure IoT, Azure Kinect, Azure Spatial Anchors, Azure Remote Rendering, but also Azure Cognitive Services, and more.

We will talk about some of the challenges of developing Metaverse applications regarding some typically involved toolchains which in many case come from the game development background such as Unity3D and suggest some approaches to get started.

Python: A quickstart for non-Python developers

Python is one of the most popular development languages, and by some measures currently the most popular language for beginners. In Artificial Intelligence and Data Science it is practically impossible to not use Python in one way or the other.
Yet, many Enterprise Developers have not started yet.
This fast focus provides regular developers a quickstart to start using Python.
This is for everybody who has not used Python yet and wants a quick overview on how to get started.

Hackathons - unleashing hidden potential in organizations and empower individuals

Hackathons are a hot topic to drive innovation. Organizations across the globe have discovered that it enables them to help their digital transformation endeavors through unleashing hidden potential within the organization or across an industry.
For individuals, hackathons can help to dive into a new subject matter, empowering to work on subjects they always wanted to work on, and in some cases hackathons have changed career paths.
This session will discuss topics around hackathons:
What different types of hackathons exist? What value do hackathons have for organizations and for participants? How does one best prepare for a hackathon?

Most importantly, hackathons are about culture and in some cases helping to change culture in a positive way. The best hackathons are inclusive and empower people to succeed.

Attendees will learn about the value of hackathons for organizations and individuals, and tips will be shared how to run or participate in a successful hackathon. This session is for everyone who cares about innovation, digital transformation, and how to disrupt and reinvent themselves.

Get started: What, I need to use Python? Help!

Python has rapidly become the most popular software development language measured by online searches. The daily responsibilities of many Web-Developers and Enterprise Developers do not allow diving into this completely new ecosystem as part of their role, yet they are increasingly often expected to know Python. This focused session provides the starting point for software developers to begin working with Python.

Jupyter Notebooks - a quick look for regular developers

Jupyter Notebooks are a popular tool for many professionals and are very prevalent with Python developers and Data Scientists.
But they are actually useful for many more scenarios.

In this session, attendees will see a variety of applications of Jupyter Notebooks to expand their toolbox through quick demos.

Starting with vanilla Python use cases, the session will also introduce Microsoft Azure's flavor of Jupyter Notebooks.
From there demonstrations will branch out into different development languages and use cases, such as connecting to a SQL Server or writing C# code in a Jupyter Notebook.

Intelligent Spatial Applications

The availability of cloud based services such as Microsoft Azure Cognitive Services unlock advanced computer vision capabilities for regular developers. At the same time, with AR/VR and Mixed Reality Devices such as Microsoft HoloLens, a new paradigm has emerged: Spatial Computing.
Here new concepts such as "Spatial Anchors" have been introduced that have on-device and cloud-based tools that let developers contextualize information to fixed locations in space.
In this session attendees will see computer vision capabilities in action and then those tools will be applied to gain a better understanding of a real 3-dimensional space by being able to annotate what a camera has recognized in that space.
Sounds complicated? It is powerful but you will see that the tools are actually straightforward to use.

Introducing Kinect for Azure for Developers

This session introduces Kinect for Azure and provides a quick overview what developers can accomplish with this latest iteration of the popular depth camera.
Through demos and samples code, attendees will receive the necessary information how to start developing applications that leverage Kinect for Azure.

Space is what matters - looking at the core value of Mixed Reality and HoloLens 2

In this session attendees will learn why it is different and valuable to pursue Mixed Reality solutions compared to 2-dimensional apps. Many MR applications display graphics in 3 dimensions in a visually appealing way but stop there. Often this results in a lost opportunity: Interacting in 3D-space enables completely new scenarios that would be impossible with 2D-applications.
The presenter will discuss what insights and value can be gained with spatially aware applications.
Developers will receive the necessary starting points to start building apps, including for HoloLens 2, and decision makers will receive guidance, enabling them to think about solutions differently.

Understanding the Human Body with Depth Cameras

Since the arrival of Microsoft Kinect for the XBOX 360, depth cameras created new possibilities for software developers and researchers to use democratized “skeletal tracking” capabilities to understand the human body. With the announcement of Kinect for Azure, the ecosystem providing intelligence and perception capabilities on the edge is getting richer and it is a good time to understand what developers can do with Skeletal Tracking.
This session will discuss skeletal tracking and introduce some simple math concepts that are helpful to reason on the provided tracking data. Tips and guidance how to build applications that work with skeletal tracking systems will empower developers to get started immediately.
Attendees will learn about specific scenarios like human posture recognition, fall detection, or energy expenditure estimation for sports applications and how those scenarios can be implemented in their own applications.

Successful hackathons: value for organizations and hackers, experiences as organizer or participants

Hackathons are a hot topic in digital transformation to unleash hidden potential in your organization or across your industry. On an individual level, they can also help you to dive into new subject matters, empower you to work on something you always wanted to work on, or even change your career path. What different types of hackathons exist? What value do hackathons have for organizations and for me? How do I prepare for a hackathon?
After organizing, mentoring, and participating in various hackathons, I see it is necessary to share my bigger picture view of hackathons for a larger audience. Often the unanticipated was the most interesting of the participation. I will provide tips for both organizers and participants.

Red-Teaming your own prompts

Generative AI can create wonderful but also horrible things. With it come new types of risks and attack vectors on systems.

In this session the presenter talks about some of his experiences trying to understand risks and limitations by "red-team"ing his own usage.

The presenter will share observations he made as to some of the patterns that he believes can often circumvent prompt- or content filter-based protections.

With plenty of hands-on examples some of the unique properties of Large Language Models will be explored, and the cat-and-mouse game between attackers and defenders will be discussed.

You will also hear about various attack vectors that you may need to defend against when building AI systems based on Large Language Models or even building Large Language Models.

Furthermore you will also get some insights into existing "off-the-shelf" solutions such as various Copilots that can be exposed through Red-Teaming and gain an understanding how your own solutions may be subject to similar attacks.

Agents in the AI race: from Prompts to Swarms

AI Agents have become one of the main focus areas in the industry as we want work to get done, and AI to integrate nicely to contribute to a winning team.

In this session we will look at the concepts of AI agents starting with how to define AI agents with appropriate prompts, to how AI agents can form teams to complete tasks.

In this rapidly evolving domain change is expected regarding the implementation details, but expect to see aspects of Semantic Kernel, Microsoft AutoGen, and Azure Container Apps to be relevant parts to be part of what we will discuss.
Then we cover how this relates to Copilots and Azure OpenAI Assistants, and how to integrate with existing services in your environment.

After this session you should have an understanding of how agents are built that you can apply to your projects and keep winning.

With the license to code: Pushing the limits of Secret GitHub Copilot Coding Agent

GitHub Copilot Coding Agent with GPU acceleration, massive amounts of storage and memory, and reusing work from previous sessions sounds good to you? How about getting hundreds if not thousands of dollars worth of power out of your affordable GitHub Subscription. Then you found the right talk.

There is no escape, Coding Agents are everywhere, and GitHub Copilot Coding Agent stands out in many ways. The cloud-based GitHub offering has its quirks and secrets and understanding those can make the difference between getting "so so results" or unlocking superpowers.

I have been working on pushing the limits of GitHub Copilot Coding Agent since before it came out in public preview.

Starting with how this agent differs from it's peers within the GitHub universe and many competitor's offer, we go quickly into putting it's meat on the grill
As we cover how to set GitHub Copilot Coding Agent with it's many quirks you can control starting with the minimal configuration to then quickly go into how to deploy a team of specialist agents at your disposal and how you can give them the tool for success.

Then we move on to the environment this coding agent "lives in" when it executes, the GitHub Copilot Coding Agent action runner and how to modify it effectively.

Understanding that this is a cloud-first environment we look at the restrictions is has per default - as in running out of memory, little processing power, and limits how long your agent tasks can run. And - what it can cost you if you want to push the limits beyond the standard settings as you pay for GitHub action runners.

Finally we go "007"-mode and aim to beat GitHub at it's own game: You can massively stretch your budget by letting GitHub Copilot Coding Agent run on your own hardware.

This means: GPU access, access to massive amounts of memory, being able to access cached information from previous sessions, and using generous compute without paying extra.

And of course I will share a few ways I have been "abusing" this agent offering.

Rapidly developing talk as GH is working on its billing models.

Against the Slop: Engineering Creative AI Workflows

Your own music video. A custom character. Running on your own computer. No cloud required?

Yes, please.

Unfortunately, there is a small detail: all the interesting parts have to actually work together.

AI slop is everywhere. Generic images. Generic videos. Generic everything. Content that looks impressive for about three seconds and then somehow feels like you have already seen it seventeen times.

The antidote is not to reject AI. It is to stop treating it like a magic slot machine.

In this session, we will treat creative AI more like an instrument and less like a button marked "make awesome."

We will use node based environments such as ComfyUI as our playground, stare into the intimidating wall of boxes and noodles, and work out what is actually happening underneath.

What does a VAE really do? Why are there text encoders everywhere? What exactly is moving between those nodes? Why does one model need another model before it can talk to yet another model? And at what point did generating an image turn into systems engineering?

Without getting lost in the math, we will build an intuition for the components and how they fit together across image, audio, and video workflows.

The goal is simple: stop pulling the prompt lever and hoping for magic. Start building creative pipelines that are deliberate, reusable, and much more likely to produce what you actually had in mind.

And, ideally, a music video that does not look like AI slop.

Old School Statistics Meets Generative AI

Generative AI can produce a regression model, a polished chart, and several convincing mistakes before lunch. So how do we use it for serious data analysis without surrendering judgment?

In this session, we will combine natural language, AI assisted coding, and mature open source libraries to explore data, apply statistical methods, create visualizations, and build reproducible analyses. The goal is not to ask a chatbot for the answer. It is to turn statistical intent into code we can inspect, test, rerun, and challenge.

We will follow a practical workflow that makes rigorous analysis more approachable for domain experts and beginners while keeping assumptions, calculations, and limitations visible.

This is not a toy workflow. The same foundation supports real clinical research.

Come for the vibe coding. Stay for the confidence intervals.

AI Risks: There Are Monsters in Your LLMs

Your model is not your friend. It is not your enemy either. It is a very convincing instruction follower with access to your data, tools, and possibly production. What could go wrong?

Prompt injection was only the opening act. Modern AI applications browse the web, call APIs, connect to MCP servers, retain memory, and act with limited supervision. A poisoned document, malicious tool, or patient attacker can turn a useful agent into a confused deputy.

We will dissect attack patterns appearing in research and real systems, including indirect prompt injection, data exfiltration, tool poisoning, and Crescendo style jailbreaks. We will examine defenses that hold up, along with popular mitigations that put a better lock on the wrong door, introduce new failure modes, or backfire as soon as the monster learns a new trick.

Finally, we will consider what changes as agents gain more memory, authority, and autonomy. You will leave with a clearer threat model, practical defensive principles, and some important questions to ask before giving a chatbot production credentials.

Generative AI Without the Vendor Goggles

The domain of Generative AI has exploded in the past few years. The conversation is dominated by the story that major vendors push, and it is features, not knowledge, that they push.

Join me to get up to speed on the right now of this whole brave new world of Generative AI. An accessible Zero to... Hero in training.

In four segments, we aim to grasp the current state of Generative AI from a hands on perspective while keeping an independent mindset.

Segment 1: Foundations: Concepts and APIs

Together, we will look at the journey to today's models and, practically, how to interact with them using common APIs.

You will learn about the progression from pre training and post training to the models that you finally get to interact with. We will look at tokens, context, reasoning models, structured output, and why models can be remarkably capable one moment and surprisingly fragile the next.

What is actually in the model, and what is rather a PaaS offering around it? What does the model really see? What building blocks do we work with in APIs and SDKs? How much can we put into context before things get weird? And how is this landscape evolving?

Segment 2: Integrating AI

Focusing on how to integrate AI into your applications, we will look at concepts such as RAG, tool calls, MCP, and currently popular frameworks that help connect all of this.

This includes how to work with larger documents and content sources to make them accessible to AI models, what you need to do with content ad hoc at runtime or in preparation when indexing it, what vectors are actually good at, and where their limitations start to show.

Putting documents into a vector database is not quite RAG yet. We will look at chunking, retrieval, reranking, context construction, and what happens when the supposedly relevant information is not actually all that relevant.

We will also look at what a "Copilot" really is and demystify how these systems are made. Along the way, we will talk about evaluation, testing, prompt injection, and what changes once an AI feature has to work more than once in a demo.

Segment 3: The world of agents

Starting with very simple agents, we will look at how to effectively leverage AI in an agentic world, meaning how to have agents do work for you, all the way up to deploying larger teams of agents on complex tasks.

What makes an agent an agent in the first place? We will start with the simplest possible loop, then add tools, state, memory, planning, permissions, and eventually other agents.

We will look at where agents are actually useful, where a simpler workflow may be the better idea, and what changes once a model is allowed to take actions rather than merely generate an answer.

This segment is intentionally a little vague because this space is moving ridiculously fast. Expect to walk away with an understanding of useful tools and patterns in an agentic world and how to integrate agentic concepts into your own work.

Segment 4: Local AI, media content, and AI beyond the Western corporate world

There are plenty of reasons why you may want or need to run AI locally on your own devices. Here, let's talk about how that is done.

Starting with the "easy button" of tools such as Ollama, LM Studio, Azure AI Foundry Local, and various other alternatives, we aim to integrate those with our own applications and then peek below the easy buttons as well.

Why are there suddenly six versions of what appears to be the same model? What is quantization actually doing? What can you realistically run on your laptop, workstation, or whatever GPU you happen to have available?

From there, we enter the wild model zoo that suddenly becomes available once we go beyond the big cloud vendors.

We will generate images, video, speech, lip sync, and more. We will also look at multimodal models that can understand different kinds of input, models coming from Chinese AI labs, and how you can mix and match capabilities from very different models and ecosystems into interesting workflows.

The goal across both days is not to memorize the latest collection of product names. It is to understand the pieces well enough that when the next model, framework, agent platform, or miracle button appears, you can work out what it actually is, what it is good for, and whether you need it at all.

Medical AI Models for All

Medical AI has a bit of an accessibility problem.

On one side: research papers, specialist tooling, regulatory acronyms, and models with names that sound like rejected Pokemon.

On the other: people pasting their entire medical history into ChatGPT and hoping for the best.

There is quite a lot in between.

In this talk, we’ll take a hands-on tour through the surprisingly large zoo of open and freely available AI models for medical information. We’ll look at what kinds of models are out there, what they are actually useful for, and how developers, researchers, and curious patients can experiment with them without first joining a hospital research lab.

We’ll segment medical images, fine-tune imaging models, search and chat with medical information using specialized embeddings, and combine text, images, and structured data into multimodal workflows.

Some of these models are surprisingly capable. Some are oddly specific. Some come with three citations, a GitHub repo, and absolutely no instructions.

By the end, you should have a much better map of this strange little corner of AI: what you can build today, where the sharp edges are, and where to start if you want to play with medical AI yourself.

A Day in the Life of a GPU Rich Developer

What does a GPU rich developer actually do all day, besides checking power consumption and inventing increasingly creative justifications for the hardware?

A new class of AI machine now sits somewhere between a powerful workstation and a datacenter in the basement. NVIDIA calls these deskside AI supercomputers. Other vendors use large unified memory pools to fit models locally that once required cloud infrastructure.

In this session, we will spend a day running large models, fine tuning them, unleashing AI agents, and conducting experiments that seemed sensible at the time. We will see what changes when an idea becomes a local command instead of a provisioning exercise, a data upload, and a rapidly spinning cloud meter.

We will also confront cost, heat, software friction, and the awkward amount of time an expensive machine can spend doing absolutely nothing.

Expect hundreds of gigabytes of memory and enough power draw to make the air fryer nervous. You will leave knowing when local compute is liberating, when the cloud still wins, and whether being GPU rich is actually worth it.

Beyond DeepSeek: A Developer Tour of China’s AI Ecosystem

For years, the generative AI conversation was dominated by a handful of Western giants. Then DeepSeek crashed the party.

But DeepSeek is not an anomaly. It is one visible part of a rapidly growing ecosystem of open weight models, coding agents, and media generation models.

This session goes beyond benchmark drama and geopolitical hot takes. We will put DeepSeek, Qwen, Kimi, GLM, and others to work on real developer tasks. We will test coding agents, compare text and media generation, and see what can run locally or fit into familiar development workflows.

We will also look honestly at cost, licenses, privacy, censorship, and platform risk. The conclusion will not be “China won” or “nothing to see here.”

Come for the benchmark drama. Leave with a practical map of an AI ecosystem developers can no longer afford to ignore.

Building on Shifting Sands: AI Integration in a Fluid World

Integrating AI is no longer just about sending a request to a model and getting some text back. Applications now have tools, context, memory, workflows, and increasingly the ability to go off and do actual work.

Which is useful.

It also means the architecture diagram from six months ago may already look a little archaeological.

In this session, we will step away from the tool of the week and look at the building blocks underneath modern AI integration.

Starting with a simple model call, we will add structured interaction, tools, context, and orchestration, and see where an AI integration quietly turns into an agent.

We will look at MCP as part of today's integration landscape, what problem it actually solves, and where frameworks such as Microsoft Agent Framework fit around it.

What belongs in your application? What belongs in a framework? What does MCP actually buy you? When does orchestration help, and when have you simply built a very elaborate way to call a function?

The goal is not to predict which framework will still be fashionable next year. It is to understand the pieces well enough that when the sands shift again, you can recognize what actually changed and what merely got a new logo.

How Agents Work Together Without Losing the Plot

You can build one agent in an afternoon. Add a second, and suddenly you have a distributed system with opinions.

Context engineering is difficult enough for one agent. Across many, it becomes a coordination problem: What does each agent know? What should it remember? What gets lost along the way? Most systems answer with prompts and tool calls, shoveling state through text and hoping the important bits survive. This works surprisingly well until the system becomes slow, expensive, or confidently wrong in ways that are miserable to debug.

We will trace how information moves through modern multiagent systems using memory, skills, hooks, subagents, MCP, and A2A. You will learn what each layer contributes, how to compose them, and where the tradeoffs hide.

Finally, we will look beyond today’s text passing architectures and ask: If agents stop trading text, what should they share instead?