Event Sourcing — The Video Signal

Sep 14, 2026 · 20:50

Every step you take, every call you make: the reliable agent stack — Giselle van Dongen, Restate

This talk introduces Restate, an open-source framework designed to provide a flexible, durable foundation for building resilient, long-running, and stateful agentic systems. Restate addresses the infrastructure gap in agent development by handling complex concerns like retry logic, recovery, session isolation, and process cancellation. It operates as a server proxying requests to the agent service, using an event journal to ensure that processes can survive crashes, redeploys, and long periods of suspension (e.g., waiting for human approval) without losing state or consuming serverless execution time.

Key takeaways

Durable Execution and Resilience 5:40
Restate enables durable execution, allowing an agent process that runs for extended periods (e.g., a week) to crash and restart exactly at the point of failure, rather than starting over. This is achieved by recording all events in a journal.
Modeling State with Virtual Objects 14:00
Instead of modeling agents as simple workflows, Restate uses 'virtual objects' to model persistent, stateful entities (like a session). These objects have unique IDs and isolated state, allowing multiple agents to interact with a single run without interfering with each other's state.
Advanced Control and Interaction 16:40
The framework supports advanced control primitives, allowing external processes to signal, inject state into, or completely cancel an already running agent loop. This capability is crucial for complex, multi-agent interactions.
Low Latency via Push Model 19:20
Unlike traditional workflow orchestrators that poll for new tasks (pull model), Restate uses an event-driven, push model for invocations. This design significantly lowers latency, achieving low latencies (e.g., 45ms p99) even for multi-step workflows.

Watch on YouTube Full article

Aug 19, 2026 · 19:15

Why Your Enterprise Tech Stack Isn’t Ready for AI Agents — Christopher Lovejoy & Saul Howard

The talk addresses why traditional enterprise tech stacks are insufficient for deploying AI agents in highly regulated industries like healthcare. The core argument is that focusing on achieving high accuracy during a Proof of Concept (POC) often leads to architectural debt when attempting productionization. To build scalable, compliant systems, engineers must prioritize non-functional requirements—specifically auditability, data security, and human oversight—from the outset. This requires adopting specialized primitives: immutable event logs, schema-driven object storage for sensitive data, and treating humans and models as equivalent agents.

Key takeaways

Audit Trail vs. Developer Log 0:05
In regulated environments (e.g., HIPAA, SOC 2), an audit trail must be a complete record of every action taken by the agent, every place it accessed data, and the authorization behind each step—not merely a developer log like those found in DataDog [5:19].
Prioritize Constraints Over Accuracy 0:12
Engineers should take regulatory constraints seriously first (e.g., auditability) and design the architecture around them, rather than bolting compliance requirements onto a high-performing POC [12:07].
The Three Architectural Primitives 0:08
Effective AI agent systems require three core primitives: an immutable append-only event log (for state tracking), schema-driven object storage (for data separation and Zero Trust), and human/model agent equivalency (for seamless escalation) [8:30].
Evals as a Byproduct 0:10
By implementing these three primitives, robust evaluation (evals) can emerge naturally—allowing for action replay, testing on production data without exposure, and comparing human vs. model performance—rather than being an afterthought [10:37].

Watch on YouTube Full article

Jul 30, 2026 · 21:37

Let's integrate AI Agents in Event-Sourced Systems — Divakar Kumar, FlyersSoft

The presentation outlines an advanced architectural pattern for integrating AI agents into existing enterprise systems, specifically targeting real-time fraud detection. Instead of replacing established Rule-Based Engines or ML models, the approach layers agentic intelligence to resolve 'gray zone' transactions—cases where current deterministic systems lack sufficient context. The architecture leverages Event Sourcing and Domain-Driven Design (DDD) principles by building a centralized semantic layer that aggregates data from multiple bounded contexts (e.g., Transaction, Device, Account). Agents then consume this enriched context via an orchestration layer in a saga pattern to reach a final verdict.

Key takeaways

AI Agents Augment, Not Replace, Existing Systems
The primary value of AI agents is not replacing existing systems (like rule-based or ML engines) but rather adding an agentic layer to handle ambiguous cases—the 'gray zone' where current models lack necessary context. The goal is to enhance business workflows using the state and history already captured by event sourcing.
Context Aggregation via Semantic Layer 17:37
To provide sufficient context for agents, data from disparate bounded contexts (Transaction, Device, Account, Payment) must be aggregated into a semantic layer or materialized view. This is achieved by propagating domain events using Change Data Capture (CDC) mechanisms or message brokers.
Saga Orchestration and Agentic Decision Making
The system uses an orchestration layer to manage the process. This layer employs a fan-out pattern, sending events simultaneously to multiple specialized agents (e.g., Risk Analyzer Agent, Behavior Analyzer Agent). A final Verdict Agent then analyzes these responses to reach a consensus event.

Watch on YouTube Full article