Local-first runtime trace layer

Replayable logs for AI agents.

Eventloom is a black box recorder for agent work. It captures goals, tasks, model calls, tool calls, decisions, verification, and handoffs as an immutable event log you can replay, inspect, and export.

Runs beside your agents Writes append-only JSONL Rebuilds state from events
Start logging locally Try the visualizer Agent integration guide
@eventloom/runtime @eventloom/mcp syndicalt/eventloom Documentation

Visualizer

Paste a log and get the same Capture, Replay, and Handoff views.

In this example a coding agent is fixing release checks. Eventloom runs beside it, records the operational facts, then turns the log into replay and handoff output another agent or human can inspect.

This runs entirely in your browser. Drop in an Eventloom JSONL log, paste the JSON output from eventloom visualize, or load the sample, and the visualizer projects the same story: what was captured, what replay rebuilt, and what a handoff should say next. Export the same log to Pathlight and those Capture, Replay, and Handoff views render directly on the trace detail page above the normal span waterfall.

Sample log loaded. Paste JSONL, upload a file, or paste visualize output.

sample.jsonl
Captured events Ordered facts from the log.

What it is

A durable work journal for agent systems.

Chat transcripts are useful for reading a conversation, but they are a weak source of truth for autonomous work. Eventloom records the operational facts around an agent run so you can answer what happened after the run is over.

What did the agent do?

Goals, task lifecycle, decisions, model calls, tool calls, and verification are typed events instead of loose prose.

Can we trust the history?

Every append is sealed into a hash chain, so replay can detect edits, truncation, or reordered history.

Can another agent resume?

Handoff summaries rebuild active tasks, completed work, evidence, observability gaps, and next actions from the log.

Why run it alongside agents?

Keep the agent stack you have. Add a replayable source of truth.

Eventloom does not replace your LLM provider, framework, editor, or observability tool. It sits next to them as a small local runtime and event journal. Agents and MCP clients append facts as they work; Eventloom verifies, replays, summarizes, and exports.

1 Agent works

Planner, coder, reviewer, or research actor takes a step.

2 Eventloom records

Typed events capture task state, tools, models, reasoning summaries, and evidence.

3 Replay explains

Projections rebuild current state, mailbox items, handoff summaries, and trace exports.

Debugging

Stop guessing from the final answer.

Trace the tool calls, model telemetry, verification commands, and decisions that led to a result. Export the same log to Pathlight for Capture, Replay, and Handoff panels beside the span waterfall, or to HALO for failure-mode analysis.

Replay

Rebuild state without rerunning the agent.

Deterministic projections rebuild tasks, research state, approvals, effects, and actor mailboxes from the immutable log. That makes handoffs and audits less dependent on a long conversational transcript.

Control

Validate intentions before state changes.

Eventloom's runtime pattern lets actors emit structured intentions. The orchestrator validates those intentions before appending accepted events, keeping workflow state explicit and inspectable.

How it works

Append facts. Replay projections. Export traces.

Agent step
append
Immutable JSONL
replay
Projected state
export
Pathlight / HALO

Install

Start with a local log file.

No hosted service, database, or daemon is required. Use the CLI directly or expose the same operations to agent clients through the MCP package.

CLI

npm install @eventloom/runtime
npx eventloom append .eventloom/agent-work.jsonl \
  goal.created --actor user \
  --payload '{"title":"Ship the feature"}'
npx eventloom visualize .eventloom/agent-work.jsonl

MCP

npx @eventloom/mcp --root .

# tools: append, replay, timeline,
# explain task, mailbox, handoff,
# visualize,
# built-in workflows, Pathlight, HALO

TypeScript

import { createRuntime } from "@eventloom/runtime";

const runtime = createRuntime(".eventloom/run.jsonl");
await runtime.runBuiltIn("software-work");
const visualizer = await runtime.visualize();

Observability

One journal, multiple inspection surfaces.

Keep the canonical record local, then export when useful. Eventloom can turn agent journals into Pathlight traces with native Eventloom visualizer panels, or HALO-compatible OpenTelemetry JSONL without mutating the original log. 

npm run eventloom -- run software-work /tmp/eventloom-pathlight-viz.jsonl
npm run eventloom -- export pathlight /tmp/eventloom-pathlight-viz.jsonl \
  --base-url http://localhost:4100 \
  --trace-name eventloom-pathlight-viz
Pathlight guide HALO guide User guide