Juggler
A visual AI coding agent workbench for people who want hands-on control over what the LLM does to their codebase.
Trust: SECURITY.md documents a concrete trust model — loopback-only by default, explicit opt-in LAN exposure with no auth, remote traffic admitted as viewers only, UI approval required for shell/file-write tools — and honestly discloses weaknesses (@-mention out-of-project reads, non-security shell filter, credentials visible to agent tools). The approval flow and opt-in exposure support user_confirmation=3; but unauthenticated LAN mode, full-user-privilege subprocesses, and plaintext credential visibility in agent reach warrant deductions on sensitive_data_handling and rollback (partial evidence only).
Reliability: README, SECURITY.md, go.mod, and CI are mutually consistent (localhost default, approvals persist as document state, make test needs no API keys), and CI runs cross-platform builds with -race tests — supporting self_consistency and dependency_availability=2. Failure-message quality has no direct evidence in the provided files, scored 1.
Adaptability: README clearly targets hands-on developers wanting control over LLM behavior; local/remote/multi-client deployment and per-platform build prerequisites are concretely documented, audience_and_scenarios=3. Capability boundaries are stated but partly deferred to external docs; trigger precision (@-mention, approval granularity) described at docs level only — both scored 2.
Convention: Documentation is well organized (README/SECURITY/CONTRIBUTING/LICENSING, per-platform install steps) with a clear dual-license split (AGPL-3.0 app, Apache-2.0 SDK) — license=3, information_architecture=3, install_notes=3. No CHANGELOG or versioning policy is present; a single maintainer with 'only main is supported, no LTS'; examples/FAQ are thin — deductions to 1–2.
Effectiveness: The editable session tree, inspectable tool calls, and persisted approvals offer clear differentiated value for hands-on users, marginal_value=2. Output usability and cost/benefit are only inferable from design claims in static review; scored 2.
Verifiability: README claims are cross-corroborated in SECURITY.md and CI configuration (Origin check, LAN gate, least-privilege workflow permissions, commit-pinned CLA action), claim_traceability and corroboration=2. Fact/inference separation is good (e.g., explicitly stating the shell filter is not a security control), but line-level code verification was not possible, so no full marks.
- LAN mode has no authentication: anyone who learns the URL or scans the QR code can drive the agent; enable only on trusted networks.
- Agent shell commands run with your full user privileges and can read ~/.juggler/credentials. and environment credentials; the 'foot-gun filter' is not a security control.
- An @-mention can steer the LLM to read arbitrary files outside the project directory (audited, but by design) — beware prompt injection.
- Publisher identity is unverified and the project is a single-maintainer effort supporting only main with no LTS; dependency and security fix cadence is not guaranteed.
- This is a static review; no execution was performed and runtime behavior/test quality were not independently verified.
What does this agent do, and when should you use it?
Juggler is an open-source AI coding agent written in Go, built around a GUI rather than a terminal. It ships as two parts — a native desktop app and a headless command-line server (`juggler`) — distributed together, with the server exposing a local web session that desktop apps and browsers attach to as clients. A session is an editable Yjs document tree, not a linear transcript: you can branch sub-threads, backtrack, and even restore a paused approval dialog after a restart. Everything is laid out in Finder-style Miller columns — tool calls, item properties, raw context, the system prompt — for inspection. Nearly everything (context items, slash commands, LLM loop strategies, even the read/write/bash tools) is a JavaScript extension you can inspect, fork, or replace, and MCP servers plug into the same model. It connects to Claude Code, OpenAI/Codex, GitHub Copilot, Gemini, Mistral, Z.ai, Ollama, OpenRouter, Deepseek, and more.
Running juggler starts a local (localhost-only by default) server that prints a browser URL and QR code; pressing p or launching with --public opens LAN access. The agent reads and edits files and runs commands through JavaScript-extension-defined tools (read-file, replace-text, bash, etc.); every tool call becomes an inspectable, approvable item in the session document. Sessions persist as Yjs documents on disk and branch into sub-threads; clicking the footer's token count shows what a past turn actually sent, and selecting System Prompt shows exactly what the model is told and which tools it can call. MCP server tools arrive as context items indistinguishable from built-ins, configured via Juggler's own config per docs/mcp.md. The desktop app, browser tabs, and even a phone browser can attach to the same session and stay in sync.
- Developers who want a GUI to inspect every tool call and the raw context, rather than scrolling through terminal output, while an agent edits their codebase
- Engineers running long-lived sessions: quit, lose connection, or come back tomorrow, and the agent is still parked at the same approval point, ready to resume
- Remote workflows where the agent runs on the machine where the code lives (dev box, build server) while you view progress from a browser or another machine
- Plugin authors who want to build custom UIs, slash commands, or LLM loop strategies for agentic workflows — including closed-source extensions, since the SDK is Apache-2.0
- Users with existing Claude Code, Codex, or Copilot subscriptions who want to reuse what they already pay for, or plug in their own API keys
- Ops running headless sessions on servers, containers, or CI machines with no display (see docs/headless-linux.md)
What are this agent's strengths and limitations?
- A genuine GUI with Miller-column navigation of tool calls, item properties, and nested sub-threads — visual inspection instead of terminal text dumps
- The session is an editable Yjs document tree, not a linear transcript, and even paused approval states survive restarts and reconnections
- Almost everything is a JavaScript extension you can inspect, fork, or replace, including read/write/bash basics; the extension SDK is Apache-2.0, allowing closed-source extensions
- Multi-client architecture: desktop app, browsers, and phones can attach to and stay in sync with the same session, and the server can run remotely where the code lives
- No Node, Electron, or npm dependencies — Go compiles binaries with HTML/JS embedded, and the frontend ships with no build step
- The project is very new and maintained by one person; the README itself describes ongoing churn and stability fixes, so maturity and long-term support are uncertain
- Builds from this repository are local + LAN only — WAN access modes exist only in the official binaries and are not in this repo (see LICENSING.md)
- LAN access has no password: anyone who can reach the address can drive the agent, so it is restricted to trusted networks
- Linux builds require cgo linking against GTK4 and WebKitGTK dev packages; Windows builds require Git Bash with GNU make, and WSL2 produces Linux binaries rather than native .exe files
- The frontend is type-checked JavaScript with JSDoc rather than TypeScript, and CI publishes no artifacts, so you depend on source builds or the official release pipeline
How do you install or deploy this agent?
Download a build from the GitHub Releases page or juggler.studio. macOS: open the .dmg, drag Juggler to Applications (Gatekeeper may block first launch — right-click → Open, or allow in System Settings → Privacy & Security). Windows: run Juggler-<version>-setup.exe, which installs the desktop app and juggler.exe together. Linux: download the juggler server binary and run it from a terminal, then connect with a browser or the desktop app; see docs/headless-linux.md for display-less hosts. Building from source requires Go 1.26+: git clone --recurse-submodules https://github.com/juggler-ai/juggler.git && cd juggler && make go-build. Linux additionally needs sudo apt-get install -y libgtk-4-dev libwebkitgtk-6.0-dev libsoup-3.0-dev; Windows builds require Git Bash with GNU make.
How do you use this agent?
Run juggler in a terminal — it opens the web UI and prints the connection URL plus a QR code. It is localhost-only by default; press p in the terminal or launch with --public for LAN access (no password, so only on trusted networks). Launch the desktop app (open bin/Juggler.app, ./bin/juggler-app, or bin/juggler-app.exe on Windows), or type w into the server terminal to open it. Configure model providers (Claude Code CLI/API, OpenAI Codex plan/API, etc.) and MCP servers through Juggler's own config — it does not read other agents' configuration. Start a coding task; sessions persist on disk, so any client can disconnect and reconnect later, resuming even paused approval states.
How does this agent compare with similar options?
The README self-describes Juggler as 'another AI coding agent' and contrasts itself with terminal-based agents offering linear transcripts: its differentiators are the visual Miller-column workbench, the editable tree-structured session document, and a fully plugin-based architecture rather than headless terminal scripts.