RepoToon

What it does

RepoToon is an autonomous webtoon studio that runs on Guild.ai. The moment you publish a GitHub release, it springs to life and ships a comic episode:

• A release webhook fires the release-arc agent (--event release --action published).
• The agent reads the changelog and dramatizes it into a story: fix: entries become monsters that Rune the patch-knight defeats, feat: entries become new allies joining the party, BREAKING CHANGEs become full-width boss battles that spell out exactly what broke and what to do instead, and perf: entries become training montages. chore:/docs:/ci: noise is skipped.
• It draws the panels itself as inline SVG — no image models, no external assets — and assembles a self-contained HTML episode.
• It publishes autonomously, committing the episode to docs/episodes/.html via the GitHub contents API, where GitHub Pages serves it as the next chapter in an ongoing series.

Every panel cites its source changelog entries verbatim, with links back to the real PRs — so it's a comic that's also an honest, traceable release log.

How we built it

• Guild.ai agents SDK — a single one-shot llmAgent (agent.ts) does the whole pipeline in one session: parse → write script → draw SVG → publish.
• Trigger — a GitHub release.published webhook integration wired straight into the agent.
• Tools — three gitHubTools (get_release_by_tag, get_content, create_or_update_file_contents); the agent base64-encodes its HTML and commits in exactly one call.
• Rendering — hand-authored SVG primitives (circles, rects, one or two polylines per panel) and a tiny shared CSS skeleton, so episodes render instantly in any browser.
• Hosting — GitHub Pages, with a hub page that orders episodes by commit date (newest first).
• Demo content is real Composio release notes, dramatized end-to-end.

Challenges we ran into

• Output truncation. The biggest fight was the model running out of output budget mid-episode. We had to make the agent ruthlessly compact — a hard ~2,800-character budget for the entire HTML file, at most ~6 shapes per panel — to guarantee complete, valid episodes every time.
• ASCII-safe everything. Stray middots and non-ASCII separators broke encoding, so we forced plain-ASCII punctuation throughout.
• Base64 commit discipline. The GitHub contents API wants base64; we had to prompt the agent to encode once and commit once — no re-reading its own output, no second-guessing — or it would loop.
• Constrained runtime. The agent sandbox only allows @guildai/agents-sdk + zod, so no image libraries — drawing had to be pure inline SVG.
• Messy changelogs. Real notes mix conventional-commit bullets with GitHub's auto-generated * fix(...): ... by @author in lines; the parser handles both.

Accomplishments that we're proud of

• A fully autonomous loop — release → comic on a live URL — with no human touching it after the publish click.
• An agent that draws, not just writes: it composes original SVG art from a recurring cast.
• Traceability as a feature — every dramatized panel is grounded in a verbatim changelog entry with a link to the real PR, so it never hallucinates changes.
• Built in a ~3-hour sprint, end-to-end, deployed and demoable.

What we learned

• Tight output budgets are a design constraint, not a bug — forcing compactness made episodes more reliable and more readable.
• Giving an agent a strict skeleton to fill (fixed HTML/CSS, fixed panel count, fixed character vocabulary) beats letting it freestyle when you need deterministic, shippable output.
• Webhooks + a one-shot agent + a Git-backed host is a shockingly powerful pattern: the entire studio is stateless and the repo is the archive.

What's next for RepoToon

• Continuity — recurring villains, story arcs across releases, and callbacks to past episodes.
• Richer art — a panel renderer that can vary layouts and character poses while staying within budget.
• Beyond releases — toon merged PRs, sprint recaps, or incident postmortems.
• Reader-facing series — an RSS feed and auto-posting so a repo's followers get each new chapter pushed to them.
• Self-serve install — drop RepoToon onto any repo with one webhook and watch its history start drawing itself.

Built With

• ai
• githubactions
• guildai
• svg