Vision Language Action Models (VLAs) promise to bring the ChatGPT moment to robotics. Thanks to their strong foundational knowledge, they can solve complex problems end-to-end and be easily adapted to completely new tasks and embodiments. But how far can VLAs be pushed? Could they even play video games?

In this talk, Thomas will show how a VLA can be trained to play arbitrary video games using imitation learning. He will draw first blood with an introduction to VLAs. Attendees will learn how they work, what kind of data they are designed to process, and how that makes NVIDIA's GR00T perfect for playing video games. After that, Thomas will briefly cover the concept of imitation learning, what kind of data is needed to train GR00T, and how it can be collected from games. Finally, he will tell the story of leveling up the model from total noob to global elite - one failure at a time - and share all the things learned along the way. To close the game, Thomas will challenge one member of the audience to beat GR00T live on stage in a 1v1.

Observability often grows one tool at a time. Logs may live in Elasticsearch, metrics in Prometheus or InfluxDB, and traces may be missing completely. Each tool has its own query language, storage model, and dashboards. As a result, finding the cause of a slow request can take longer than it should.

This talk explains how to connect logs, metrics, and traces with the Grafana LGTM stack: Loki, Grafana, Tempo, and Mimir. It also shows how OpenTelemetry and Grafana Alloy can collect and connect tObservability often grows one tool at a time. Logs may live in Elasticsearch, metrics in Prometheus or InfluxDB, and traces may be missing completely. Each tool has its own query language, storage model, and dashboards. As a result, finding the cause of a slow request can take longer than it should.

This talk explains how to connect logs, metrics, and traces with the Grafana LGTM stack: Loki, Grafana, Tempo, and Mimir. It also shows how OpenTelemetry and Grafana Alloy can collect and connect telemetry data from applications.

Ned will share lessons from building and running this stack in a production environment. The platform is self-hosted on AWS, runs in Docker, and is protected by Nginx. The talk will cover how the main parts fit together, how data moves through the system, and how to connect an alert to the related logs and trace.

Attendees will leave with a practical view of the architecture, the main setup steps, and the tradeoffs to consider when building a self-hosted observability platform.lemety data from applications.

Ndshare lessons from uilding and running this stack in a production nvironment.he pltform is sef-hosted on AWS, runs in Docer,an is protcted by Nginx. The talk will cover how the main part fit together, how data moves through the system, and how to onnect an alert to the elated logs and trace.

Attendees wll leave with a raccal view of the architecture, the main setup steps, and the tradeoffs to csider when building a self-hosted observability platform.

Standard userland utilities like ps, netstat, and top create a false sense of security and observability. Built for simpler times, they are easily blindsided by modern abstractions like containers and capabilities, or outright tricked by argument overwriting and linker hijacking. Furthermore, the “do one thing and do it well” philosophy forces engineers to combine fragmented tool outputs using vague criteria, burying critical insights in noise.

This talk strips away user-space abstractions to demonstrate how to audit, debug, and verify running workloads by querying raw kernel structures directly inside /proc. This approach is invaluable for uncovering malware or anomalies, or for debugging minimalist containers with no native tooling installed. Aivars will explore the most vital /proc files, what they reveal, and how to link them together through inodes and memory addresses to extract the kernel’s absolute truth.

You’ve spent months building your project. You know the architecture, the patterns, the libraries, and every painful bug along the way. Then some non-technical guy asks a simple question: “So, what does it do?” Suddenly, explaining the project is harder than building it.

In this session, Alper will look at how developers can explain technical work to people who don’t share their context, whether that’s a customer, a manager, their mother, or someone they meet at a conference. He will explore how to decide what the audience actually needs to know and turn complicated technical details into stories people can follow and remember.

He has been giving conference talks and has presented his .NET project to audiences in more than 100 countries. He has learned that the same technical story needs to be told differently depending on who’s listening. He’ll share practical examples and lessons learned along the way.

If developers can make their mothers understand why their projects matter, explaining them to the next audience might become a lot easier.

