Agent architecture as event log + typed components — actors composed with Tardigrade and Effect

TL;DR

Arjun Kumar sketches an agent architecture where the append-only event log is the sole source of truth, and everything else — components, actors, tools, memory, compaction — is a pure projection over that log. Components are typed state machines (initial state + allowed transitions + output as either a view like a tool schema or a transition like a tool call / budget-exhaustion event). Actors are compositions of components that interface with the world through typed methods; component outputs are reconciled by a runtime called Tardigrade and requirements are composed by Effect. The thread argues Pi and DSH come closest in spirit but stop short of defining all agent behavior as f(log); taken all the way, this gives infinite lossless memory (via a tool that reads the agent’s own log) and makes user messages just another event class.

Key claims

State is a pure projection from the event log — every component’s current state is computed by folding the log through its transition function, not stored separately [tweet 1].
Components are typed state machines defined by (initial state, allowed transitions, output type), where output is either a view (e.g. tool schema visible to the model) or a transition (e.g. tool call, budget-exhaustion event) [tweet 1].
Actors are compositions of components with typed methods as the world-facing interface; a runtime called Tardigrade reconciles cross-component outputs and Effect composes their requirements [tweet 2].
Compaction is a component, not a harness feature: it tracks token count and emits a summarization effect when the threshold is reached, appending a Compacted event on success; the inference component projects a bounded transcript from the log using that event [tweet 3].
Recursive language models (RLMs) are a composition of a codemode component and a subagent component over a shared sandbox, with subagents as identical actors keeping their own logs and communicating via typed RPCs [tweet 4].
Infinite lossless memory is a small component — expose a tool that reads the agent’s own event log; because the log is the source of truth, memory becomes a retrieval-over-log problem rather than a separate storage subsystem [tweet 5].
User messages are just another event class, so the same substrate extends to arbitrary event kinds (webhooks, sensor readings, human interrupts) without harness changes [tweet 5].
Pi and DSH come closest to this design in spirit but don’t take it all the way — they don’t define all possible agent behavior as f(log) [tweet 6].

Method

The tweet illustrates the pattern with four diagrams (not reproduced here) covering the component definition, actor composition through Tardigrade + Effect, a worked compaction example, and the RLM composition. The load-bearing move is that agent state at any point is fold(log, transitions) — no separate state store, no memory summarization pipeline, no orchestrator that owns “what happened.” All non-determinism moves into typed effects (compaction, tool call, subagent spawn), which are themselves logged before execution and reconciled by the runtime after. This is the event-sourced / CQRS pattern from distributed systems, ported to agent design and given a typed component algebra on top.

Results

None reported — the thread is an architectural proposal, not an evaluation. The author explicitly frames it as a design sketch and points at Pi (Databricks’ agent harness) and DSH as the closest existing systems, saying they don’t commit to the full f(log) framing.

Why it’s interesting

Places the design on the same map as Agentic Context Management: Solving Agent Memory and Cost by Treating Them as Lifecycle and Architecture Problems‘s Agentic Context Management (ACM) lifecycle and Memory in the Age of AI Agents‘s Forms × Functions × Dynamics taxonomy, but from an implementation-first rather than survey angle — compaction, memory, and orchestration all reduce to typed components over one shared log. Complements Recursive Language Models by giving a concrete composition semantics for RLMs (codemode + subagent components over a shared sandbox with per-actor logs) rather than the paper’s high-level “LLM in a REPL” framing. Contrasts with Training-Free Group Relative Policy Optimization‘s learned experience library, which keeps the base model frozen and evolves a natural-language memory artifact: here the memory is the log, and no distillation into weights or prompts is needed. The f(log) commitment also gives deterministic replay and forkability for free — the same property The Log is the Agent (ActiveGraph) argues for as the key differentiator over retrieval-and-summarization memory. If the typed component algebra holds up under scale (many components, many effect types), this is the tightest formalization of the “everything is f(log)” position filed so far.