Stop Managing One AI Agent at a Time: Dorothy Orchestrates 10+

Your terminal is a prison. Every morning, you open Claude Code in one window, switch to another project in another tab, and pray you don't lose context when the session times out. You hire AI to write code, yet you spend more time managing the AI than shipping features. What if you could deploy an entire fleet of AI agents—each working on different projects, different tasks, different codebases—and control them all from a single, beautiful dashboard?

Meet Dorothy, the open-source desktop application that transforms lonely terminal sessions into a coordinated AI workforce. Created by developer Charlie85270, Dorothy isn't just another wrapper around Claude Code. It's a full agent orchestration platform that runs multiple AI agents in parallel, automates workflows through GitHub and JIRA integrations, and even lets you command your agent fleet from Telegram while grabbing coffee.

The secret weapon top developers are already using? It's not more prompts. It's parallel agent execution with intelligent orchestration—and Dorothy delivers exactly that, completely free.

What is Dorothy?

Dorothy is a free, open-source desktop application built for developers who have outgrown single-terminal AI workflows. Named with a playful nod to being "the wife your AI agents needs," Dorothy serves as the central command hub for Claude Code, OpenAI Codex, Google Gemini CLI, and local AI agents.

The project emerged from a genuine pain point: AI CLI tools like Claude Code are extraordinarily powerful, but they're fundamentally designed for serial execution—one agent, one terminal, one task at a time. For developers juggling multiple microservices, maintaining several open-source projects, or running AI-powered code review across an organization, this limitation becomes a productivity killer.

Charlie85270 built Dorothy on a modern Electron + Next.js + React stack, leveraging node-pty for true terminal multiplexing and the Model Context Protocol (MCP) for extensible tool integration. The result? A desktop app that doesn't just launch agents—it orchestrates them with lifecycle management, real-time monitoring, automated task assignment, and cross-agent knowledge sharing.

Dorothy is trending now because it arrives at a critical inflection point: AI coding tools have matured enough to be genuinely useful, but the infrastructure to manage them at scale hasn't existed—until now. With 40+ MCP tools, native automations, and a visual Kanban system, Dorothy bridges the gap between "AI-assisted coding" and "AI-driven development teams."

Key Features That Separate Dorothy from Basic Wrappers

Parallel Agent Execution with Isolated PTY Sessions

Unlike simple terminal tabs, Dorothy spawns each agent in its own pseudo-terminal (PTY) session via node-pty. This means full terminal fidelity—colors, interactive prompts, progress bars, and real-time output streaming—for every single agent. You can run 10+ agents simultaneously across completely different projects without crosstalk or context pollution.

Each agent gets independent configuration: model selection (Sonnet for complex architecture, Haiku for quick scripts, Opus for deep analysis), skill assignments, project paths, and even secondary directories via --add-dir for multi-repo context. Git worktrees are natively supported, enabling branch-isolated development where one agent works on your feature/auth branch while another handles hotfix/memory-leak.

Super Agent: The Meta-Orchestrator

Dorothy's most powerful feature is the Super Agent—a meta-agent that programmatically controls all other agents through MCP tools. Give it a high-level objective like "refactor all authentication across our microservices," and it will:

• Analyze which agents have the relevant skills
• Spawn temporary agents for each service
• Delegate specific refactoring tasks with appropriate context
• Monitor progress across all agents in real-time
• Handle errors by reassigning or escalating
• Clean up temporary agents when complete

This isn't just automation—it's autonomous coordination that scales your oversight capacity exponentially.

Built-in Automations Engine

Dorothy's automation system polls external sources and triggers agent execution without human intervention. The execution pipeline is remarkably robust: scheduler → poller → filter → deduplication → agent spawning → prompt injection → autonomous execution → output delivery → cleanup.

Supported sources include GitHub (PRs, issues, releases via gh CLI) and JIRA (REST API v3), with Pipedrive, Twitter, RSS, and custom webhooks on the roadmap. Template variables like {{title}}, {{url}}, {{body}} inject live data into agent prompts, while deduplication via content hashing prevents redundant processing.

Visual Kanban with Auto-Assignment

Tasks flow through Backlog → Planned → Ongoing → Done with automatic agent matching based on skill requirements. The kanban-automation service watches for new tasks, creates agents if no match exists, and tracks progress to completion. This creates a self-managing pipeline where you add tasks and agents automatically pick them up.

Remote Fleet Control

