Multi-Agent Orchestrator References

This document maps public multi-agent orchestration systems to design patterns relevant to Wardian's command center, workflow runtime, local agent roster, and agent-team management surfaces.

This is not an endorsement, affiliation claim, product evaluation, or competitive teardown. The notes below describe public architecture and design pressure only.

Last reviewed: 2026-05-13.

Source basis: the local-agent, worktree-manager, organization-management, and SDLC-control entries in this note were rechecked against their public repositories or first-party documentation where available. Repo-checked means the README plus project metadata and visible source layout were inspected. When a public website and repository disagreed, the repository was treated as the higher-confidence source.

Surface Taxonomy

Wardian should distinguish interaction surface from orchestration model:

• GUI/web command centers: emphasize dashboards, visual configuration, run history, and team-level visibility.
• CLI/TUI/local-terminal systems: emphasize fast keyboard control, local worktrees, terminal multiplexing, and developer-loop ergonomics.
• Organization and SDLC control planes: emphasize goals, org charts, budgets, issue/task ownership, approval gates, CI, PRs, and management/accountability workflows above individual agent sessions.
• Libraries/frameworks: emphasize programmable agent composition, state models, message routing, tools, memory, and runtime APIs.
• Hybrid systems: expose more than one surface, often pairing a code or YAML source of truth with a GUI or CLI execution surface.

This distinction matters because Wardian is not only an agent framework. It is a local command center for visible, long-running agent sessions. Systems that look similar at the orchestration layer can feel very different when the primary control surface is a browser, a terminal, a Python API, an organization chart, or a workspace-local YAML file.

Summary Map