SQL Server 2025 introduces native vector support, enabling AI-powered semantic search directly inside the database engine. But what does that mean for data professionals, and how does it actually work?

In this session, Andrew will break down the fundamentals of vector search and show exactly how SQL Server stores, indexes, and queries embeddings to deliver semantic search capabilities.

He will cover:

• What embeddings are and how to visualize them in high-dimensional space
• How the vector data type works in SQL Server
• How to generate and store embeddings using an external large language model (LLM)
• Performing searches using VECTORSEARCH() and VECTORDISTANCE()
• How vector indexes, such as those based on the DiskANN algorithm, work under the hood

Andrew will then bring it all together by building an intelligent, AI-driven application to provide burrito restaurant recommendations in Ireland.

This session is ideal for data professionals and developers who want a practical understanding of SQL Server’s vector capabilities, with real demos and a real use case.

AI is making code abundant, but most companies still organise software delivery around scarce implementation capacity. This session follows a regulated-enterprise case in which more than 300 employees built over 1,900 internal applications and more than 200 use one on a typical day. The speaker shows what changed when selected domain experts stopped handing requirements through a delivery chain and began owning the problem, the working system and the outcome end to end. The session covers a practical handoff audit, signals for identifying potential full-stack operators, the paved technical path that supports direct authorship, and failures hidden by adoption metrics. Attendees leave with a concrete framework for deciding which handoffs add distinct judgment, which merely transfer information, and how engineering leadership changes when implementation is no longer the scarce resource.

Cybersecurity programmes often rely on periodic risk assessments, control reviews, and incident-driven improvements, while adversaries continuously adapt their techniques, infrastructure, and decision-making.

In this session, Dionysis Karamitopoulos introduces Continuous Adversarial Readiness, a governance-led security operating model that connects threat intelligence, controlled adversarial emulation, AI-assisted analysis, and continuous validation of defensive controls.

The session explores how current threat intelligence can trigger targeted security validation, how AI can support analysis and prioritisation, and how the resulting evidence can feed back into security architecture and risk decisions. It also addresses a critical question as security technology becomes increasingly autonomous: where should automation stop, and where should human decision-making remain mandatory?

Rather than proposing autonomous retaliation or “hack back” approaches, the model focuses entirely on defensive readiness. The objective is to continuously understand how relevant adversaries may approach an organisation, test whether existing controls remain effective, and adapt security decisions before weaknesses become incidents.

Attendees will leave with a practical framework for connecting adversarial thinking, AI-assisted security, continuous control validation, and governance within an enterprise security programme.

Autoscaling model inference for traditional ML/AI workloads is a relatively well-understood problem; these workloads are typically scaled horizontally, adding extra containers under increased load. But what do you do when you have millions of requests and larger models that span multiple machines and GPUs, requiring significant workload coordination?

In this talk, Federico will take the perspective of an MLOps team tasked with reducing the AI vendor spending of a large enterprise, deploying increasingly large open-source language models on Kubernetes. He will identify a series of practical inference and system architecture best practices that teams can follow to autoscale model serving in their clusters.

Furthermore, Federico will take a deep dive into components of the open-source ecosystem that teams can deploy to optimize the utilization of their compute (GPU) resources and increase the number of tokens per second (TPS) served.

Talk Structure

• Quick intro to autoscaling methods on Kubernetes and language model inference
• Explanation of the demo task to the audience
• Deep dive into autoscaling model serving on Kubernetes, starting with smaller single-container models, then moving to large models that span multiple containers, and finally adding GPU complexity
• Particularities of autoscaling GPU resources
• Open-source tools that can simplify “some” of this work (Ray, vLLM, SGLang, etc.)

Conclusion
This is a very interactive talk with multiple questions for the audience throughout the presentation.

The Sovereignty Imperative
Gartner expects EU sovereign cloud IaaS spending to nearly double in 2026, from $6.9 billion to $12.6 billion, and to reach $23.1 billion by 2027.

