Originally published on andrew.ooo — visit the original for any updates, code snippets that aged out, or follow-up posts.
Most AI coding agents live in your terminal. You type, they scroll, and the conversation becomes an endless log you can barely navigate. Juggler is a bet that this is the wrong shape for the problem — and it comes from someone with a 30-year track record of making tools developers actually enjoy using.
Juggler is an open-source GUI coding agent from Julian Storer, the creator of JUCE (the standard C++ framework for audio plugins), the Tracktion DAW, and the Cmajor DSP language. It launched on Hacker News in mid-July 2026 and hit 280 points — a strong signal for a one-person side project. This review covers what makes Juggler architecturally different, real community reactions, honest limitations, and whether it's worth installing today.
TL;DR
Product: Juggler
Creator: Julian Storer (JUCE, Tracktion, Cmajor)
Type: GUI coding agent (desktop + browser + headless server)
License: AGPLv3 (app) / Apache-2.0 (extensions SDK + core extensions)
Stack: Go backend, Wails windowing, plain type-checked JS, Yjs CRDT
Models: Claude (CLI/API), OpenAI/Codex, Gemini, Ollama, OpenRouter, Z.AI, DeepSeek
Signup: None. No telemetry. BYOK.
Status: Alpha/beta — one-man project, ~6 months of work
Platforms: macOS, Windows, Linux (headless)
Website: https://juggler.studio
What it is: A visual workbench for AI coding agents where the conversation is an editable tree, not a chat log, and every tool call, approval, and raw context message is inspectable.
Best for: Developers who want tight, hands-on control over what the model does to their codebase — and who find terminal UX painful for scanning and editing large chunks of text.
Why a GUI Coding Agent?
The pitch is refreshingly honest. Here's Storer's own framing from the launch:
"It's pretty clear that the rest of my coding career will involve staring at some kind of code-agent tool all day, so I decided to have a stab at making one that feels right to me. I may be arriving at the AI agent party after all the booze has been drunk, but maybe there's still some fun to be had."
His annoyances were specific: the UX and the data model under the hood. Using a code agent involves editing big blocks of multi-line text and getting hosed with information you need to scan and understand fast. Storer finds a terminal miserable for those tasks, so Juggler is "resolutely a GUI app."
That's a contrarian position in 2026. The dominant agents — Claude Code, Codex, OpenCode, Pi — are all terminal-first. Juggler argues the terminal is an accident of history, not a good fit for reading branching agent output.
What Makes Juggler Different
1. The session is a tree, not a doom-scroll
This is the headline feature. Most agents give you a single linear transcript; if you're lucky, you can rewind it. Juggler gives you a tree. Any point in the conversation can branch into a sub-thread, and sub-threads can branch again, recursively.
Under the hood, each session is a Yjs CRDT document, not a log file. You can navigate, drill down, backtrack, duplicate, delete, undo/redo, and re-open or branch threads directly. The UI uses Miller columns — the Finder-style column view where the root sits on the left and selected items expand into properties and children on the right.
If you've ever wanted to explore two different approaches from the same starting context without polluting one conversation with the other, this is the model that makes it natural.
2. Everything is inspectable
Tool calls, approvals, thread structure, item properties, and even the raw context JSON going to the model — all of it is part of the document and laid out for fast navigation. For anyone who has squinted at an agent wondering what exactly did it just send to the model?, this is a genuine debugging superpower.
3. The session is a persistent state-machine
A session lives in a database on disk, not in memory. Quit the app, relaunch the server, lose and regain a connection — everything resumes exactly where it was. Crucially, that includes state that's waiting on you:
"When the agent pauses for user intervention — to run a command, apply an edit, take the next step — that paused state is part of the document. You can shut everything down, reopen it later on the same machine or a different one, and the agent is still parked at the same decision, ready to resume the moment you say yes."
Approval dialogs survive restarts and follow you across devices. That's rare.
4. Everything is an extension
The core app manages the document and orchestration; almost everything else is a JavaScript plugin:
-
Context items — every item type (
read-file,replace-text,bash, …) controls both how it talks to the LLM and how it renders in the UI. -
Strategies — high-level LLM loops like
plan,research, or your own inventions. -
Commands — slash commands like
/clearand/compactare plugins that manipulate the session document.
Even the basic read/write/bash tools are plugins you can inspect, fork, or replace. The extension SDK and bundled extensions are Apache-2.0, so extensions carry no copyleft strings even though the app itself is AGPLv3.
5. Local, remote, or both at once
Juggler looks like a native desktop app, but underneath it's a local web server serving a live collaborative session. The desktop app is just one client. A browser tab — on the same machine or a remote one — can be another. Run a headless juggler server on the box where your code lives, then drive it from your laptop, or even your phone.
Getting Started
Downloads come from the Releases page or juggler.studio. Every download bundles two parts that ship as one unit so they never drift:
- Juggler app — the native desktop client.
-
juggler— the headless command-line server for long-lived, remote, or network-accessible sessions.
macOS: download the .dmg, drag to Applications, launch. First launch may trip Gatekeeper — right-click → Open → Open.
Windows: run Juggler-<version>-setup.exe; it installs the app and matching juggler.exe server together and can add juggler to your PATH.
Linux: grab the juggler server binary and connect from a browser or the desktop app.
For a headless session, just run:
juggler # prints everything you need to connect from a browser
By default it opens a web UI and prints a URL plus a QR code for quick phone connection. The server is localhost-only by default — nothing off your machine can reach it. To expose it on your LAN, press p in the terminal (or launch with --public):
juggler --public
⚠️ LAN access has no password. Anyone who can reach the address can drive the agent, so only enable it on trusted networks. WAN access is not built into the open-source repo — the official binaries add remote-access modes as a paid component.
Provider Support (BYOK)
Juggler is model-independent and bring-your-own-key. Supported providers:
- Claude — via the Claude Code CLI or the API
- OpenAI / Codex — via the codex plan or API
- Gemini
- Ollama — for local models
- OpenRouter, Z.AI, DeepSeek, and more
No signup, no telemetry. It's just an app.
Community Reactions
The HN thread was warm, which is notable for a "yet another coding agent" launch. A few representative takes:
The pedigree lands. One commenter captured why this project got attention:
"It's so cool to see you on HN creating this. JUCE is the standard for cross-platform music plugin development and needs to work efficiently in hard realtime settings... someone like you picking up the desire to build an agentic platform really piques my interest."
That user, currently on OpenCode at work, called out exactly the pain Juggler targets: the "doom scroll" experience and the wish for "a tree like experience as well as a more UI forward experience." Their wishlist for Juggler — worktree support, sandboxing, skills/subagent handling, rich tool-call embeds, web UI for non-technical teammates, and long-horizon efficiency (they routinely hit 200k–400k-token sessions) — is a good map of where GUI agents need to go.
The UI clicks immediately. A user who installed it on macOS reported: "UI is clean. Could install on Mac. Adding context files at the top is clean. It worked." Storer's response is telling about his priorities:
"Hearing 'the UI is clean' is exactly the reaction I've been hoping for. While I've put huge effort into architecture and the extension API, it's really trying to build a lovely UI/UX that has been my motivation."
Built the anti-JUCE way. Asked whether he used JUCE to build it, Storer said no: "This is pretty much the anti-JUCE! There's no C++ in it, it's all Go/JavaScript, and all the UIs are HTML." And on how it was written:
"I must have authored literally a million lines of C++ over my career... but in this one I wrote almost zero lines by hand! Surprisingly, I've really enjoyed the experience."
A veteran systems programmer building a coding agent almost entirely with coding agents is a nice piece of 2026 symmetry.
Honest Limitations
Juggler is genuinely promising, but be clear-eyed:
- It's alpha/beta. Storer says so plainly — about six months of heavy churn, and the app "will need to do some growing-up out in the real world." Don't expect Claude Code's polish or ecosystem yet.
- One-man side project. No trillion-dollar-company release cadence, no big team fixing your edge case overnight. Support is a Discord and the maintainer's goodwill.
- Real bug reports exist. One tester hit a system reboot tied to unplugging/replugging a USB-C hub with an external monitor — a rough edge that points to the young Wails/windowing layer.
- Missing table-stakes features (for now). Worktree support, sandboxing, and skills/subagents are on the TODO list, not shipped. If you rely on isolated worktrees or sandboxed execution today, you'll feel the gap.
- No hosted WAN access in the open repo. Cross-internet remote access is a paid component; the OSS build is local + LAN only.
- Business model is "release it and see." There may eventually be a paid "pro" tier. That's honest, but it means the roadmap isn't guaranteed.
Who Should Try Juggler?
Try it if you:
- Find terminal agents painful to scan and navigate, and want a real GUI.
- Want to explore multiple approaches from one context via branching threads.
- Care about seeing the raw context and tool calls, not trusting a black box.
- Like extensible, model-independent tools (OpenCode/Pi people, this is aimed at you).
- Want a headless server on your dev box that you can reach from a browser or phone.
Wait if you:
- Need production stability today.
- Depend on worktrees, sandboxing, or subagents right now.
- Want a large ecosystem and vendor-backed support.
FAQ
Is Juggler free and open-source?
Yes. The main app is AGPLv3; the extension SDK and bundled core extensions are Apache-2.0, so extensions have no copyleft obligations. There's no signup and no telemetry. You bring your own model API keys.
What models does Juggler support?
Claude (via the Claude Code CLI or API), OpenAI/Codex, Gemini, Ollama (local models), OpenRouter, Z.AI, and DeepSeek, with more expected as users request them.
How is Juggler different from Claude Code or OpenCode?
Those are terminal-first with linear transcripts. Juggler is a GUI where the session is an editable, branching tree stored as a Yjs CRDT document. Every tool call, approval, and raw context message is inspectable, sessions persist across restarts (including pending approvals), and almost everything is a swappable JavaScript plugin.
Can I run Juggler on a remote server?
Yes. The juggler headless server runs where your code lives and prints a URL and QR code to connect from a browser or the desktop app. It's localhost-only by default; --public exposes it to your LAN (no password — trusted networks only). Cross-internet WAN access is a paid feature not in the open-source repo.
Is Juggler production-ready?
Not yet. It's an alpha/beta one-person project with roughly six months of development. It's very usable for hands-on exploration, but expect rough edges and missing features like worktrees and sandboxing.
Who made Juggler?
Julian Storer, a 30-year C++ veteran best known for creating JUCE (the dominant audio-plugin framework), the Tracktion DAW, and the Cmajor DSP language.
The Bottom Line
Juggler isn't trying to out-feature Claude Code or OpenCode. It's making a focused argument: agent conversations are trees, not scrolls, and you should be able to see and edit everything the model touches. Coming from the person who built JUCE, that opinion carries weight — and the early UX reactions suggest he's onto something.
It's alpha, it's a side project, and it's missing sandboxing and worktrees. But if you've ever felt boxed in by a terminal agent's linear log, Juggler is the most interesting alternative shape to appear in a while. At zero cost and zero signup, kicking the tires is easy.
Links: GitHub · juggler.studio
Sources
- Juggler on GitHub — README, licensing, install docs
- juggler.studio — official site and feature overview
- Show HN: Juggler — launch thread (280 points) and maintainer Q&A
- Julian Storer on GitHub — creator profile (JUCE, Tracktion, Cmajor)
- JUCE framework — Storer's best-known project, for context
Top comments (0)