Local-first desktop cockpit · for Claude Code & Codex

Your AI agent zoo. One cockpit.

Zoogentic turns the coding CLIs you already run (Claude Code and Codex) into a multi-agent workspace. Spin up agents per project, watch them in a clean chat or the real terminal, and chain them into teams that hand work off to each other. Every process, every byte, on your machine.

Download for Windows
See how it works

Free while in beta · macOS (Apple Silicon) & Windows (x64) · no account, ever

Fits the stack you already run

Claude CodeCodexOpusSonnetHaikuMCP serversClaude Code pluginsGit worktreesJiraSentryPostHogExcalidrawSQLitePTY · ConPTYTauri 2Claude CodeCodexOpusSonnetHaikuMCP serversClaude Code pluginsGit worktreesJiraSentryPostHogExcalidrawSQLitePTY · ConPTYTauri 2
The cockpit

Everything you need to run
a menagerie of agents.

Pick a capability to see exactly what it does, and what it looks like in the app. Every agent gets its own chat, terminal, worktree, and role.

Run the whole menagerie

Spin up many agents ("Critters") at once, each with its own role, model, account, and resumable session.

  • Chat mode: a streaming transcript with thinking, tool calls, and question cards
  • Terminal mode: the real interactive Claude / Codex CLI in a persistent PTY
  • Pick a mode per agent; resilient streaming keeps building when you switch away
  • Pixel-animal companions and a floating status Notch so agents stay legible

How the magic actually works

No black box. Zoogentic drives the real CLIs: you just get the controls, the visibility, and the coordination on top.

Chat & Terminal mode

Two ways to work with every agent

When you open an agent, you choose how to see it: a clean chat rendered from its stream-json transcript, or the raw interactive CLI in a real terminal. Switch any time; histories stay separate.

  • Chat mode
    Streaming text and thinking, tool-call lines, and inline question cards: organized bubbles, not a wall of logs.
  • Terminal mode
    The genuine `claude` / `codex` CLI over a persistent PTY, with full control when chat isn’t enough.
  • Never loses its place
    Switch agents or projects mid-run; output keeps streaming in the background.
Claw & QA

Agents that work while you sleep

Beyond reactive chat agents, Zoogentic runs guardians. Claw is a persistent, fully-local agent that wakes on a heartbeat, remembers across sessions, and grows its own skills. QA is a specialised guardian that tests your running app.

  • A global Claw + per-project Claws
    Layered memory and cross-project recall, with a read-only-propose default you can loosen.
  • Nightly learning passes
    Claw distills what it saw into CLAUDE.md rules, memory, and reusable skills, all as approvable diffs.
  • QA that files tickets
    It drives your app in an embedded browser, catches regressions, and opens Jira or backlog findings with screenshots.
Precision controls

Dial in effort, permissions, and role

Mirror the real CLI flags without memorising them. Set how hard an agent thinks, how much autonomy it gets, and which discipline it plays, all per agent, applied on the next turn.

  • Effort Low → Max, plus Ultracode
    Cheap mechanical edits or deep reasoning, and Ultracode for orchestrated crews.
  • Plan / Accept Edits / Bypass
    Grant exactly as much rope as a task deserves, and change it mid-flight.
  • 20+ role prompts
    Architect, security, QA, DevOps and more, each layered on shared house-rules.
Packs & Subagents

Orchestrate a crew, not a single bot

Assemble a Pack on a visual canvas (a lead that spawns teammates over a shared task list), or type “ultracode” and let Claude Code author the workflow. Every subagent stays visible in real time.

  • Visual team builder
    Wire Start → Agent → Done nodes with handoff policies and feedback loops.
  • Automatic handoff
    Pipeline members pass context-rich, junior-readable summaries to the next.
  • Live subagents
    Running/done badges, elapsed time, and tool counts; click any one for its full transcript.
20+ role prompts

One tool. A whole team of specialists.

Give each agent a discipline and it inherits a tailored system prompt layered on shared house-rules, so a security review reads differently from a UI polish pass.

Architect
Full-Stack
Frontend
Backend
Mobile
DevOps
SRE
QA
Security
Data
Database
ML
Performance
Reviewer
Designer
A11y
Tech Writer
Product
Marketing
SEO
i18n
Git Expert
Brainstormer
0+
agent role prompts
0
CLIs, side by side
0
cloud · telemetry · accounts
1
local SQLite database

Everything in the cockpit.

The full menagerie: from Critters and Packs to Claw, QA, Schedules, Rewind, worktrees, prompts, skills, MCP, and more. Nine areas, dozens of features, one local app.

Agents & conversations

  • Critters: Every agent has a role, model, account, and its own worktree.
  • Chat mode: Streaming transcript with thinking, tool calls, and question cards.
  • Terminal mode: The real interactive Claude / Codex CLI over a persistent PTY.
  • Mode & effort: Plan / Accept Edits / Bypass and Low → Max, per agent, next turn.
  • Queued & scheduled sends: Keep typing while it works, or schedule a message for later.
  • Hand off: Pass a live conversation to another agent without losing context.
  • Companions & Notch: Pixel-animal avatars and a floating always-on-top status window.