Two factors are driving this: regulation and geopolitics. GDPR, NIS2, DORA, and the EU Data Act have generated €7.1 billion in cumulative fines. And in July 2025, Microsoft told the French Senate under oath that it could not guarantee European data would stay out of US hands under the CLOUD Act.

The EU's Cloud and AI Development Act, proposed in June 2026, adds four assurance levels. At the top two, which cover sensitive public-sector and critical-infrastructure workloads, US-owned hyperscalers simply don't qualify. They still run more than 70% of the European market, but 61% of Western European CIOs now say geopolitics is pushing them toward local providers.

The Egress Problem Nobody Budgets For
The market has already started to move. The European Commission awarded a €180 million sovereign-cloud framework to four European providers, including STACKIT, Scaleway, and OVHcloud. The Dutch central government signed one with an EEA exit clause. De Nederlandsche Bank moved to Schwarz Digits, STACKIT's parent. And in November 2025, Schwarz Digits broke ground on an €11 billion, 200 MW data centre in Lübbenau.

What often gets missed is what happens once an organization is running across two clouds: moving data between them is expensive, and it's expensive on purpose.

Hyperscaler egress costs 5–10× what European providers charge: $0.05–$0.09/GB at volume, up to $0.12/GB on GCP's Premium tier, compared with rates that can be as much as 90% lower from EU providers. Hopsworks cut its cloud bill by 62% after moving from AWS to OVHcloud, most of it due to free egress.

The EU Data Act kills switching fees in January 2027, but day-to-day operational egress isn't covered. In a dual-cloud setup, enterprises pay it every time data crosses the line.

Solace as the Sovereign Data Backbone
This is where the Solace event mesh earns its place. Instead of copying whole datasets back and forth, Solace streams only what has changed, as events. In transactional workloads where only a small share of records change each cycle, this can cut cross-cloud transfer by an estimated 80–95%.

A few things that follow from that:

• Financial and government workloads on STACKIT keep a live, EU-sovereign system of record, fed by events from AWS or Azure, with no need to tear out what's already running.
• Topic subscriptions are selective, so each environment only receives the data it is legally allowed and operationally required to hold, which shrinks transfer volume and compliance exposure at once.
• It speaks AMQP, MQTT, REST, JMS, and Kafka-compatible APIs, so it bridges mismatched environments without a re-platforming project.
• Guaranteed delivery and replay give regulated industries the audit trail and resilience their rules require.
• The payoff is a predictable bill: organizations pay for small, discrete events, not full-dataset copies.

In the session, Hari will cover:

• The regulatory and geopolitical forces reshaping EU cloud in 2025–2026
• The real cost of cross-cloud data movement and how to model it
• The event-driven sovereign architecture pattern, with STACKIT as a reference implementation
• A cost-optimization framework spanning event payload sizing, topic design, and selective subscription strategies
• How the Solace event mesh enforces data-residency policy at the infrastructure layer, aligned with GDPR, DORA, NIS2, and the EU Data Act

What if our computers hadn't been binary? We take bits, zeros, and ones for granted, as if binary computing were the only possible way to build a computer. But in 1958, Soviet researchers at Moscow State University built Setun, a real computer based on balanced ternary: −1, 0, and +1. It wasn't an experiment on paper: Setun was produced, programmed, and used for years.

In this talk, Horacio will explore what happens when a bit becomes a trit. How do you represent positive and negative numbers? How does arithmetic work? What do memory, instructions, registers, and conditional branches look like? He will dissect Setun's surprisingly elegant architecture and go all the way to building an emulator capable of running its instructions. Along the way, he will explore why base 3 has some fascinating mathematical properties, including the radix economy argument, and why, despite them, binary ultimately became dominant.

But ternary computing never completely disappeared. Three-state logic lives on in TCAMs used in networking, ternary weight quantization is behind current research into 1.58-bit large language models (LLMs), and quantum computing is exploring qutrits alongside qubits. Setun may be a computer from 1958, but the ideas behind it are surprisingly alive today. Maybe binary wasn't the only possible future after all.

