Mozzie

What is Mozzie?

Mozzie is a local-first desktop app that orchestrates AI coding agents as a managed workforce. Instead of running a single agent session at a time, you describe what you want to build and Mozzie breaks the work into items, runs multiple agents in parallel, and coordinates their output through a git-based workflow.

The app is designed to keep work and orchestration on your machine. It creates isolated git worktrees per work item, manages dependencies between items, and provides a review flow so you can approve or reject changes before merging.

Key Features

• Local-first execution with offline workflow: Uses a local SQLite database and runs everything on your machine, including the agent execution workflow.
• Natural-language orchestration into work items: The orchestrator converts your request into work items, sets up execution order, and assigns agents.
• Parallel multi-agent support: Runs multiple coding agents concurrently, including built-in support for Claude Code, Gemini CLI, Codex CLI, and custom CLIs/scripts.
• Git worktree isolation per work item: Each work item is executed in its own worktree and branch, reducing conflicts between agent runs.
• Review + merge workflow: After an agent finishes, Mozzie provides a diff/review step; approve pushes to origin, while reject feeds feedback into the next attempt.
• Dependency graph with blocked-item auto-launch: Work items can depend on each other; blocked items auto-launch when dependencies complete, with cycle detection included.
• Sub-work-items (stacked branches) and parent/child merging: Child branches merge into a parent work item; the parent pushes to origin as one PR.
• Persistent conversations across sessions: Orchestrator context is preserved so you can pick up where you left off.
• Live streaming of agent output: You can watch agent output in real time, including tool-call activity visualization.

How to Use Mozzie

1. Install prerequisites: Use Node >= 20, pnpm >= 9, Rust (stable), and the platform-specific Tauri prerequisites. Ensure at least one AI coding agent CLI is installed.
2. Set up the app:
   • Clone the repository and install dependencies (pnpm install).
   • Start the development app (pnpm dev). The app will open.
3. Configure providers and agents:
   • In Open Settings (gear icon), add API keys for your LLM orchestrator provider (OpenAI, Anthropic, or Gemini).
   • Add agent configurations for the coding agents you want to run (e.g., Claude Code, Gemini CLI, Codex, or custom).
4. Create and run a work item:
   • Create a work item, point it at a repo, assign an agent, and start execution.
   • Alternatively, open the command bar (Ctrl+K), describe what you want built, and let the orchestrator create work items and queue them.
5. Review and merge:
   • When work items reach review, approve to push changes to origin.
   • Reject to provide feedback; Mozzie includes the full attempt history and your rejection reason in the agent’s next prompt.

Use Cases

• Split a feature request into multiple parallel coding tasks: Describe a larger change via the command bar; Mozzie breaks it into work items and runs supported agents concurrently to produce reviewable branches.
• Work on a repo while keeping agent outputs isolated: When experimenting with multiple approaches, each work item runs in its own git worktree and branch to prevent agent runs from stepping on each other.
• Handle multi-step dependencies (e.g., scaffolding then implementation): Create work items with dependencies so that blocked items auto-launch only after prerequisite items complete, with cycle detection to prevent circular plans.
• Iterate after failed attempts with structured feedback: Reject a work item during review and include feedback; Mozzie injects the full attempt history (including your rejection reason) into the next run to reduce repeating the same mistake.
• Manage multiple projects from one desktop app session: Use multi-workspace support to run and review work items across more than one repository within the same app.

FAQ

• Does Mozzie require a cloud connection to run? Mozzie is local-first and is described as working fully offline.

• Which AI coding agents can it run? The repository lists built-in support for Claude Code (via ACP/stdio transport), Gemini CLI, Codex CLI, and custom CLIs/scripts.

• How does Mozzie prevent conflicts between agents? It creates isolated git worktrees and branches per work item, so concurrent runs don’t share the same working directory.

• What happens if I reject a work item during review? Mozzie includes the full attempt history and your rejection reason in the agent’s next prompt, and the state can move from review back to a re-run path.

• Can work items depend on each other? Yes. Mozzie supports a dependency graph, auto-launches blocked items when dependencies complete, and includes cycle detection.

Alternatives

• Single-agent IDE tooling or chat-based coding assistants: Useful when you want one agent session at a time; they typically don’t provide the same work-item dependency orchestration and git worktree isolation.
• Local script runners that dispatch multiple tasks to CLIs: You can parallelize agent commands, but you would need to build orchestration, dependency management, and a review workflow yourself.
• CI/CD-based automation for code generation and PR review: Can handle review gates and branching, but it’s less oriented around an interactive local “one window” orchestration workflow.
• Workflow/orchestration tools for AI agents without local-first git worktrees: These may coordinate agent calls, but may not offer the specific git worktree isolation and stack-branch merge workflow described for Mozzie.