System	Primary Surface	Relevant Pattern	Wardian Takeaway
Gas Town	Hybrid CLI/TUI + web dashboard	Workspace manager for many coding agents, Git worktrees, task bundles, health patrol, merge queues, and real-time feeds.	Persistent agent identity, work units, watchdogs, and dashboards are as important as terminal panes.
Gas City	SDK/CLI infrastructure	Orchestration-builder SDK with runtime providers, config packs, controller/supervisor loops, and health patrol.	Treat construction APIs and visual observability as separate layers; Gas City is source-level orchestration infrastructure, not a GUI reference.
Beehive	Desktop GUI + TUI	One-window repo/workspace manager for isolated clones, persistent PTYs, agent panes, and shared GUI/TUI config.	The "agent colony" metaphor aligns with Wardian's habitat framing when it exposes concrete repos, branches, panes, and persisted layout.
Agent of Empires	TUI + web dashboard	tmux-backed session manager for many CLI coding agents, worktrees, optional Docker sandboxes, and remote browser access.	Dense, low-latency agent supervision is its own UX class.
Hive	CLI/TUI	Small Ink-based worktree manager for creating, listing, merging, and dropping parallel agent workspaces.	Some adjacent tools are intentionally narrow; Wardian should keep the fast worktree loop simple even as the command center grows.
Apiari	Coordinator daemon + TUI/web surfaces	Rust workspace chat hub plus Swarm worker multiplexer for bots, signal watching, schedules, and worktree workers.	Wardian workflows should distinguish agent execution from coordination, review, notification, and merge ownership.
Orca	Desktop IDE + CLI	Agent development environment with worktrees, terminal panes, source control, inline review, browser/design mode, and agent-driving CLI.	Terminal panes, diffs, unread markers, status, and notifications belong in one command center.
Daintree	Desktop agent console	Electron local control plane for panels, worktrees, CLI agents, state detection, context injection, recipes, MCP, and review workflows.	Wardian's habitat metaphor should stay grounded in concrete worktrees, diffs, resource pressure, and action-needed states.
Biomelab	Desktop GUI	Fyne desktop dashboard for Git worktrees, process-detected agents, PR/CI state, terminal/IDE detection, and Docker sandboxes.	Visual dashboards can make worktree ownership, branch health, and agent isolation inspectable without owning the agent runtime.
Agor	GUI/Web	Multiplayer spatial canvas for coordinating coding assistants, worktrees, and sessions.	Spatial dashboards are useful when they expose ownership, environment, and live conversation state.
webmux	Web dashboard + CLI	Parallel AI agent dashboard with YAML-defined layouts, tmux terminals, worktrees, service ports, PR/CI, Linear, and Docker sandboxes.	A web command center can remain reproducible if its layout and runtime assumptions are text-defined.
OctoAlly	Web dashboard + Electron	Local-first Claude Code/Codex dashboard with tmux persistence, sessions grid, specialist agents, source control, and voice input.	Agent dashboards should treat live output, task lifecycle, terminals, and source control as one surface.
Overstory	CLI + web UI + TUI dashboard	Multi-agent coding orchestration with worktrees, runtime adapters, SQLite mail, watchdogs, web UI, TUI dashboard, and conflict resolution.	Agent-agent messaging, health monitoring, and merge coordination are key pieces beyond simply spawning workers.
Paperclip	Org/company control plane	Node.js server and React UI for managing teams of agents through companies, org charts, goals, issues, budgets, approvals, heartbeats, and audit trails.	Wardian should distinguish agent execution from management primitives such as goals, reporting lines, budgets, governance, and accountability.
Shep	CLI + web dashboard	Feature/SDLC control plane for AI coding agents, worktrees, feature phases, approval gates, CI auto-fix, PR creation, and multi-repo dashboards.	Wardian needs lifecycle views that sit above sessions: feature state, gates, CI, PRs, and evidence should be visible independently of the terminal.
Archon	Hybrid CLI/web	YAML workflows, isolated worktrees, visual execution.	Treat agent work as inspectable workflow runs with source-controlled definitions.
AWS CLI Agent Orchestrator	CLI/TUI	Terminal-native orchestration of multiple coding agents in Git worktrees.	TUI-style agent rosters and worktree dispatch are directly relevant to Wardian.
Claude Squad	TUI/local terminal	Manage multiple AI coding agents in isolated workspaces from one terminal UI.	Local multiplexing, resumable sessions, and per-agent workspace isolation are first-class UX concerns.
OpenHands	GUI/web + CLI	Software engineering agents with browser/app UI, runtime sandboxing, and task execution.	Humans benefit from seeing agent work products, logs, browser state, and code changes together.
AutoGen	Framework + Studio	Multi-agent conversation framework with an optional no-code studio.	A library-level orchestration model can power both programmatic and visual control surfaces.
Microsoft Agent Framework	Framework	Enterprise-oriented multi-agent orchestration with workflow, memory, tools, MCP, A2A, and observability concepts.	Protocol and governance boundaries matter when agents become long-lived infrastructure.
CrewAI	Framework + platform	Role-based crews plus deterministic flows.	Separate autonomous team collaboration from deterministic workflow control.
AgentScope	Framework	Multi-agent framework with message hub orchestration, MCP/A2A support, observability, and deployment options.	Agent systems need observability, structured messages, and deployment-aware orchestration.
MetaGPT	Framework/CLI	Software-company metaphor with role-specialized agents.	Role contracts and artifact handoffs help humans reason about multi-agent output.
CAMEL	Framework	Communicative agent framework and society simulation patterns.	Message protocols and role-play interactions are useful primitives, but need operational visibility.
SuperAGI	GUI/web platform	Agent platform with marketplace, tools, memory, and execution visibility.	Web dashboards can make agent lifecycle visible, but local-first inspection remains Wardian's differentiator.
AutoGPT Platform	GUI/web + server	Visual block-based agent workflows with marketplace/server components.	Block-based agent graphs show how visual composition and reusable agent components fit together.
Flowise	GUI/web	Low-code LLM app, agent, and workflow builder.	Visual construction is accessible, but Wardian should retain text-native definitions for agent authors.

Organization and SDLC Control Planes

This cluster is adjacent to local terminal multiplexers but operates at a higher management layer. These systems do not only ask "which agent is running?" They ask "what goal is this work serving?", "who owns it?", "what budget or approval gate constrains it?", "what evidence shows it is ready?", and "what happens after the agent finishes?"

Paperclip

Source basis: Public repo and first-party product/docs pages checked.

What it includes: Paperclip is a Node.js server and React UI for orchestrating a team of AI agents as an organization. It models companies, org charts, agents, goals, issues, tasks, heartbeats, budgets, governance, approvals, workspaces, plugins, schedules, audit activity, and multi-company isolation.

Distinctive components:

• Org chart with roles, titles, reporting lines, permissions, and job descriptions.
• Goal hierarchy and issue/task system so work traces back to company/project objectives.
• Heartbeat execution for scheduled or event-triggered agent work.
• Budget and cost control by company, agent, project, goal, provider, and model.
• Governance workflows for approvals, pause/resume/terminate, rollback, and audit trails.
• Bring-your-own-agent posture for Claude Code, Codex, Cursor, shell processes, HTTP/webhook bots, and similar adapters.
• Import/export direction for company templates, agents, skills, projects, routines, and issues.

Wardian relevance: Paperclip is a direct reference for "manage an organization, not just sessions." Wardian should not collapse agent management into terminals and workflows alone. As Wardian grows teams, watchlists, roles, workflows, budgets, approvals, and memory, it should make management primitives explicit: goal, owner, reporting relationship, budget policy, approval state, audit trail, and work product.

Shep

Source basis: Public repo, project site, and first-party docs checked.

What it includes: Shep is a CLI and web dashboard for running AI coding agents across features in isolated Git worktrees. It creates feature branches/worktrees, launches configured agents, streams live output, commits, pushes, opens draft PRs, watches CI, retries fixes, and preserves feature records.

Shep is not an org-chart system in the Paperclip sense. It is still relevant to this cluster because it elevates the unit of management from "agent session" to "feature lifecycle."

Distinctive components:

• Feature-centered lifecycle: started, analyze, requirements, research, planning, implementation, review, maintain, and blocked.
• Fast mode for direct implementation and spec-driven mode with PRD, plan, and merge approval gates.
• One worktree per feature, leaving the user's main checkout untouched.
• Web dashboard with feature sidebar, live agent output, activity log, diff viewer, chat, controls, and multi-repo views.
• CI watch and auto-fix loop after pushed branches.
• Agent-agnostic execution for configured coding agents such as Claude Code, Cursor CLI, Gemini CLI, Codex, and related tools.

Wardian relevance: Shep is a reference for work-as-lifecycle rather than session-as-lifecycle. Wardian should support durable work objects above agents: feature/request/run state, approval gates, CI evidence, PR links, diffs, blocked reasons, and follow-up chat. This belongs beside, not inside, the terminal pane.

CLI, TUI, and Local-Terminal Systems

Emerging TUI Workspace Managers

Several newer systems focus less on agent-framework abstractions and more on the day-to-day surface for supervising many local coding agents. This cluster includes Gas Town, Beehive, Agent of Empires, Hive, Apiari/Swarm, Orca, Daintree, Biomelab, webmux, OctoAlly, and related tools.

What they include: These systems usually provide a keyboard-first terminal interface for launching, naming, switching between, and monitoring multiple coding agents. Most pair each agent with a Git worktree, branch, task, or isolated workspace so many agents can work in parallel without directly colliding in the same checkout.

Distinctive components:

• Persistent TUI dashboards for multiple agent sessions.
• Worktree or workspace isolation as a default execution model.
• Fast keyboard switching between agents and tasks.
• Agent-aware status surfaces rather than generic terminal multiplexing.
• Task ownership and review handoff patterns for parallel coding work.

Wardian relevance: This is a core adjacent category for Wardian. These tools show that multi-agent orchestration is becoming a developer environment problem, not only a backend framework problem. Wardian should learn from their low-latency navigation, dense roster displays, and worktree-aware task ownership while preserving its broader habitat model: provider diversity, visible PTYs, workflow telemetry, skills, memory, and disk-inspectable state.

Gas Town

Source basis: Public repo checked.

What it includes: Gas Town is a hybrid local orchestration system for coordinating Claude Code, GitHub Copilot, Codex, Gemini, and other coding agents across Git-backed workspaces. Its command surface includes a real-time TUI feed, agent/task commands, and a web dashboard for agents, work bundles, hooks, queues, issues, and escalations.

Distinctive components:

• Mayor/coordinator, rigs/project containers, persistent worker identities, and Git-backed hook storage.
• Convoys and beads for task/work tracking rather than only terminal sessions.
• gt feed real-time TUI with agent tree, event stream, problems view, nudges, and handoffs.
• Web dashboard, telemetry, health patrol/watchdog concepts, and a refinery-style merge queue.
• Session discovery/continuation from agent event logs.

Wardian relevance: Gas Town reinforces that a useful command center is not just many terminals. Wardian should model durable agent identity, work ownership, event feeds, stuck-agent handling, merge readiness, and escalation state alongside the PTY.

