Skip to content
/
Tier A A12 UI passthrough

Dorothy

dorothy · Charlie85270/Dorothy · ★ 291 · last commit 2026-05-05

Primitive shape 15 total
Skills 2 Subagents 1 MCP tools 12
00

Summary

Dorothy — Summary

Dorothy is an Electron desktop app (Next.js + React) for running 10+ parallel AI coding agents (Claude Code, Codex, Gemini, local models) in isolated PTY terminal sessions, with a Super Agent MCP orchestrator (a meta-agent that controls all others via MCP tools), a Kanban board with automatic agent assignment, cron-scheduled tasks, GitHub/JIRA automations with deduplication, Telegram/Slack remote control, a built-in memory API (REST, port 31415), a Claude Code session hook for capturing clean output, and a skills/plugin system via skills.sh.

Problem it solved: Running unlimited parallel AI agents across different projects with automated workflow triggers, remote control, and cross-agent coordination from a single desktop app — without requiring cloud infrastructure.

Distinctive traits: (1) Super Agent — a meta-agent with MCP tools (list_agents, get_agent, start_agent, stop_agent, create_agent, get_agent_output) that programmatically controls all other agents; (2) Memory REST API at port 31415 with remember, search, stats endpoints and typed memory categories (preference/learning/decision/context); (3) Automation pipeline with content hashing for deduplication; (4) Telegram/Slack integration for remote agent control from phone.

Target audience: Individual developers and small teams wanting autonomous, unattended AI agent pipelines with event-driven triggers and mobile remote control.

differs_from_seeds: Dorothy is closest to SwarmClaw in feature breadth (both have hierarchical orchestration, memory, skills, scheduling, connectors), but Dorothy focuses on local execution with PTY terminals rather than a web-based agent runtime. The Super Agent's MCP-based control surface over other agents is similar to Dorothy's own orchestrator pattern but lighter than SwarmClaw's 6-primitive runtime. The local memory REST API at port 31415 is unique relative to all seeds.

01

Overview

Dorothy — Overview

Origin

Created by Charlie85270 (Charlie Josselin). MIT license. Version 1.2.8. Website implied at screenshots. Actively maintained as of 2026-05-05.

Philosophy

From README:

"Dorothy, the wife your AI agents needs." "AI CLI tools are powerful — but it runs one agent at a time, in one terminal. Dorothy removes that limitation."

Core capabilities:

  • Run 10+ agents simultaneously across different projects
  • Automate agent workflows — trigger from GitHub PRs, JIRA issues
  • Delegate and coordinate — Super Agent orchestrates others via MCP tools
  • Manage tasks visually — Kanban board with automatic agent assignment
  • Schedule recurring work — cron-based tasks that run autonomously
  • Control from anywhere — Telegram and Slack for remote management

Key design philosophy

Dorothy is local-first and PTY-based — agents run as actual terminal processes in PTY sessions, not via API calls. This means any CLI-based AI tool works, including local models via Ollama.

Super Agent metaphor

The Super Agent is described as:

"A meta-agent that programmatically controls all other agents. Give it a high-level task and it delegates, monitors, and coordinates the work across your agent pool."

This creates an emergent hierarchy: one Claude Code session controls N other Claude Code sessions via MCP.

Target users

Solo developers and small teams wanting autonomous, unattended AI workflows with GitHub/JIRA automation and mobile remote control.

02

Architecture

Dorothy — Architecture

Distribution

  • Electron desktop app (macOS, Windows, Linux)
  • No npm global install (Electron only)

Technology stack

Layer Technology
Desktop framework Electron 33
Frontend Next.js (App Router) + React 19
Backend (main process) Node.js + node-pty
Styling Tailwind CSS 4
MCP server mcp-orchestrator (TypeScript, stdio)
Memory API REST server at port 31415
Notifications Telegram Bot API, Slack API

Directory structure