Control your entire agent workforce from Telegram or Slack. Start agents, check status, delegate to the Super Agent, or receive usage reports—all from your phone. The Telegram bot supports media uploads via mcp-telegram, while Slack integration uses Socket Mode for security without public URLs.

Persistent Knowledge Vault

Agents share knowledge through Dorothy's Vault—a SQLite-backed document system with full-text search (FTS5). Any agent can store reports, analyses, or structured notes that other agents retrieve later. This solves the critical "memory" problem where each Claude Code session starts from scratch.

Real-World Use Cases Where Dorothy Dominates

1. Multi-Service Architecture Refactoring

You're modernizing a backend from REST to GraphQL across six microservices. Instead of six sequential Claude Code sessions with context re-establishment each time, Dorothy spawns six parallel agents—one per service—with the Super Agent coordinating shared type definitions and API contracts. Each agent has its own project path, secondary directories for shared libraries, and real-time terminal output visible in the dashboard. What took three weeks of evenings now completes in a focused weekend.

2. Automated PR Review Pipeline

Your team receives 20+ pull requests daily across multiple repositories. Dorothy's GitHub automation polls every 15 minutes, creates temporary agents for each new PR, and posts structured code review comments automatically. The agent checks for security issues, performance regressions, and test coverage—freeing senior developers for architecture decisions while ensuring nothing slips through.

3. JIRA-Driven Development Workflow

Product creates tickets; Dorothy executes them. When a JIRA issue moves to "Open," the automation creates a Kanban task, auto-assigns to a matching agent, and the agent implements the feature. On completion, Dorothy transitions the JIRA issue, adds implementation notes, and notifies Slack. You've built a CI/CD pipeline where the "integration" is AI agents shipping code.

4. Recurring Maintenance & Monitoring

Schedule agents for periodic tasks: database optimization queries every Sunday at 2 AM, dependency vulnerability scans every 4 hours, or competitor analysis reports every Monday morning. Dorothy's cron-based scheduler uses launchd on macOS and cron on Linux for reliable background execution—with full logs and Telegram notifications on completion or failure.

5. Remote Incident Response

Production alert fires at 3 AM. From Telegram, you /ask the Super Agent to investigate. It spawns diagnostic agents across your infrastructure repositories, analyzes logs, identifies the root cause, and prepares a hotfix branch. You review and deploy from bed—never opening your laptop.

Step-by-Step Installation & Setup Guide

Prerequisites

Before installing Dorothy, ensure you have:

• Node.js 18+ and npm/yarn
• Claude Code CLI: npm install -g @anthropic-ai/claude-code
• GitHub CLI (gh) — required for GitHub automations

Option 1: Download Pre-built Release (Recommended)

Download the latest release from GitHub Releases.

macOS users: If you encounter "app is damaged," run:

xattr -cr /Applications/Dorothy.app

Option 2: Build from Source

For developers who want the latest features or plan to contribute:

# Clone the repository
git clone https://github.com/Charlie85270/Dorothy.git
cd Dorothy/app/dorothy

# Install dependencies
npm install

# Rebuild native modules for Electron
npx @electron/rebuild

# Development mode with hot reload
npm run electron:dev

# Production build (creates DMG installer)
npm run electron:build

Build outputs:

• macOS Apple Silicon: release/mac-arm64/Dorothy.app
• macOS Intel: release/mac/Dorothy.app
• DMG installer: Included for distribution

Web Browser Development Mode

For UI development without Electron features:

npm install
npm run dev

Open http://localhost:3000. Note that agent management and terminal features require the Electron app—the browser mode is for frontend development only.

Initial Configuration

On first launch, Dorothy reads your existing Claude Code configuration from:

• ~/.claude/settings.json — User preferences and permissions
• ~/.claude/statsig_metadata.json — Usage statistics

Configure these essential integrations in Settings:

1. Telegram: Create bot via @BotFather, paste token, send /start
2. Slack: Create app at api.slack.com/apps, enable Socket Mode, add OAuth scopes, subscribe to app_mention and message.im events
3. Google Workspace: Install gcloud and gws CLI, run guided OAuth setup
4. SocialData: Add API key from socialdata.tools

REAL Code Examples from Dorothy's Repository

Example 1: Automated PR Review Bot Configuration

This JavaScript configuration creates a fully autonomous code review pipeline. Dorothy's automation engine polls GitHub every 15 minutes and spawns agents for each new pull request:

create_automation({
  name: "PR Code Reviewer",
  sourceType: "github",
  // Configure which repositories and item types to monitor
  sourceConfig: '{"repos": ["myorg/myrepo"], "pollFor": ["pull_requests"]}',
  scheduleMinutes: 15,  // Poll interval — balance freshness vs. API limits
  agentEnabled: true,   // Actually spawn agents (false = just log for testing)
  // Template variables inject live PR data: {{title}}, {{url}}, {{body}}
  agentPrompt: "Review this PR for code quality, security issues, and performance. PR: {{title}} ({{url}}). Description: {{body}}",
  agentProjectPath: "/path/to/myrepo",  // Where the agent checks out and analyzes code
  outputGitHubComment: true,  // Post review directly as PR comments
  outputSlack: true           // Also notify your team channel
})

What's happening here? The automation creates a closed loop: GitHub PR → Dorothy detects it → agent analyzes code → feedback posted automatically. The {{title}} and {{body}} variables ensure each agent receives contextual, specific instructions rather than generic prompts. Setting outputGitHubComment: true means reviewers see structured feedback without anyone opening Claude Code manually.

Example 2: JIRA Issue Processor with Auto-Transition

This automation handles JIRA tickets from detection through resolution, including status transitions and team notifications:

create_automation({
  name: "JIRA Task Agent",
  sourceType: "jira",
  // JQL query filters which issues trigger the automation
  sourceConfig: '{"projectKeys": ["PROJ"], "jql": "status = Open"}',
  scheduleMinutes: 5,  // Faster polling for ticket-driven workflows
  agentEnabled: true,
  // Inject JIRA-specific variables: issue key, summary, priority, description
  agentPrompt: "Work on JIRA issue {{key}}: {{summary}}. Description: {{body}}. Priority: {{priority}}.",
  agentProjectPath: "/path/to/project",
  outputJiraComment: true,     // Document agent's work in ticket comments
  outputJiraTransition: true,  // Move ticket status when agent completes
  outputTelegram: true         // Ping you when done
})

Critical insight: The outputJiraTransition: true flag enables true autonomous workflow completion—not just analysis, but actual status changes in your project management tool. Combined with Dorothy's Kanban integration, JIRA automations also create backlog tasks automatically, allowing the auto-assignment system to distribute work across your agent pool.

Example 3: Building from Source with Native Module Rebuild

This shell sequence from Dorothy's documentation shows the complete build process, including the critical electron-rebuild step that many developers miss:

# Clone the complete monorepo with all MCP servers
git clone https://github.com/Charlie85270/Dorothy.git
cd Dorothy/app/dorothy

# Install all dependencies including Electron-specific packages
npm install

# CRITICAL: Rebuild native modules against Electron's Node.js version
# Without this, node-pty and better-sqlite3 will fail with ABI mismatches
npx @electron/rebuild

# Development mode: runs Next.js dev server + Electron concurrently
# Includes hot reload for both renderer and main processes
npm run electron:dev

# Production build: compiles TypeScript, builds Next.js, packages with electron-builder
# Output: DMG installer + unpackaged app in release/ directory
npm run electron:build

Why npx @electron/rebuild matters: Dorothy relies on native modules (node-pty for terminal emulation, better-sqlite3 for the Vault database). These compile against Node.js's ABI (Application Binary Interface). Electron bundles its own Node.js version, which often differs from your system Node.js. Without rebuilding, you'll encounter cryptic "Module version mismatch" errors. This single command prevents hours of debugging.

Example 4: Cron-Scheduled Recurring Task

Dorothy's scheduled tasks use standard cron syntax for maximum flexibility. Here's how to set up a weekly maintenance agent:

# Schedule expression: 0 9 * * 1-5
# │ │ │ │ │
# │ │ │ │ └─── Day of week: 1-5 (Monday through Friday)
# │ │ │ └───── Month: * (every month)
# │ │ └─────── Day of month: * (every day)
# │ └───────── Hour: 9 (9:00 AM)
# └─────────── Minute: 0 (top of the hour)

In Dorothy's UI, you'd create a scheduled task with:

• Schedule: 0 9 * * 1-5 (weekdays at 9 AM)
• Project Path: /path/to/maintenance-scripts
• Prompt: "Run database optimization, check for unused indexes, generate performance report, and save to Vault folder 'weekly-reports'"
• Autonomous Mode: Enabled (--dangerously-skip-permissions)

The agent executes unattended, stores results in the Vault for cross-agent access, and Dorothy's scheduler ensures reliable execution via launchd (macOS) or cron (Linux).

Advanced Usage & Best Practices

Optimize Agent Density with Skill Specialization

