Make your own event-sourced agent harness using stream processors — Jonas Templestein, Iterate

Jonas Templestein from Iterate presents an experimental workshop on building event-sourced agent harnesses using stream processors, arguing that this architecture makes agents more debuggable, extensible, and composable than conventional approaches. The core abstraction consists of three primitives: state, a synchronous reducer function that derives state from events, and an after-append hook for side effects. The key design insight is splitting these two concerns — when a program restarts after 100 events have accumulated, it can replay state via the pure synchronous reducer without re-issuing LLM requests, then decide what actions to take based on the terminal state.

The workshop is built around a live service at events.iterate.com that provides append-only event streams accessible via HTTP and Server-Sent Events (SSE). Every occurrence in the agent loop — streaming chunks, tool calls, errors, circuit breaker triggers, even stream pauses — becomes a typed event in the log. Event types are namespaced as URLs (e.g., https://events.iterate.com/...) which double as documentation links. The service includes built-in primitives: idempotency keys, stream pausing via event append, circuit breakers (auto-pause after more than 100 events per second), heartbeat scheduling, push and pull subscriptions, and path-based namespacing analogous to a filesystem.

Templestein demonstrates stream processors in TypeScript using an NPM SDK he published the morning of the workshop. A processor exports an initial state, a synchronous reducer, and an after-append hook. For the LLM agent example using the OpenAI Responses API, the state type carries model name (e.g., GPT-5.4 as default), system prompt, and conversation history. The reducer translates incoming agent-input-added events (plain strings) into OpenAI's role/content format, accumulating history without side effects. The after-append hook fires after the reducer runs and is the only place that makes actual LLM or API calls.

The most novel capability demonstrated is the dynamic worker configured event: a special event whose payload is a JavaScript string containing a full stream processor. Appending this event to any stream causes it to immediately execute that processor — effectively deploying an AI agent without any server infrastructure, by simply POSTing a string to a URL. Templestein shows a minimal ping/pong processor deployed this way live. The broader implication is that processors from different authors on different servers can compose against the same stream, enabling polyglot, distributed agent systems where each component only needs HTTP.

Templestein argues strongly against before-hooks, citing performance regressions and broken context caching in agents like OpenCode as examples of the hazard. Instead, he advocates for eventual consistency: a safety-checker processor can inject additional context into an agent's event stream within a 200ms window before an LLM request, but the agent proceeds regardless if the checker doesn't make it in time. This design is presented as enabling commercial plugin or safety-as-a-service models — a third party could offer prompt injection protection as a processor that charges per invocation, integrating directly into the event stream without MCP or CLI authentication ceremony. The circuit breaker mechanism (also implemented as an internal stream processor with a reducer tracking event timestamps) illustrates that the same abstraction covers infrastructure-level concerns and application-level agent logic alike.