dorothy/
├── src/
│   └── app/           # Next.js App Router pages
├── electron/          # Electron main process
│   ├── AgentManager   # Manages N PTY agent sessions
│   ├── PTYManager     # Terminal multiplexing (node-pty)
│   └── Services:
│       ├── TelegramBot
│       ├── SlackBot
│       ├── KanbanAutomation
│       ├── MCPServerLauncher
│       ├── APIServer (memory REST at :31415)
│       └── Scheduler (cron)
├── mcp-orchestrator/  # Super Agent MCP server (TypeScript)
│   └── src/
│       └── tools/
│           ├── agents.ts      # Agent CRUD + control tools
│           ├── messaging.ts   # Telegram/Slack messaging tools
│           ├── scheduler.ts   # Scheduler tools
│           └── automations.ts # Automation tools
├── skills/            # Skill files
│   └── remember.md    # Memory skill
├── .claude/           # Claude Code integration
│   └── skills/        # Skills for Claude Code
├── .cursor/           # Cursor config
├── .opencode/         # OpenCode config
└── hooks/             # Hooks configuration

Agent isolation

Each agent runs in an isolated PTY terminal session (node-pty). Git worktree support available but optional.

03

Components

Dorothy — Components

Super Agent MCP server (mcp-orchestrator)

Tool Purpose
list_agents List all agents and their status (idle/running/waiting/completed/error)
get_agent Get detailed agent info including full output history
get_agent_output Get agent's last response as clean text (via hook-captured transcript)
start_agent Start an agent
stop_agent Stop an agent
create_agent Create a new agent
Messaging tools Send Telegram/Slack messages
Scheduler tools Create/delete/run recurring tasks
Automation tools Manage GitHub/JIRA automation pipelines

Memory REST API (port 31415)

Endpoint Method Purpose
/api/memory/remember POST Store a memory with type (preference/learning/decision/context)
/api/memory/search?q=TERM GET Search memories
/api/memory/stats GET Memory statistics

Skills

Skill Purpose
skills/remember.md Teaches agents to use the memory REST API at port 31415
.claude/skills/world-builder/ World-builder skill (specific content not retrieved)

UI pages

Page Purpose
Agent Dashboard Manage 10+ parallel agents, view PTY output
Super Agent Meta-agent control panel
Kanban Board Visual task management with auto-assignment
Automations GitHub/JIRA automation configuration
Scheduled Tasks Cron task management
Usage Stats Token/cost tracking across all agents
Skills Management Install skills from skills.sh
Settings Claude Code permissions, env vars, hooks, model selection

Automation pipeline

Stage Description
Scheduler Cron trigger
Poller Fetch from source (GitHub via gh CLI, JIRA via REST)
Filter Apply trigger conditions (event type, new vs updated)
Dedup Skip already-processed items via content hashing
Agent spawn Create temporary agent per item
Prompt injection Inject item data via template variables ({{title}}, {{body}}, etc.)
Execution Agent runs autonomously with --dangerously-skip-permissions
Output delivery Post to Telegram, Slack, GitHub comments, JIRA comments
Cleanup Delete temporary agent after completion
05

Prompts

Dorothy — Prompts

Verbatim excerpt 1: remember.md (memory skill)

# Remember Skill

You have access to a persistent memory system that allows you to store and recall information across sessions.

## How to Save Memories

Use bash to call the memory API. The API runs on `http://127.0.0.1:31415`.

### Store a memory:
```bash
curl -s -X POST http://127.0.0.1:31415/api/memory/remember \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "YOUR_AGENT_ID", "content": "What you want to remember", "type": "TYPE"}'

Types:

  • preference - User preferences (name, coding style, etc.)
  • learning - Something you learned about the codebase
  • decision - An important decision that was made
  • context - Background information about the project

Search memories:

curl -s "http://127.0.0.1:31415/api/memory/search?q=SEARCH_TERM"

When to Use Memory

ALWAYS save memories when:

  • User tells you their name or preferences
  • You learn something important about the codebase architecture
  • An important decision is made about implementation approach
  • User corrects you or provides context you should remember

Example - User says "My name is Charlie":

curl -s -X POST http://127.0.0.1:31415/api/memory/remember \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "{{AGENT_ID}}", "content": "User name is Charlie", "type": "preference"}'

**Prompting technique:** REST API skill injection — the agent is given a `curl`-based interface to a local REST server (port 31415) for memory persistence. This is a novel approach: instead of a file-based or MCP memory system, the agent uses `execute` (bash) to call a REST API that Dorothy's main process exposes.

---

## Verbatim excerpt 2: automation prompt template (from README)
```javascript
create_automation({
  name: "PR Code Reviewer",
  sourceType: "github",
  sourceConfig: '{"repos": ["myorg/myrepo"], "pollFor": ["pull_requests"]}',
  scheduleMinutes: 15,
  agentEnabled: true,
  agentPrompt: "Review this PR for code quality, security issues, and performance. PR: {{title}} ({{url}}). Description: {{body}}",
  agentProjectPath: "/path/to/myrepo",
  outputGitHubComment: true,
  outputSlack: true
})