Gas City

Source basis: Public repo checked.

What it includes: Gas City is an orchestration-builder SDK for multi-agent systems, not a GUI. It packages the Gas Town patterns as composable Go infrastructure: declarative city.toml config, runtime providers, work routing, formulas, orders, health patrol, and controller/supervisor loops.

Distinctive components:

• Runtime provider abstraction with implementations such as tmux, subprocess, exec, ACP, and Kubernetes.
• Config and pack composition for reusable orchestration setups.
• Controller/supervisor loop that reconciles desired state to running state.
• Beads store abstraction and health patrol concepts.
• CLI wiring around a reusable orchestration package.

Wardian relevance: Gas City is relevant to Wardian's agent-friendly construction layer. It supports the split the user described: code/config as construction, observable nodes/status as presentation. The important correction is that it should be cited as SDK/CLI orchestration infrastructure, not as a desktop or web GUI reference.

Orca

Source basis: Public repo and project site checked.

What it includes: Orca is a desktop agent development environment with a companion CLI. It runs Claude Code, Codex, OpenCode, Gemini, Cursor CLI, Copilot, Pi, and other CLI agents side by side in isolated worktrees with terminal panes, file editing, source control, browser/design mode, remote SSH worktrees, notifications, unread markers, and agent-visible automation commands.

Distinctive components:

• Ghostty-inspired terminal surface for many agents.
• Worktree-first feature isolation.
• Built-in source control, diff comments that can be sent back to agents, and PR/CI review surfaces.
• Per-worktree browser/design mode and remote worktree support.
• First-class CLI so agents can create worktrees, snapshot, click, and fill.
• Cross-agent/provider support within one local command center.

Wardian relevance: Orca is close to Wardian's desired command-center feel. It treats terminals as live work surfaces while adding just enough surrounding UI to make agent state, unread work, and code diffs legible.

Apiari

Source basis: Public repos for ApiariTools/apiari and ApiariTools/swarm checked; public product site checked for positioning.

What it includes: Apiari is better treated as a toolchain than a single TUI. The apiari repo is a Rust daemon and React SPA workspace chat hub for bots, provider SDKs, signals, schedules, and swarm-worker integration. The swarm repo is a TUI/CLI agent multiplexer that runs Claude, Codex, and Gemini agents in isolated Git worktrees.

Distinctive components:

• Bot/coordinator layer with workspace configs, context files, scheduled runs, and GitHub watch bots.
• Swarm TUI for multiple workers, each with branch/worktree isolation.
• Worker daemon processes, persistent .swarm/ state, PR tracking, and merge/close operations.
• Provider SDK crates for Claude, Codex, and Gemini.
• Public positioning around CI/review/PR/Telegram coordination.

Wardian relevance: Apiari is useful because it separates worker execution from coordinator responsibility. Wardian workflows should similarly model dispatch, supervision, review, notification, and merge readiness as separate states, not just "agent is running."

Beehive

Source basis: Public repo and project site checked.

What it includes: Beehive is a Tauri desktop GUI plus standalone Rust TUI for managing repos, isolated workspace clones, persistent PTY panes, terminals, and CLI agents side by side. The GUI and TUI share config and data.

Distinctive components:

• One-window workspace for repos, terminals, and agents.
• Hive/nest/comb model: linked repository, optional groups, and isolated clone per branch.
• Persistent terminals and agent panes using real PTYs.
• Tauri GUI with React/xterm.js and Rust backend; Ratatui/Crossterm TUI with portable-pty/vt100.
• Custom quick-launch buttons, layout persistence, branch tracking, and copyable workspaces.
• GUI currently macOS-oriented; TUI supports macOS and Linux x64.

Wardian relevance: Beehive is conceptually close to Wardian's habitat metaphor. Wardian should use its own ecological framing carefully: agent colonies are useful when they make ownership and status visible, not when they obscure concrete files, tasks, and run state.

Agent of Empires

Source basis: Public repo checked.

What it includes: Agent of Empires is a terminal session manager for AI coding agents with a TUI, optional browser dashboard, and ACP cockpit. Agents run in tmux sessions, usually in Git worktrees, with optional Docker sandboxing and session resume.

Distinctive components:

• TUI and browser dashboard for multiple agent sessions.
• tmux-backed persistence, worktree isolation, multi-repo workspaces, and diff view.
• Broad CLI-agent support including Claude Code, OpenCode, Codex, Gemini, Cursor, Copilot, Hermes, Kiro, Qwen, and others.
• Status detection for running, waiting, and idle states.
• Remote access patterns for phone/tablet use; Linux/macOS focus with WSL2 for Windows.

Wardian relevance: Agent of Empires is useful as a UX pressure reference. Wardian needs comparable speed for agent switching and task inspection even though it exposes a richer desktop command center.

Hive

Source basis: Public repo and project site checked.

What it includes: Hive is a narrow Bun/TypeScript CLI and Ink TUI for managing parallel AI-agent workspaces using Git worktrees. It creates new workspaces, lists them, merges them back to main, or drops them.

Distinctive components:

• Parallel coding-agent sessions.
• Git worktree isolation.
• Ink-based interactive TUI plus direct commands.
• Minimal branch/workspace lifecycle: new, list, merge, drop.
• Emphasis on avoiding branch/file conflicts, not on a full dashboard.

Wardian relevance: Hive reinforces that worktree isolation is becoming the default answer for parallel coding agents. Wardian should keep workspace identity, branch/worktree state, and merge/review state visible wherever agents appear.

Daintree

Source basis: Public repo and project site checked.

What it includes: Daintree is an Electron desktop agent console for supervising multiple CLI agents in local worktrees. It combines a worktree dashboard, panel grid, terminal/agent sessions, browser/dev previews, context injection, recipes, MCP tools, GitHub integration, and review-oriented diffs.

Distinctive components:

• Habitat metaphor around agents and worktrees.
• Support for many CLI agents, including Claude Code, Gemini CLI, Codex, OpenCode, Cursor Agent, Kiro, Copilot, Goose, Aider, and others.
• Agent state detection such as idle, working, waiting, completed, and failed.
• Context injection through CopyTree-style structured context.
• Recipes for multi-terminal launch presets and variable substitution.
• MCP server exposing Daintree actions such as creating worktrees, spawning terminals, injecting context, and running Git operations.
• Resource profiles and worktree monitoring as local fleet-management infrastructure.

Wardian relevance: Daintree is directly relevant to Wardian's ecological framing. It shows the metaphor becomes concrete when tied to practical surfaces: worktree identity, branch state, diffs, and action-needed signals.

Biomelab

Source basis: Public repo and project site checked.

What it includes: Biomelab is a Go/Fyne desktop GUI for managing Git worktrees and the coding agents running inside them. It is more of a monitoring and worktree dashboard than an agent runtime: it detects running agents, IDEs, terminals, branch status, PR/MR status, and CI status.

Distinctive components:

• Multi-repo tree with worktree cards.
• Process scanning for Claude, Kiro, Copilot, Codex, OpenCode, and Gemini.
• Terminal and IDE detection per worktree.
• PR/MR status through GitHub/GitLab CLIs.
• Docker Sandbox mode with one sandbox per agent per repo.
• Keyboard-first desktop GUI actions for create/delete worktree, fetch PR, push/create PR, open terminal/editor, and sandbox lifecycle.

Wardian relevance: Biomelab reinforces that worktree state should be visible at the same level as agent state. Wardian should not treat workspace paths as incidental metadata; they are part of the agent's operational identity.

AWS CLI Agent Orchestrator

Source basis: Public repo checked.

What it includes: AWS CLI Agent Orchestrator is a Python local orchestrator for AI coding CLIs. It runs agents in isolated tmux sessions and coordinates supervisor-worker patterns over MCP. It exposes CLI commands, a bundled web UI, REST APIs, and MCP management/control surfaces.

Distinctive components:

• Supervisor-worker orchestration using handoff, assign, and send_message.
• tmux session isolation with human attach/steer support.
• Cross-provider profiles for Kiro CLI, Claude Code, Codex, Amazon Q, Gemini, Kimi, Copilot, and OpenCode.
• Web UI, CLI, REST API, MCP server, and ops MCP server as separate control planes.
• Tool restrictions, scheduled flows, skills, plugins, terminal restore, and outbound event hooks.

Wardian relevance: This is a useful surface-level reference for Wardian. It validates a terminal-native orchestration layer where agents are visible, task-scoped, and workspace-aware. Wardian should go further by preserving persistent roster identity, UI observability, provider-specific PTY state, and Markdown/disk-inspectable truth.

