Event Sourcing: The Only Sane Way to Run Agentic Systems

In an agentic world, software no longer just responds to user input — it acts on our behalf. Decisions are made by AI agents, workflows are executed autonomously, and systems continuously change themselves. When something goes wrong, “the state” is no longer a sufficient answer.

This talk explores why event sourcing becomes foundational in AI-driven systems. Event types don’t just record what changed, but capture why it changed, who initiated it, on whose behalf, and what caused it — including the originating prompt, model, and decision chain.

By preserving identity, intent, causation, and context as first-class data, event-sourced systems provide something traditional architectures cannot: a complete, trustworthy audit trail that survives autonomous execution. Not logs. Not snapshots. A factual history.

You’ll see how causation chains, correlated events, and rich metadata turn production systems into explainable systems — enabling accountability, debugging, governance, and trust when humans are no longer in the loop for every action.

If AI agents are going to act for us, we need architectures that can answer for them.

The assembly language for information systems

Every big leap in software has been about letting go of a layer we used to worry about. Operating systems freed us from the hardware. Virtualization freed us from the physical machine. Containers freed us from the environment, and orchestration freed us from the machines entirely.

Hardware → Operating System → Virtualization → Containerization → Orchestration → ?

And yet, at the very top of that ladder, we still hand-craft applications the same way we did decades ago. Controllers, repositories, mappers, wiring, plumbing. The business outcome we're actually trying to achieve is buried in there somewhere, spread across a hundred files. Ask anyone on the team what the system does, and they'll point you to a wiki page that stopped being true two sprints ago.

The thing is, we're now entering a world where AI writes more and more of our code. That changes the question. It's no longer "how fast can we type", it's "how precisely can we describe what we want". What we're missing is a target to compile to. An assembly language for information systems.

That's what Screenplay is. A new abstraction level, the Application Model, that sits on top of the ladder we've been climbing for fifty years. Screenplay is built on Event Modeling and describes systems as vertical slices: commands, events, read models, and the flows that connect them. You describe the business outcomes. An engine turns that description into a running, event-sourced solution. No infrastructure decisions, no plumbing, no drift between the design and what's actually running.

In this talk I'll make the case for why this abstraction is inevitable, show you what Screenplay looks like, and go from a business-level description to a running system. Live, no slides pretending it works. Just the thing itself, working.

You'll see:

- Why the next rung on the abstraction ladder is the application itself, not more infrastructure
- How Event Modeling's building blocks (commands, events, read models) become an executable language
- What it means to describe outcomes instead of implementations, and let an engine do the rest
- Why AI makes a precise, verifiable application model more valuable than the code it generates

Can your database do this?

What if your database didn’t just store state, but told the full story of your system?

This talk explores the real power of event sourcing: complete traceability, deep insight, and a development model that stays flexible as requirements evolve. By treating events as the source of truth, you gain time travel, reproducibility, auditability, and the ability to rebuild any view of your system at any point in time.

But this isn’t just about architecture elegance. Event sourcing also makes your domain inherently AI-ready. When every event carries rich context and metadata, you unlock high-quality signals for analytics, automation, and intelligent systems — without bolting on fragile pipelines later.

You’ll leave with a clear understanding of what becomes possible when your database stops being a passive store and starts becoming a living record of everything that happens in your business.

Event Sourcing - AIs best friend

With traditional CRUD based approaches you basically throw away very valuable information.
Information that describes not only what changed, but also why it changed.
When one does not have this information, you have to contextualize it.

Event Sourcing provides a natural out of the box experience with all your data perfectly contextualized.
This information can help you provide powerful insights into your system.

Most systems aren’t event sourced however. Where do you start in an existing system?
How can you start identifying what your system already has and get started with event sourcing?

In this talk we’ll explore how you can use different techniques to learn more about your existing system
and how to turn your valuable state changes into well formed and named events by leveraging
LLMs as part of the process.
We will also look into how an event sourced system can talk to non event sourced systems and still
provide meaning through Change Data Capture techniques. Last we’ll see how the power of
LLMs combined with MCP give your organization and end users super powers.

Your system is a timeline. Start treating it like one.

Every system has a story. A thing happened. Then another thing happened. Then a user reacted. Then the system responded. It's a timeline — but most architectures throw that timeline away the moment they overwrite a row in a database.

Event Sourcing is the idea that you stop throwing it away. You record what happened, immutably, in order. Your state becomes a consequence of your history, not a replacement for it. You get time travel. You get a full audit log. You get the ability to build an entirely new view of your data from events that already exist.

But here's the part most teams miss: Event Sourcing doesn't automatically make your system understandable. The gap between business intent and technical implementation is still there — and it's still expensive.