Prompting technique: Template variable injection ({{title}}, {{body}}, {{url}}) into automation prompts. Source-specific variables are well-defined per integration type (GitHub variables vs JIRA variables have distinct schemas).

09

Uniqueness

Dorothy — Uniqueness & Positioning

differs_from_seeds

Dorothy is the most feature-complete local-first autonomous agent platform in this batch. Among the 11 seeds, it is closest to SwarmClaw in feature breadth but differs architecturally: Dorothy uses PTY-based terminal processes (not an MCP runtime), runs a local REST memory API (not a database abstraction), and builds its Super Agent hierarchy by giving one Claude Code session MCP tools to control other Claude Code sessions — a novel inversion. The local memory REST API at port 31415 with typed memory categories (preference/learning/decision/context) and curl-based skill injection is unique across all seeds. The automation deduplication pipeline (content hashing to prevent re-processing GitHub PRs/JIRA issues) is also absent from all seeds. The get_agent_output MCP tool that captures clean text via hooks (stripping ANSI codes) solves a real problem (reading agent output programmatically) that no seed addresses.

Positioning

  • "The wife your AI agents needs" (tagline suggests completeness and support)
  • Local-first: all data on your machine, no cloud required
  • MIT license: maximally permissive
  • Lower stars (291) than RunMaestro (2954) or 1Code (5542) but actively maintained (May 2026)

Observable failure modes

  • --dangerously-skip-permissions for automation agents: security risk in unattended mode
  • Memory REST API at a fixed port (31415) could conflict with other local services
  • Telegram/Slack bot setup requires manual configuration and credentials
  • No automated merge or git flow: all integration is manual
  • PTY terminal output capture (for get_agent_output) depends on hooks working correctly

Inspired by

  • JIRA/GitHub CI/CD automation patterns
  • Telegram bot remote control model (common in DevOps tools)

Competitors named in README

None explicitly.

Cross-references

  • skills.sh ecosystem for skill installation
  • .cursor/ and .opencode/ configs suggest multi-IDE awareness
  • world-builder skill in .claude/skills/ — a custom skill for world-building tasks
04

Workflow

Dorothy — Workflow

Interactive parallel agent workflow