Claude Squad

Source basis: Public repo checked.

What it includes: Claude Squad is a Go terminal app for managing multiple Claude Code, Codex, Gemini, Aider, and other local-agent sessions in separate Git workspaces. It uses tmux for isolated terminal sessions and Git worktrees for branch/workspace isolation.

Distinctive components:

• TUI for a squad of coding agents.
• Local terminal multiplexing.
• Worktree-backed session creation, pause/resume, checkout, and commit/push actions.
• Preview and diff tabs inside the TUI.
• Configurable profiles for alternate agent commands.
• Charm Bubble Tea/Lip Gloss-style TUI stack plus PTY and Git dependencies.

Wardian relevance: Claude Squad highlights the ergonomic value of a compact roster, keyboard-first navigation, and local session switching. Wardian's GUI should keep these same virtues: dense status, rapid switching, clear activity indicators, and no hidden agent work.

Archon

Source basis: Public repo checked.

What it includes: Archon defines agentic development workflows as YAML and runs them through a deterministic harness. It combines CLI execution, workflow definitions, worktree isolation, and a web UI for building and observing workflows.

Distinctive components:

• YAML workflow source of truth.
• Deterministic and AI-driven node types.
• Worktree isolation for parallel runs.
• Visual workflow builder and execution view.
• Adapters for developer and collaboration surfaces.

Wardian relevance: Archon is both a workflow-system reference and a multi-agent orchestrator reference. For Wardian, the most important lesson is that agents need a construction surface that can be reviewed as text, while humans need a visible run surface with node state, logs, approvals, and artifacts.

GUI and Web Command Centers

Agor

Source basis: Public repo checked.

What it includes: Agor is a web command center and shared spatial canvas for coding agents and long-lived assistants. Worktrees are the anchor entity: sessions, environments, prompts, PRs, comments, and boards converge around each worktree.

Distinctive components:

• Spatial canvas for agentic work.
• Boards and zones that can trigger templated prompts when sessions/worktrees move through the canvas.
• Real-time multiplayer features, comments, terminals, and shared sessions.
• MCP endpoint so agents can operate Agor actions themselves.
• Rich chat UX with token/cost accounting, structured tool blocks, model/effort selectors, and conversation trees.
• Environment management with dev servers and unique ports.

Wardian relevance: Agor shows a distinct GUI pattern: place-based orchestration rather than only lists or tabs. Wardian should treat spatial layout carefully, using it where it clarifies ownership and workflow state rather than as decoration.

webmux

Source basis: Public repo and project site checked.

What it includes: webmux is a Bun/TypeScript CLI plus web dashboard for managing parallel AI coding agents. It owns worktree lifecycle, tmux layout, runtime events, service health checks, PR/CI display, Linear integration, Docker sandboxes, and a separate mobile-friendly chat view.

Distinctive components:

• WebSocket terminal streaming from tmux-managed worktrees.
• .webmux.yaml source of truth for worktree root, services, pane layout, profiles, runtime, sandboxes, linked repos, startup envs, and lifecycle hooks.
• Docker sandbox profiles with mount and env-passthrough controls.
• PR, CI, review comment, Linear issue, and service health surfaces.
• Auto-name support using configured LLM provider keys.

Wardian relevance: webmux is relevant because it connects GUI observability with text-defined runtime configuration. Wardian should follow that line: dashboards should be reproducible from durable definitions, not only ad hoc UI state.

OctoAlly

Source basis: Public repo and project site checked.

What it includes: OctoAlly is a local-first web dashboard with optional Electron desktop shell for Claude Code and OpenAI Codex sessions. It manages projects, sessions, specialist agents, interactive terminals, source control, browser panels, and voice dictation from one dashboard.

Distinctive components:

• Active sessions grid with live WebSocket output.
• tmux and dtach-backed persistence, including pop-out/adopt-back terminal flows.
• 36 built-in specialist agents plus custom .claude/agents/*.md definitions.
• Git source control with diffs, staging, commit history, and file explorer.
• SQLite/Fastify backend, React dashboard, Electron desktop app, and local/cloud speech-to-text.

Wardian relevance: OctoAlly is a useful reference for web-based session visibility. Wardian should provide comparable real-time output awareness while preserving local PTY truth and persistent roster identity.

Overstory

Source basis: Public repo checked.

What it includes: Overstory is a multi-agent orchestration system for AI coding agents with CLI, web UI, and TUI dashboard surfaces. It spawns worker agents in isolated Git worktrees, coordinates them through SQLite mail, supports pluggable runtime adapters, and merges work back with conflict-resolution logic. Newer Claude workers run headless by default and surface through the web UI, with tmux as an opt-in live-steering escape hatch.

Distinctive components:

• Worker agents in isolated Git worktrees.
• SQLite-backed mail system with typed messages and broadcast support.
• Pluggable AgentRuntime adapters for Claude, Pi, Copilot, Codex, Gemini, Sapling, OpenCode, Cursor, Aider, Goose, Amp, and custom adapters.
• Web UI via ov serve, live TUI dashboard via ov dashboard, and detailed CLI observability commands.
• FIFO merge queue with tiered conflict resolution.
• Tiered watchdog/monitor system, tool-call guards, checkpoint restore, trace/replay/log/cost views, and persistent coordinator/orchestrator roles.

Wardian relevance: Overstory is important because it goes beyond launching many agents. It treats inter-agent communication and merge coordination as first-class orchestration responsibilities. Wardian should similarly model cross-agent messages, ownership, dependencies, and merge/readiness states rather than leaving them as hidden chat transcript details.

OpenHands

What it includes: OpenHands is a software engineering agent platform with web and CLI surfaces. It provides a runtime where agents can modify code, run commands, browse, and produce development artifacts while humans supervise from an application surface.

Distinctive components:

• Browser-accessible software engineering agent workspace.
• Runtime sandbox for command execution and code edits.
• Visibility into agent actions, files, and task progress.
• Developer-oriented loop rather than generic chat only.

Wardian relevance: OpenHands shows the value of combining terminal output, file changes, browser state, and task progress in one observable surface. Wardian's differentiator is the persistent multi-agent habitat: many named agents, long-running sessions, local provider terminals, and workflow telemetry in the same command center.

SuperAGI

What it includes: SuperAGI is an open-source autonomous agent platform with a web interface, tool integrations, memory, marketplace concepts, and agent execution management.

Distinctive components:

• Web dashboard for creating and running agents.
• Tool and agent marketplace concepts.
• Memory and knowledge support for autonomous agents.
• Execution monitoring from a platform UI.

Wardian relevance: SuperAGI is a useful reference for lifecycle visibility and agent management through a GUI. Wardian should avoid becoming only a web-style control panel; its local-first strength is that all sessions, skills, workspace state, and telemetry remain inspectable on disk.

AutoGPT Platform

What it includes: AutoGPT has evolved into a platform for creating, deploying, and managing continuous agents. Its platform direction includes a frontend, server, marketplace, and block-based agent workflow construction.

Distinctive components:

• Visual block-based agent workflows.
• Server and frontend separation.
• Marketplace for reusable blocks or agents.
• Continuous-agent orientation.

Wardian relevance: AutoGPT Platform is useful for understanding how agent building blocks can become reusable products. Wardian should apply that idea locally: reusable workflow blocks, agent classes, and skills should remain filesystem-visible and source-controllable.

Flowise

What it includes: Flowise is a low-code visual builder for LLM applications, including chatflows, agentflows, assistants, tools, memory, and deployment integrations.

Distinctive components:

• Web canvas for LLM and agent flows.
• Agentflow and sequential agentflow concepts.
• Integration nodes for tools, vector stores, models, and memory.
• Deployment and API surfaces around visual flows.

Wardian relevance: Flowise demonstrates the accessibility of node-first configuration. Wardian should support visual composition, but not require humans or agents to treat the canvas as the only authoring surface.

Libraries and Frameworks

AutoGen

What it includes: AutoGen is a Microsoft framework for building applications with multiple conversational agents. It includes agent abstractions, group chat patterns, tool use, distributed runtimes, and related Studio tooling for no-code prototyping.

Distinctive components:

• Multi-agent conversation patterns.
• Group chat and speaker-selection orchestration.
• Tool-use and code-execution agent patterns.
• Optional Studio surface for prototyping agent teams.

Wardian relevance: AutoGen is a strong reference for message-level multi-agent coordination. Wardian should learn from its group conversation patterns while adding the operational layer AutoGen does not own by itself: terminal sessions, provider process lifecycle, persistent roster state, and filesystem truth.

Microsoft Agent Framework

What it includes: Microsoft Agent Framework is an open-source framework for multi-agent applications. Its public positioning emphasizes agents, workflows, memory, tools, observability, MCP, and A2A-style interoperability.

Distinctive components:

• Enterprise-oriented agent and workflow primitives.
• Protocol-aware interoperability posture.
• Memory, tools, and observability concepts.
• Multi-agent orchestration beyond a single chat loop.

Wardian relevance: This is relevant less as a UI reference and more as a governance reference. Wardian should keep clean contracts for provider runtime, agent identity, tools, memory, workflow events, and cross-agent communication so it can interoperate instead of becoming a closed local island.

CrewAI

What it includes: CrewAI is a framework for multi-agent automation. It separates autonomous role-based crews from flows that provide more precise event-driven control.

Distinctive components:

• Role-based agent crews.
• Task and process abstractions.
• Deterministic flows alongside autonomous teams.
• YAML scaffolding for agent and task definitions.

Wardian relevance: CrewAI's distinction between crews and flows maps cleanly to Wardian's need to differentiate agent delegation from workflow control. A Wardian workflow node that delegates to an agent should be visibly different from a node that enforces control logic.

AgentScope

What it includes: AgentScope is a framework for building multi-agent applications. It includes agent abstractions, structured message passing, service/tool use, human-in-the-loop steering, memory, planning, MCP and A2A support, observability, and deployment options.

Distinctive components:

• Multi-agent message and service abstractions.
• Distributed execution patterns.
• Message hub and pipeline APIs for multi-agent conversations and workflows.
• OpenTelemetry-oriented observability and local/cloud deployment options.
• Structured APIs for agent communication and runtime integration.

Wardian relevance: AgentScope is a useful reference for separating the agent programming model from the observability surface. Wardian should give each agent message, status change, and workflow event enough structure to support both UI display and machine-readable coordination.

MetaGPT

What it includes: MetaGPT organizes agents using a software-company metaphor. It assigns roles such as product manager, architect, engineer, and QA, then coordinates artifact production and handoffs through a structured multi-agent process.

Distinctive components:

• Role-specialized agents modeled after software teams.
• Standard operating procedure style coordination.
• Artifact handoffs across product, design, engineering, and QA roles.
• CLI/framework orientation for generating software outputs.

Wardian relevance: MetaGPT's value is its legible role structure. Wardian agent classes, teams, and workflow role mappings should make responsibilities explicit enough that humans can understand who is supposed to produce what.

CAMEL

What it includes: CAMEL is a framework and research ecosystem for communicative agents, role-playing agent societies, data generation, and multi-agent collaboration.

Distinctive components:

• Role-playing communicative agent patterns.
• Multi-agent society and simulation concepts.
• Toolkits, memory, and data generation components.
• Research-oriented agent collaboration primitives.

Wardian relevance: CAMEL is useful as a conceptual reference for agent-agent communication. Wardian should operationalize those conversations: who spoke, what task context they had, which workspace they touched, what artifacts changed, and how the interaction is replayed.

Adjacent Local Agent Surfaces

Some systems are not primarily multi-agent orchestrators, but they still inform Wardian's interaction design:

• OpenCode: terminal-native AI coding agent with strong local developer ergonomics.
• Goose: local agent experience with CLI and desktop surfaces.
• Aider: terminal-first pair programming agent with strong Git workflow integration.

These are useful references for single-agent ergonomics, provider interaction, and developer trust. They should not be treated as direct multi-agent command center references unless they add explicit orchestration or roster semantics.

Wardian Positioning

Wardian sits at the intersection of these categories:

• GUI/web systems prove the value of human-observable dashboards.
• CLI/TUI systems prove the value of fast local control and worktree-aware dispatch.
• Organization and SDLC control planes prove the value of explicit management primitives: goals, ownership, budgets, approvals, lifecycle phases, work products, and audit trails.
• Frameworks prove the value of structured agent roles, messages, tools, and workflow state.

Wardian's direction should be hybrid and local-first: visible agent terminals, durable roster state, workflow graph telemetry, filesystem-inspectable skills and definitions, and enough structured APIs that agents can construct and operate the system without depending on fragile UI actions.