Coordination

  • Packs (Agent Teams): A visual Start → Agent → Done builder with handoff policies.
  • Automatic handoff: Junior-readable summaries flow down the pipeline between members.
  • Ultracode: Max-effort dynamic multi-agent workflows from a single prompt.
  • Subagents: Live status, elapsed time, tool counts, and full per-subagent transcripts.

Autonomous guardians

  • Claw: A persistent, offline guardian that remembers across sessions.
  • Nightly learning: Distills lessons into rules, memory, and new skills, all as diffs.
  • QA guardian: Exercises your running app in an embedded browser to catch regressions.
  • Test-case suite: A managed library of E2E scenarios QA runs and extends from your changes.
  • Findings → tickets: Files issues to Jira or the backlog with evidence screenshots.
  • Connectors: Pulls signal from Sentry and PostHog into QA runs.
  • Rules & checklists: Standing rules the guardians always honor.

Plan & schedule

  • Backlog: A Kanban board: drag a card to “in progress” to spawn an agent on it.
  • Triage: Turn a pile of tasks into a prompt, or run a Pack per task.
  • Schedules: Cron or one-shot runs of prompts or tasks to an agent or Pack.
  • Unattended runs: Pick the account and model for scheduled runs; auto-switch when a limit hits.
  • Run reports: Every scheduled run leaves an LLM-summarized report.
  • Jira sync: Import tickets, fetch attachments, and post resolution comments.

Git & code

  • Worktrees: An isolated git branch per agent, created and cleaned up for you.
  • Changes & diffs: Review exactly what each agent touched, with file history.
  • Rewind: Roll an agent’s worktree back to before any chat turn, reversibly.
  • Run: Start dev servers, detect the ready URL, and open the app.
  • Editor & Code map: A Monaco editor plus a codebase dependency map.
  • Audit: A Changes review feed with risk flags, and a Security findings view.

Knowledge & reuse

  • Prompt Library: Foldered, per-project saved prompts you send to any agent.
  • Skills: Modular instruction sets you attach to agents.
  • Saved Commands: Dev-command snippets that launch in real terminal tabs.
  • Memory editor: CLAUDE.md / CODEX.md across global, project, and agent scope.
  • Notes: An Obsidian-style vault with Markdown and Mermaid diagrams.

Extend & connect

  • MCP servers: Per-project config plus a bundled Zoogentic MCP (backlog, prompts, skills, ask).
  • Plugins & marketplaces: Search and install Claude Code plugins in-app.
  • Browser bridge: Capture a page element into the composer via the Chrome extension.
  • Sketches: An Excalidraw canvas: annotate a screenshot and attach it.

Providers & accounts

  • Auto-detect: Finds Claude Code and Codex plus the models they report.
  • Multiple accounts: Isolated credentials per login, with live usage bars.
  • Switch after limit: Wait, switch, or switch-then-wait when a run hits a cap.
  • Cost cockpit: Tokens, cost, budgets, and a per-agent breakdown.

Your workspace

  • Projects & Workspaces: Group projects so agents can work across them.
  • Habitats: A Virtual Office floor where each agent animates at its cubicle.
  • Statistics: Tokens, cost, prompt count, and working-time analytics.
  • Command palette: Everything a ⌘K / Ctrl+K away.
  • Themes & Coffee: A light/dark savanna console, plus keep-awake and a mouse jiggler for long runs.
Local-first

No account. No cloud. No telemetry.

Your data and your agents live on your machine. You bring your own CLI and provider login. Nothing routes through a Zoogentic server, because there isn’t one.

Local SQLite

Projects, prompts, skills, and sessions in one file on your device.

Isolated credentials

Many accounts per provider, each in its own config directory.

Real processes

Agents run over ConPTY / PTY, the CLIs you already trust.

Auto-detected CLIs:Claude Code· opus · sonnet · haikuCodex· your CLI models

The Zoogentic Loop

Plan, launch, and steer a whole team of agents, without leaving one window.

Plan on the Backlog

Drop work onto the board, break it into tasks, and pick the agent role that fits each one.

Launch Critters

Spin up one agent (or a whole Pack with a lead that hands off to teammates), each in its own worktree.

Watch & steer

Follow the live chat and thinking, drop into the real terminal, queue follow-ups, and tune effort or permissions per turn.

Review, Rewind, ship

Diff what each agent changed, rewind a turn if it drifted, then merge, while Claw and QA keep watch.

Questions, answered.

The things people ask before they hit download.

It’s free while in beta. Paid plans are planned down the road. We’ll give plenty of notice before anything changes, and you can keep using the beta in the meantime.

Zoogentic

Stop babysitting one agent.
Run the whole zoo.

Native performance. Local-first by default. Your CLIs, your accounts, your machine.

Download for Windows

macOS (Apple Silicon) · Windows (x64)