Your Sessions, Illustrated

Turn a JSONL log into a comic book

The setup

Amplifier's best work happens in a session — then gets buried in a log no human will read

Inside an Amplifier session, agents research, storyboard, design characters, and iterate their way to a result. Then that whole run is left behind as a raw JSONL event log.

And that log is bigger than it sounds.

The work is realAgents research, storyboard, and iterate to a result inside the session.

The record is rawA session is captured as an events.jsonl log — a stream nobody re-opens.

The problem, measured

One real session behind an example comic was a 123 MB JSONL log

The Sin City example was generated from a 123 MB combined-sessions.jsonl. Too big to read, too big to share — the research was stored as an asset and passed downstream as just a ~70-byte URI.

So how do you turn something that big into something anyone can open?

123 MB

combined-sessions.jsonl behind the Sin City example

~70 B

URI passed downstream instead of the raw log

The tool

The Comic Strips bundle takes one input — a session's events.jsonl — and outputs a comic

comic-strips 1.0.0 runs the session-to-comic recipe (v9.0.0). You point it at a session file; it hands back a comic. Everything else in this deck is how that one step works.

Under the hood, it's a pipeline.

# session-to-comic recipe (v9.0.0)
session_file: events.jsonl   # Required

# in → a session's event log
# out → a comic book

How it works

A thin orchestrator chains three sub-recipes, driven by six specialist agents

session-to-comic is a thin orchestrator (refactored from an 853-line monolith). It plans the saga, designs the characters, then generates the pages — each step its own composable recipe.

One step matters most: keeping the characters consistent.

1

saga-plan — write a dramatized storyboard from the session

2

design-characters — generate the cast reference sheets

3

generate-issues — produce the panel and cover art

The coherence trick

Generated character reference sheets keep the same faces across every panel

The character-designer agent runs create_character_ref to generate and store a reference sheet per character. Every panel is drawn against it — so the output reads as one coherent story, not disconnected images.

And all of it ships as a single file.

create_character_refGenerates + stores a reference sheet for each character.

Panels drawn to matchEvery panel references the sheet, so faces stay consistent.

One coherent storyThe result reads as a comic, not a pile of unrelated pictures.

The pivot

Everything collapses into one self-contained HTML file — open it in any browser, offline

The renderer produces a self-contained HTML page with base64-embedded images and errors if none are present. Example files run 3.1 MB to 20.4 MB — no server, works offline.

The unreadable log is now a single artifact anyone can open.

1 file

self-contained HTML, base64-embedded art

3–20 MB

example comics (3.1 MB watchmen → 20.4 MB sin-city)

0

servers needed — opens offline in any browser

The payoff

The engine drew its own origin story

The Sin City example dramatizes the actual sessions that built the comic-strips bundle. The 3-issue Transformers: The Forge Saga chronicles the creation of the comic engine itself — 24 panels across 9 story pages.

Proof the tool works: it ships as its own portfolio.

Sin CityA noir comic dramatizing the actual Amplifier sessions that built the bundle.

Transformers: The Forge SagaA 3-issue saga — 24 panels across 9 story pages — chronicling the comic engine itself.

What you keep

Point the recipe at any session and walk away with a shareable comic instead of a dead log

The pattern is repeatable and the engine is proven end-to-end: 8 shipped example comics, 80 test files, 1,115 test functions, 283 commits since February 2026.

STATUS: WORKING END-TO-END

8

shipped example comics (self-contained HTML)

1,115

test functions across 80 test files

283

commits since Feb 2026

Sources

Sources & Research Methodology

Primary source: colombod/amplifier-bundle-comic-strips (bundle: comic-strips, version 1.0.0), local checkout at commit c1a1e9c.

Feature status: Working end-to-end. tool-comic-image-gen is a temporary bridge (Issue #90) until Amplifier providers support image output natively.

Commands run:

head bundle.md — name: comic-strips, version 1.0.0
grep -n 'session_file' README.md — Required param: Path to events.jsonl
sed -n '50,60p' examples/README.md — 123 MB combined-sessions.jsonl; ~70-byte URI
cat recipes/session-to-comic.yaml — v9.0.0; 3 sub-recipes; thin orchestrator (from 853-line monolith)
grep -n 'create_character_ref' modules/.../__init__.py; ls agents/ — 6 agent files
grep -n 'self-contained\|data:image' html_renderer.py; base64 counts per example HTML (3.1–20.4 MB)
find . -name 'test_*.py' | wc -l; grep -rh 'def test_' | wc -l — 80 files / 1,115 tests
git rev-list --count HEAD — 283 commits; first 2026-02-27, latest 2026-05-20
git shortlog -sne --all — contributors

Primary contributors: Diego Colombo (281 commits), Brian Krabach (1), Marc Goodner (1).

Gaps: Panel counts (e.g. 24 panels / 9 pages) are cited from README, not independently re-counted from HTML. Commit/contributor totals are for the local checkout at c1a1e9c; upstream may have advanced.