Umbraco
DK
Festival

Join Lotte and Sebastiaan from Umbraco HQ for a look at where Umbraco is today and where it’s going next. We’ll demo what our engineers are working on now, and share what’s ahead later this year across the CMS, Umbraco Cloud, and products like Umbraco AI and Automate.

This includes the long-awaited Reusable Blocks feature and changes coming to Umbraco Search in Umbraco 19.

But this isn’t just a product update. It’s a story about how the Umbraco community shapes the platform, turning ideas and feedback into real contributions. You’ll see where you can get involved, what opportunities are emerging, and how your voice fits into what comes next.

Whether you’re building, implementing, or making the decisions, you’ll leave with practical insights, a clearer view of the roadmap, and a real sense of how you can help guide where Umbraco goes from here.

How do you make an agent keep working until the job is actually done? How do you make it verify its own progress, recover when something fails, and know when to stop? And when is one agent no longer enough?

In this session, we will go deep into loop and graph engineering — two powerful patterns for building agents that can operate autonomously and reliably.

We will build agents that work towards verifiable goals, iterate until specific conditions are met, and operate within clear boundaries. Then we will take the next step and compose agents into graphs where specialized agents divide the work, run in parallel, verify each other, and hand work between them.

Along the way, we will explore how to design effective finish lines, build verification into the loop, prevent agents from running forever, decide when work should be split across multiple agents, and control what flows between them.

You will leave with practical patterns for designing loops and graphs that make your agents more autonomous, predictable, and effective — patterns you can start using in your own agentic systems right away.

Observability closes the feedback loop — but it is often introduced only after something has already broken in production. It can shine in that situation, but what if the same telemetry could also help us build better software before it is released? And what if it could give an AI coding agent enough context to test, diagnose and improve its own work?

In this live-demo session, we will give developers and AI agents X-ray vision into a running Umbraco application.

Starting with a local Umbraco site and a custom package, we will use .NET Aspire and OpenTelemetry to bring logs, distributed traces and metrics together in one local observability environment where we will build a new feature, diagnose real problems and verify that our fixes actually work.

We will also explore how coding agents can use observability data through Model Context Protocol to move beyond simply generating code. By inspecting the behaviour of the running application, an agent can help identify failures, suggest changes and validate the result.

Along the way, we will consider what telemetry is genuinely useful, how to avoid collecting personal form data, and how to give AI tools controlled, read-only access to production systems. These practical examples will give you a concrete approach for making observability part of the development process—not merely something you add after deployment.

An opinionated soap box session of dos and don'ts in Umbraco #notacult

AI agents can write code. The harder part is trusting them to work on real tickets while you're not watching, and getting back work you can actually review.

This session shows how we run unattended agents on Umbraco projects today, across GitHub and across Jira with Azure DevOps. A ticket goes in and a draft PR comes out, with screenshots, test results and the reasoning behind each change. A human stays in control at both ends. If the ticket is unclear or the build fails, the agent stops and asks rather than guessing.

We'll share what worked, what broke as it scaled, and why we moved from simple agent loops to a deterministic orchestrator.

You'll leave with a practical checklist of what your project needs before you hand work to an agent.

TBA

When building software, we all know well that we cannot predict all the possible pitfalls that await us during implementation. Join us on a story of how we set out to engineer Compose’s ingestion pipeline and what happened when customers started ingesting millions of data items - and how we rebuilt it to handle the load. We will talk about per-tenant session queuing, fair scheduling and resource starvation - and how they fit in the overall architecture of Compose.