That's where Event Modeling comes in.

Event Modeling gives your entire team — developers, domain experts, product owners — a shared visual language to describe how a system behaves before anyone writes a line of code. It uses exactly three building blocks: commands, events, and read models. It uses exactly four patterns. That's it. You can explain the whole approach in ten minutes. The rest you learn by building.

In this talk, I'll walk through what it actually looks like to go from a domain brainstorm to a running, event-sourced application — using Cratis, an open-source event sourcing platform for .NET, and Cratis Studio, a collaborative modeling tool that takes your event model and generates type-safe C# commands, events, and projections directly from your design.

Design and code that tell the same story. No translation loss. No "it made sense in the meeting" moments two sprints later.

You'll see:

- How Event Modeling forces clarity about what your system actually does
- Why Event Sourcing is the natural implementation layer for a model-first approach
- How code generation from a shared model eliminates the drift between design and reality
- What time-travel debugging and projection replay look like in practice

This isn't a theoretical talk. We'll go from blank canvas to working software — live.

Engineering for Chaos: Software Architecture for Emergency Response

Emergency medicine is chaos by default: connectivity disappears, devices fail, crews change mid-mission, and data must follow the patient — not the hardware.

This talk tells the real-world story of designing and building software used across ambulances, helicopters, and maritime units, running on Windows, iPad, Android, and the web, with full offline support and reliable synchronization.

Driven by harsh constraints, the architecture evolved toward an event-first approach where every change became an atomic unit for storage, transfer, and replay. You’ll hear how this enabled offline-first sync, multi-device collaboration, live handovers between teams, and consistent behavior across platforms.

This is not a theory talk. It’s a candid, experience-based story about architectural tradeoffs, unexpected challenges, and what actually worked when the software left localhost and entered real emergency environments.

Maintainable vibe coding

One of the biggest challenges with vibe coding is handling change.
Agents can get you going real fast, but when you want to react to changing requirements,
the agents tend to struggle and can get you into a real mess real quick.
Much like we humans would do with large systems as well, because of the amount of context
one needs to have.

Breaking software into vertical slices that are focused on individual use-cases allow
you to have self-contained capabilities. This then gives you the confidence of
making changes and avoiding merge conflicts ant the like.
For agentic LLMs, this a perfect fit. Done right with formalized building blocks,
AI can easily amend functionality. Given the nature of the slices, they could also just be
thrown away and you could just regenerate a vertical slice as requirements change for it.

This talk will focus on how having an opinionated approach can act as rails for your
agent. Providing a more consistent and maintainable code base that is as maintainable
for the AI as for the developer.

Through vertical slices, Domain Driven Design, CQRS and Event Sourcing, this talk
will show how you can empower your teams to deliver reliably with high productivity.

Realtime collaboration of systems in a non-API world

How can systems collaborate without being coupled together and achieve full autonomy.
This was the promise an API-driven world, but the reality has lead to systems being built
with coupling through their APIs. In this talk you’ll see how this can be solved through a
decentralized, event-driven and microservice oriented approach.

Information saves lives

Public health crises, such as disease outbreaks and famine most often occur in settings where health systems and public health surveillance are weak. This gap in national and global surveillance poses a risk to communities, as disease outbreaks can develop undetected.

In emergencies, whether sudden or slow onset, people’s vulnerabilities to health risks increase, and infectious disease can quickly spread and cause life threatening outbreaks. At the same time, health services can become overwhelmed or put out of function, at a time where risk monitoring is most needed.

Risk monitoring provides early detection, which enables early response.

Digital volunteers have now since October 2017 been building a solution in the open for Red Cross. You'll learn more about how people in tech can contribute and how much of an impact you can do to other peoples lives and in fact save lives.

A year ago we presented at NDC Oslo 2017 about the journey we were about to embark on - its been so great to see people from near and far gather around this project and really focus on the primary objective of helping other people.

Let's focus on business value

Users are more demanding than ever. The systems we build should do more than ever. Competition is fiercer than ever. Technology changes more rapidly than ever. How to keep up with it all?

This talk will walk through a way of working with software that enables you to take away a lot of the complexities often found in Line of Business scenarios, such as multi-tenancy, resource management, cloud vs edge / on-premise and how to keep it all continuously improved leveraging the power of event driven architecture in a distributed decentralized microservice environment. In addition you'll see how you can work with authentication and authorization without having to write any code for it.

All this without you as a developer having to think about any of it.

It will showcase the open source platform Dolittle and how you can get started with it.

This talk showcases how you can separate concerns and take the cross cutting concerns to the next level. Its focus is on architecture with a lot of demos.