Phase Action Artifact
1. Agent creation Create agent: name, model (sonnet/opus/haiku), project path, skills Agent record in Dorothy
2. Parallel execution Agents run as PTY processes; send interactive input to any Per-agent PTY output
3. Lifecycle tracking `idle → running → completed error
4. Monitoring Usage stats: token consumption, cost, history Analytics view

Super Agent workflow

Phase Action Artifact
1. High-level task User gives Super Agent a complex goal Task description
2. Delegation Super Agent creates/starts/assigns workers via MCP tools Worker agents created
3. Monitoring Super Agent calls get_agent_output to check progress Clean output text
4. Coordination Super Agent handles errors, re-delegates, summarizes Coordinated result

Automation pipeline workflow

Phase Action Artifact
1. Trigger Cron fires → Poller fetches GitHub PRs or JIRA issues Source items
2. Filter + Dedup Apply conditions, skip already-processed (hash check) Filtered item set
3. Agent spawn Create temporary agent per item with injected prompt Agent per item
4. Execution --dangerously-skip-permissions autonomous run Agent output
5. Delivery Post to GitHub/JIRA/Telegram/Slack Comment/update/notification
6. Cleanup Delete temporary agent

Kanban workflow

  • Tasks in Kanban board
  • Auto-assignment to agents based on skill matching
  • Tasks move through columns: Backlog → In Progress → Done
  • JIRA automations automatically create Kanban tasks

Approval gates

  • No hard automated gates
  • User can send interactive input to any agent at any time
  • Automation deduplication prevents reprocessing
06

Memory Context

Dorothy — Memory & Context

Memory REST API (port 31415)

Dorothy runs a local REST API that agents can call via bash (curl) to store and retrieve persistent memories.

Memory types

Type Purpose
preference User preferences (name, coding style)
learning Architecture/codebase learnings
decision Important implementation decisions
context Background project information

Endpoints

  • POST /api/memory/remember — store a memory
  • GET /api/memory/search?q=TERM — search memories
  • GET /api/memory/stats — statistics

Scope

Memories are per-agent_id — each agent has its own memory namespace. This enables per-agent persistent context without cross-contamination.

Cross-session persistence

Memory is stored by Dorothy's main process (likely in SQLite or in-memory store — not explicitly documented). Agents can search memories from any previous session via the REST API.

Skills for context

The remember.md skill is injected into Claude Code agents to teach them how to use the memory API. The .claude/skills/ directory contains skills loaded by Claude Code at session start.

Agent state persistence

Dorothy persists agent state across app restarts (from README: "Persistent agent state across app restarts"). This includes the PTY session metadata, not necessarily the terminal scrollback.

Automation deduplication

Processed automation items are tracked via content hashing — a lightweight deduplication mechanism that prevents re-processing already-handled GitHub PRs or JIRA issues.

07

Orchestration

Dorothy — Orchestration

Multi-agent support

Yes — "Run 10+ agents simultaneously" is the primary value proposition.

Orchestration pattern

Hierarchical — Super Agent (orchestrator) controls N worker agents via MCP tools.

Super Agent pattern

The Super Agent is a Claude Code session that has the mcp-orchestrator MCP server configured. This gives it tools to:

  • List all running agents and their status
  • Get any agent's output (clean text, captured via hooks)
  • Create, start, stop, and delete agents
  • Send messages to Telegram/Slack
  • Create and manage scheduled tasks

The Super Agent is itself a Claude Code session — so a Claude instance controls other Claude instances via MCP. This is agent-to-agent orchestration at the MCP level.

Isolation mechanism

PTY process — each agent is an isolated terminal process (node-pty). Git worktree support is available but optional (referenced as a capability, not a default).

Multi-model support

Yes — each agent can be configured with model selection (sonnet/opus/haiku) and the framework supports Claude Code, Codex, Gemini, and local models.

Automation execution

Automation-spawned agents run with --dangerously-skip-permissions for unattended operation. They are temporary agents deleted after completion.

Execution modes

  • Interactive loop: Manual agent sessions with user input
  • Event-driven: GitHub/JIRA automation triggers
  • Scheduled: Cron-based recurring tasks

Memory coordination

The REST memory API (port 31415) enables agents to share knowledge — one agent can remember something and another can search for it, enabling cross-agent knowledge transfer without direct communication.

Max concurrent agents

10+ (no hard cap stated; "unlimited" per README).

08

Ui Cli Surface

Dorothy — UI & CLI Surface

Desktop application

Electron + Next.js + React 19 — the primary interface. Next.js runs inside Electron, serving pages via the app router.

No CLI binary

No bin field in package.json. Desktop-only distribution.

Key UI pages

Page Features
Agent Dashboard Spawn/monitor 10+ agents; per-agent PTY terminal output; status tracking
Super Agent Meta-agent control panel; delegate high-level tasks
Kanban Board Visual task management; auto-assignment based on skill matching
Automations GitHub/JIRA automation config; template variables; dedup; delivery config
Scheduled Tasks Cron-based recurring task setup
Usage Stats Token consumption, conversation history, cost tracking, activity patterns
Skills Management Install skills from skills.sh; per-agent skill assignment
Settings Claude Code permissions, env vars, hooks, model defaults

Remote control

Channel Capabilities
Telegram Receive messages, trigger agents, get outputs, Super Agent responds
Slack Same as Telegram

Observability

  • Real-time PTY terminal output per agent
  • Usage stats dashboard (token/cost/activity)
  • Agent lifecycle tracking (idle/running/completed/error/waiting)
  • MCP get_agent_output for clean (no ANSI) text capture
  • No JSONL audit log or replay capability

IDE support

  • .claude/: Claude Code integration (skills)
  • .cursor/: Cursor IDE support
  • .opencode/: OpenCode support

Memory inspection

Via REST API at http://127.0.0.1:31415/api/memory/stats and search — accessible from any agent via curl or from external tools.

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

Vibe Kanban ★ 27k
A12 UI passthrough

Eliminate the overhead of planning, switching between agent terminals, and reviewing diffs by providing a single web dashboard…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

AgentsMesh ★ 2.1k
A12 UI passthrough

Multi-tenant workforce platform that gives every team member a squad of AI coding agents coordinated through channels, pod…