In event-driven systems, teams should not call another service's API, but instead consume its events and maintain local state. However, how much state should they store? If teams limit themselves to the state that is needed at the moment, they may find themselves rushing to deal with changes in requirements over a number of sprints. If they store all the state, then they end up being coupled to the other team's schema evolution.

In every architecture review, this decision comes up, gets discussed in a Slack thread, and is regretted six months later. However, most teams lack a systematic approach to evaluating it.

In this talk, Jeroen will walk attendees through the range of options, from making REST calls to full event replication. He will share examples of teams that kept too little data and teams that kept too much, and provide a practical decision-making framework based on four criteria: topic retention, schema stability, requirements clarity, and query patterns.

Attendees will leave with a method they can use to assess this trade-off in their own systems. It won't be a set of rules, but rather a structured approach that recognizes there is no one-size-fits-all solution.

What Jeroen will cover:

• The spectrum: REST calls, thin projections, full event replication, raw event storage, and when each approach breaks down
• Real examples of teams that stored too little and teams that stored too much, and what it cost them
• A decision framework built on four axes and how to apply it in an architecture review

Coding is dead. But software engineering is more alive than ever. AI agents write code, vibe coding is becoming a reality, and yet, or precisely because of this, the demands on junior developers are rising. Because anyone who doesn't understand what AI produces can neither evaluate it nor take responsibility for it.

This talk examines what deliberate junior training means in the age of AI. On the technical side, Kajetan will show why engineering fundamentals like TDD, CI/CD, and code reviews matter especially in the context of AI, as a yardstick for what AI delivers. On the personal side, he will focus on the virtues that no AI can take over: self-organization, taking ownership, and the ability to grow consciously within a team.

The talk is aimed at anyone who trains juniors, mentors them, or is a junior developer and wants to understand what really counts in a world full of generated code.

The industry has seen the Model Context Protocol (MCP) unlock incredible agentic workflows, but there is a hard truth Kalle often shares with clients: building the technical architecture is the easy part. The gap between “it works perfectly in my demo” and “the enterprise security team approves it for production” is where most MCP projects die.

To get AI agents out of the sandbox and into production, teams need to design for security, governance, and enterprise reality from day one. In this pragmatic talk, Kalle will cover the security considerations and best practices he uses for enterprise MCP development.

Do you trust your AI coding assistant? What if I told you that attackers have found ways to manipulate it and attack your code? With everyone now using AI coding assistants it’s time to look at the risks!

During this talk I’ll show you several new techniques attackers are already using. This will range from hidden messages (ASCII smuggling) to abusing mistyping and characters that look the same (typosquatting). I will also show how an LLM can make mistakes when generating code (hallucinations). Did you know that a smart attacker can abuse this too?

When you join this talk, you’ll learn how to spot hidden text in your instruction file and prompts. I will also explain how to set up a trusted dependency repository to prevent the malicious code from entering your production environment!

Liisa Thomas explores how behavioral science and organizational change principles are shaping the future of corporate compliance. In the presentation, she will share practical tools - like stakeholder mapping, influence planning, and cultural diagnostics - that privacy, AI and data professionals can use to integrate the power of organizational change into their compliance efforts. She will discuss how professionals can move past checklists and instead implement real, sustainable change in their organizations. 

Modern systems do not fail politely; they drift slowly toward a threshold, they spike without warning, they hide two different behaviors behind a single reassuring average, and they bury three real root causes underneath forty-seven simultaneous alerts. The observability engineer is the person who reads that mess and turns it into a decision, and this presentation exists to provide the foundations for doing so.

As a result, attendees will be able to see a problem while it is still forming rather than after it has become an incident, because they will have the tools to find a latency peak early, forecast the moment a metric crosses its limit, and collapse an alert storm into a short and actionable list.

That is the whole value in one sentence: an average tells attendees that a system is fine, and this presentation gives them the necessary tools to see the moment it stops being fine, and to see it first.

