Everything it does, one line each.

Inspecting what the model saw

• Open any finished turn's model transaction: system prompt, messages, tool schemas and output.
• Every transaction shows token use, cache reads and writes, stop reason and timing.
• Click the token count in the footer to open the round trip it came from.
• The System Prompt item shows the assembled prompt and every tool, grouped by source.
• Tools a strategy is withholding this turn are shown struck through, not hidden.
• Every item's properties show what it costs in tokens.
• Cache stats tell "the provider reported zero" apart from "the provider didn't say".
• A warning before you send says when the next request will miss the prompt cache, and why.
• Tool calls, arguments, approvals and results each open in a view of their own.
• Settings shows exactly what each strategy tells the model.
• System prompt presets: browse, save, delete, and pick a default.

Threads and sub-agents

• A conversation is a tree, navigated in Finder-style Miller columns.
• Branch a sub-thread from any point with /thread, or let the model open one.
• Sub-threads nest as deep as they need to, and can be resumed later.
• A thread returns only its result to the parent, not the whole excursion.
• Explore: a read-only sub-agent that investigates the codebase and reports back.
• Research: a sub-agent that reads the web and returns only the answer.
• Read-only sub-agents run in parallel, each with its own spinner and timer.
• Expand a thread back into its parent when the detail turns out to matter.
• Copy a thread, with the context it inherited, into a new conversation.
• The model can open new conversations of its own to fan work out.
• A token budget for each sub-agent run, and a spend ceiling for each conversation.
• Extensions can ship sub-agents of their own.

History, editing and undo

• Rewind a conversation to any message.
• Fork a new conversation from any message.
• Delete a single item, everything after a point, or everything before it.
• Re-run a tool command from its item.
• Undo and redo every structural change: ⌘Z, ⇧⌘Z.
• A delete or rewind offers Undo right where it happened.
• Closed conversations go to a Bin you can restore from, with its size on disk shown.
• /duplicate clones a conversation; /clear empties it.
• /compact folds the history into a summary thread you can still open.
• /handoff summarises the work into a fresh conversation, named for you.
• Copy a conversation as Markdown, or export it as a self-contained HTML page.

Approvals and strategies

• Four strategies, switched with ⇧⇥: Default, Auto-approve, Read-only and YOLO.
• Auto-approve has a cheap model wave through the obviously safe calls and ask you about the rest.
• Its reviewer can be balanced, relaxed, or follow a policy you write.
• Read-only refuses anything that could change a file.
• Even YOLO stops for plan approval and for questions it asks you.
• Shell commands are parsed, so only the parts that can change something ask first.
• Auto-approval follows cd, and copes with multi-line commands and quoted newlines.
• "Don't ask again" saves a rule as narrow as the command, editable before it's saved.
• Every saved rule is listed where it can be edited or removed.
• File edits can be allowed or asked about per conversation, with ⌘E.
• Writing outside the project always asks.
• Denying one call in a batch refuses the rest of it.
• Hooks can deny, hold or annotate any tool call, from a folder or from an extension.

Models and providers

• Claude Code: your Pro or Max plan, through your own unmodified claude CLI.
• OpenAI Codex: any ChatGPT plan, free included, via the Codex CLI or ChatGPT app login.
• GitHub Copilot: sign in with GitHub or reuse an editor's login; free plan and GitHub Enterprise Cloud work.
• API keys for Anthropic, OpenAI, Google Gemini, Mistral, DeepSeek, Moonshot Kimi and Z.AI GLM.
• OpenRouter, with its presets and free models, and OpenCode Zen.
• Local models with no key: Ollama, LM Studio, llama.cpp and LocalAI.
• Any number of custom OpenAI-compatible endpoints, each with its own URL, headers and models.
• ACP agents: drive external agents that speak the Agent Client Protocol.
• Switch model or provider mid-conversation, even mid-turn.
• Thinking levels per model, cycled with ⌥⌘T, including off where the model allows.
• Priority speed tiers on the models that offer one.
• Cycle recent models with ⌥⌘M; ⌥⇧⌘M opens the full picker.
• Hide models or whole providers you never use.
• Override any model's context window and maximum output.
• A cheap background model names tabs, reviews approvals and suggests prompts — or turn it off.
• First launch finds the agent CLIs you already have installed.
• A sidebar card shows your usage and quota.

Context management

• Every request is measured before it's sent, with room kept for the answer.
• Older history is compacted into a summary thread when it outgrows the window — nothing is thrown away.
• Automatic compaction can be switched off.
• A request that still won't fit is trimmed and retried, not failed.
• Tool results are sized to the model's window.
• An @-mentioned file is frozen as it was when you sent it.
• Large pastes collapse into pills instead of flooding the composer.
• CLAUDE.md, AGENTS.md, .cursorrules and similar files are read automatically.
• Project memory: durable facts the agent records in .juggler/MEMORY.md, private to the checkout.

Tools the agent has

• read, write and edit, plus batched reads and searches.
• grep and glob built on ripgrep, respecting nested .gitignore.
• bash, with long-running background tasks.
• Read, stop and stream background tasks; Monitor turns their output into events.
• Oversized command output spills to a file instead of the context.
• WebFetch reads a page, or asks a sub-agent one question about it.
• WebFetch returns an image URL as the image itself.
• WebSearch with no API key; Exa search is an optional extension.
• query_code: one sandboxed script in place of a dozen reads and greps.
• run_code: a script that calls tools, each approved as if called directly.
• Scripts can attach images to their results, so the model sees them.
• plan: an approach proposed for your sign-off, then tracked step by step.
• todo: a checklist the agent keeps as it works.
• AskUserQuestion: multiple-choice questions when it needs a decision.
• define_command: the agent can save a workflow as a slash command, with your approval.
• The agent can show you a report or mock-up by writing an HTML file and pinning it.
• Juggler can explain itself: the agent can read its own manual and SDK source.