Don't create generic agents. Define specialized skills per agent—TypeScript LSP for frontend agents, Python data analysis for ML agents, GitHub PR tools for review agents. The Super Agent's delegation becomes dramatically more effective when agents have clear capability profiles.

Leverage Secondary Project Paths

Use --add-dir to give agents multi-repo context without monorepo restructuring. A microservice agent can access shared libraries, a documentation agent can reference source code, and an integration test agent can span multiple services.

Design Automation Prompts for Deterministic Output

When building automations, structure agentPrompt templates to produce machine-parseable output. Include instructions like "Respond with JSON containing: summary, files_changed, risk_level, recommended_action." This enables downstream automation—like auto-merging low-risk PRs or escalating high-risk ones.

Vault as Shared Memory

Explicitly instruct agents to store intermediate findings in the Vault. A research agent's analysis becomes a planning agent's input. Use consistent folder structures (/projects/{name}/, /research/{topic}/, /decisions/{date}-topic) for discoverability.

Secure Autonomous Execution

The --dangerously-skip-permissions flag enables true unattended operation but requires trust in your automation prompts. Start with supervised mode, review agent outputs, then gradually enable autonomy for proven automation patterns. Use Git worktrees to isolate experimental agent branches from production code.

Comparison with Alternatives

When to choose Dorothy: You manage multiple AI agents across projects, need automation without building infrastructure, want visual oversight of agent fleets, or require cross-agent knowledge sharing.

When Dorothy is overkill: Single-project developers with occasional AI assistance, or teams already invested in heavy custom CI/CD with AI plugins.

FAQ

Is Dorothy officially affiliated with Anthropic, OpenAI, or Google?

No. Dorothy is an independent open-source project by Charlie85270. It orchestrates official CLI tools (Claude Code, Codex CLI, Gemini CLI) but is not endorsed by those companies.

Does Dorothy work with local LLMs or only cloud APIs?

Dorothy supports any AI agent with a CLI interface, including local models through compatible wrappers. The README specifically mentions Claude Code, Codex, Gemini CLI, and "local agents." You'll need to configure the local CLI path in settings.

How does Dorothy handle API costs with multiple agents running?

Dorothy includes usage tracking with token consumption monitoring, conversation history, and cost aggregation across all agents. The dashboard shows real-time spending patterns. For cost control, use model selection strategically (Haiku for simple tasks, Sonnet/Opus for complex work) and set autonomous execution only for proven automation patterns.

Can I run Dorothy on Windows or Linux?

The build system targets macOS primarily (DMG output, launchd scheduling). However, the Electron + Next.js architecture is cross-platform, and the README notes Linux cron support for scheduled tasks. Windows support would require community contributions for scheduling and path handling adaptations.

Is my code safe with Dorothy's automations?

Dorothy runs entirely locally—your code never leaves your machine except through the official AI CLI tools you already use. Automations use your existing gh CLI credentials and local repositories. The Vault stores data in local SQLite at ~/.dorothy/vault.db.

How do I contribute or report bugs?

Fork the repository, create a feature branch, and submit a Pull Request. The project uses standard GitHub workflow. For bugs, use GitHub Issues with reproduction steps and environment details.

What's the performance impact of running 10+ agents?

Each agent spawns a separate claude CLI process via node-pty. Memory usage scales linearly with agent count—typically 200-500MB per active agent depending on context window. CPU usage spikes during agent initialization and code analysis, but idle agents consume minimal resources. Dorothy's dashboard shows per-agent resource indicators.

Conclusion: Your AI Agents Deserve Better Than Terminal Tabs

Dorothy solves a problem most developers haven't fully articulated yet: the orchestration gap. We have powerful AI coding tools, but we're still managing them with infrastructure designed for human developers working sequentially. That's like hiring 10 engineers and giving them one shared computer.

What makes Dorothy genuinely exciting isn't any single feature—it's the system integration. Parallel execution alone is useful. Automations alone are useful. Kanban alone is useful. But combining them with a Super Agent coordinator, persistent Vault knowledge, and remote fleet control creates something greater: a self-managing AI development team that scales with your ambitions.

The project is free, open source, and actively developed. Whether you're a solo developer drowning in context switching or a team lead building AI-powered CI/CD, Dorothy deserves evaluation.

Ready to stop managing one agent at a time? Clone Dorothy from GitHub, join the growing community of developers orchestrating AI at scale, and discover what your agent fleet can accomplish when properly coordinated. The future of development isn't better prompts—it's better orchestration. Dorothy is that orchestration layer, and it's waiting for you.