AI costs are easy to see when they arrive as a license fee or an API bill. The time people spend checking AI output is much harder to spot.

An agent may produce code or analysis in seconds, but someone still has to decide whether the result is correct, safe to use, and good enough to ship. Usually, that reviewer is a senior engineer, whose time is among the most expensive on the team.

This talk looks at AI-assisted work as an end-to-end system and shows how to account for the human effort around the model. It also examines how much human verification the workflow needs, what that verification costs, and where it can be safely automated.

A quest, not a sprint.

It began with a question: how sovereign is an organization, truly? And is there any way to know for sure? A Fellowship formed - tokens and vectors, not Hobbits and wizards - to carry the Assessment into the Fires of Production.

The Shire of Requirements, where everyone nods at “just use an LLM” and nobody asks what happens when the context window runs out.

The Mines of pgvector: dark, vast, treacherous. Many have fallen there.

The Ridge of RAG, where one wrong step means hallucination on one side and retrieval irrelevance on the other.

The Misty Mountains of Prompts, where Pawel learned that a prompt is not a question - it’s a contract.

Beneath Docker Mountain lies the shelter: the full Docker AI toolset, running the stack locally.

Then comes Production: the Land of Desolation.
The Assessment survived.

In this talk, Pawel invites attendees to join the Fellowship and discover the patterns that work.

AI agents can reason, call tools, and perform complex tasks. However, when they start a new conversation, they behave as if they’ve never met the user. Give them too much history and they get distracted, expensive, and inconsistent. Give them too little and they forget user preferences or struggle with longer tasks. What is the right way to give an agent memory?

A vector database can be added, but that alone is not enough to solve the problem. It is also necessary to decide what the agent should remember, when it should save something, and how it should find that information later. Oh, and don’t forget that old memories can become stale - they need to be changed or removed at the right time.

Overall, building memory systems for AI agents is a data problem. This talk presents a practical way to think about the problem. The speaker will look at working, short-term, semantic, episodic, and procedural memory. Then, the talk will follow a memory through the system from creation to retrieval and eventual deletion. A short demo will compare exact, semantic, and hybrid retrieval and show how the agent behaves with and without the right context.
The goal is simple - to help attendees build agents that remember useful information without filling their context with irrelevant or outdated details.

Workload identities are a staple of modern cloud architecture. They are routinely used to authenticate to managed cloud services or fetch secrets from Vault. Yet, when it comes to securing communication between internal services, organizations often default back to static API keys and shared secrets.

Managing these internal credentials is often messy, error-prone, and a massive security risk. There is a better way. In this talk, Thomas will explore how to leverage native Kubernetes features and open standards to eliminate static secrets entirely. He will break down the core mechanics behind OIDC token exchanges, Kubernetes Token Projection, and the SPIFFE/SPIRE ecosystem.

Finally, Thomas will walk through a practical, real-world example: mapping Keycloak identities to Kubernetes service accounts. Attendees will leave with a clear blueprint for enabling seamless, secure, and credentialless service-to-service communication inside their own clusters.

Anyone who can open a support ticket can now talk to something that reads all of production. Yedidya built it: an autonomous AI agent living inside the production cluster, triggered by a ticket webhook, investigating 20 data sources (OpenSearch, RDS, BigQuery, logs, and Kubernetes) and replying directly to the ticket. Always read-only.

He tried every open-source investigation agent he could find; none were safe enough to give production access. So he built his own — and the hard part was never the investigation; it was the defense.

Attendees will walk away from the session with: the read-only-by-construction pattern for giving an agent production access, with no write tool available to call; the guardrail stack — a locked-down tool surface, network and RBAC limits, and prompt-injection defenses — that treats every ticket as untrusted input; how to stream an LLM's own traces into application performance monitoring (APM); the one NetworkPolicy that silently broke it; and an honest look at where it helped reduce the on-call burden — and where it answered with full confidence and was wrong.