MCP

• Local stdio servers, and remote servers over streamable HTTP or SSE.
• Configure per project, for every project, or in Settings.
• Live server status, logs and a Restart button.
• Allow or deny individual tools, and fix default arguments.
• Pre-approve a server you trust.
• Images from MCP tools reach the model.
• /mcp lists and controls servers from the composer.

Workspaces

• Git worktree: another branch, in a tree of its own, with a per-repo setup hook.
• Scratch copy: a throwaway copy to experiment in, git or not, applied back file by file.
• Subfolder: confine commands to one package of a monorepo.
• Group: a named box for related conversations, and nothing more.
• Workspaces show as boxes in the tab strip, with a dot for uncommitted work.
• Move a conversation by dragging its tab into another box.
• Finish a worktree by committing or discarding it, a copy by applying or deleting it.
• New kinds of workspace can come from extensions.

How workspaces work →

Many conversations at once

• Conversations in tabs, named automatically from what you asked.
• ⌘J jumps to the next conversation waiting on you.
• Tabs needing attention can highlight, or float to the top.
• Step through conversations with Page Up and Page Down; reorder them with Shift.
• Pause a turn with ⇧⎋ without cutting off a tool or a reply mid-flight.
• Choose what Escape does: stop, pause, ask first, need a double press, or only clear.
• Schedule a message for a set time, or for the end of the current turn.
• Suggested next prompts, and starter prompts in a new conversation.
• Chimes when a conversation needs you, in several voices, with volume and preview.

Pinboard and code review

• A Pinboard beside the conversation, toggled with ⌥⌘P.
• Pin a live file, the project tree, the plan, the todo list, project memory or running tasks.
• Pop a pinboard out into its own window or browser tab.
• The Git pin reviews every repository under the project, with branch and upstream drift.
• Review uncommitted, staged, unstaged, branch or last-commit changes — or any git diff range.
• Comment on lines of a diff, then send all the comments to the agent at once.
• Diffs side by side or unified, with as much context as you want, up to the whole file.
• Right-click any selection to put a reference to it in the prompt.
• Git status and task-progress cards in the sidebar.

Files and rendering

• Replies render Markdown, HTML and inline SVG as they stream.
• Syntax highlighting for many languages and build files.
• HTML files shown as the page they describe, in a sandbox, with the source a click away.
• PDFs page by page — and the model reads their text.
• Markdown preview for .md files.
• Images, HEIC and TIFF included, with pinch and scroll zoom.
• Video and audio play in place.
• Drop files into the conversation to show them to the model.
• New file viewers can come from extensions.

Clients and remote access

• A native desktop app, with no Electron.
• The same session in any browser, at the same time, kept in sync live.
• A touch layout for phones and tablets.
• Several windows at once with ⇧⌘N.
• A count of connected clients in the header.
• LAN access from Settings → Connectivity, with a QR code to scan.
• Local names such as mymac.local work.
• Works behind a reverse proxy such as tailscale serve.
• Remote viewers keep their own sound, Escape and diff settings.
• Sessions survive quits, relaunches and dropped connections — approvals included.
• Direct P2P: reach a session from anywhere over WebRTC. official
• Cloudflare Tunnel: reach a session through your own cloudflared. official

Extending it

• Every built-in tool, strategy and command is an extension on the public SDK.
• Extensions can add tools, strategies, slash commands, sidebar cards, pins, file viewers and workspace kinds.
• Extensions can declare settings and secrets, edited in the Extensions view.
• Every extension and every capability can be switched off individually.
• Extensions hot-reload when you save.
• juggler ext init scaffolds a working extension; validate, link and add do the rest.
• The SDK and bundled extensions are Apache-2.0, so yours can be closed source.
• Custom slash commands are markdown files, no code — in Claude Code's format.
• Commands can send, insert a draft, or run in their own sub-thread with their own model.
• Agent Skills, including those in .agents/skills, loaded only when a task needs one.
• A skills marketplace installs skills from GitHub; type $ to use one by hand.

Writing an extension →

Interface

• Find with ⌘F in the conversation, the Pinboard or a properties view.
• Zoom and font size, remembered per project.
• Light, dark, or following the system.
• Collapse runs of tool calls into one group with ⌥⌘G.
• Move through items with ⌥↑ and ⌥↓ without leaving the message box.
• Every shortcut listed with ⌘/.
• Drafts are kept if you switch away mid-sentence.
• Tips in new conversations, for the features you haven't found yet.
• Proxy settings: system, direct or manual.
• Logs viewable inside the app.

Install and run

• macOS 14+ on Apple Silicon, signed and notarized.
• Homebrew: brew install --cask juggler-ai/tap/juggler.
• Windows x64 installer, per-user, putting juggler on your PATH; runs on ARM under emulation.
• Linux x64 and arm64.
• Headless on a Linux server, no display needed, with a Docker recipe.
• juggler doctor checks a machine is ready to run it.
• juggler run "…" runs one prompt unattended, for CI, and exits with a status.
• Build it yourself from the public source, Intel Macs included.
• In-app updates on macOS and Windows. official

Your data

• Model requests go straight from your machine to the provider you chose.
• No Juggler account, and no cloud index of your code.
• Conversations are files in the project's .juggler folder.
• API keys live in one owner-only file in ~/.juggler.
• ~/.juggler is plain files: copy it to a new machine and you're set up.
• A locked or interrupted session is recovered, not lost.
• The whole app is open source, so none of this has to be taken on trust.