SwarmClaw

swarmclaw · swarmclawai/swarmclaw · ★ 523 · last commit 2026-05-20

Self-hosted autonomous agent runtime with persistent memory, org-chart delegation, dreaming memory consolidation, and 23+ LLM providers — a practical Claude Code and LangChain alternative.

Best whenAgents should have persistent identity, consolidate their own memories during idle time (dreaming), and operate in organizational hierarchies with explicit d…

Skip ifStateless agents that forget between sessions, Single-provider lock-in

vs seeds

claude-flow(MCP-anchored multi-agent), but SwarmClaw's dreaming model, 23+ providers, and full web dashboard are unique across all …

Primitive shape 12 total

Skills 11 MCP tools 1

Summary

SwarmClaw — Summary

SwarmClaw is a self-hosted AI agent runtime and multi-agent framework that ships as an Electron desktop app, an npm global CLI (swarmclaw), and a Next.js web dashboard on port 3456. It supports 23+ LLM providers, a 6-primitive tool system (files, execute, memory, platform, browser, skills), agent delegation and spawning, schedules, "dreaming" (idle memory consolidation), conversation-to-skill learning with human review, and integration with Claude Code, Codex, Gemini, OpenCode, Copilot, Factory Droid, and other CLI backends.

Problem it solved: Most agent frameworks are tied to a single LLM provider and lack persistent agent identity, cross-session memory, organizational hierarchy (org chart with delegation), and autonomous scheduling — SwarmClaw is a full autonomous agent runtime, not just a session manager.

Distinctive traits: (1) "Dreaming" — agents autonomously consolidate memories during idle time via periodic dream cycles; (2) Org chart visualization — agents form a corporate hierarchy (CEO, Developer, Researcher) with visual delegation tracking; (3) 23+ LLM providers via OpenAI-compatible routing; (4) Conversation-to-skill learning with human review gate; (5) ClawHub skill registry (openclaw skills install swarmclaw).

Target audience: Teams building autonomous agent pipelines that need persistent identity, multi-provider flexibility, org-chart coordination, and scheduled autonomous work.

differs_from_seeds: Most similar to claude-flow (MCP-anchored multi-agent with memory) but SwarmClaw is a full autonomous agent runtime rather than a Claude Code augmentation. Unlike claude-flow (sqlite + HNSW vector, 305 MCP tools), SwarmClaw routes across 23+ providers, has first-class agent dreaming/memory consolidation, org-chart delegation, and ships as both a desktop app and an npm global package. The closest seed by memory architecture is ccmemory (cross-session memory), but SwarmClaw adds delegation, scheduling, connectors, and the dreaming model.

Overview

SwarmClaw — Overview

Origin

Created by swarmclawai. MIT license. npm package @swarmclawai/swarmclaw, version 1.9.35. Actively maintained as of 2026-05-20.

Philosophy

From README:

"Open-source self-hosted AI agent runtime and multi-agent framework for autonomous agent swarms. Agent memory, MCP tools, schedules, delegation, and 23+ LLM providers — a practical Claude Code and LangChain alternative."

SwarmClaw explicitly positions itself as an alternative to both Claude Code (for agent orchestration) and LangChain (for multi-agent framework). It is not a Claude Code augmentation — it is a standalone agent runtime.

Core metaphor

From the skill documentation:

"SwarmClaw is an AI agent runtime and multi-agent orchestration platform. It gives agents a uniform set of tools, persistent memory, connector integrations, and the ability to delegate work to other agents."

The 6 primitive tools (philosophy)

SwarmClaw's design gives every agent access to exactly 6 tools that cover all capabilities:

files — any file operation
execute — bash scripts (sandboxed or host)
memory — persistent knowledge across sessions
platform — tasks, communication, delegation
browser — headless browser for dynamic web content
skills — discover and load skill documentation

Dreaming model

Agents with dreaming enabled automatically consolidate memories during idle periods — producing dream_reflection and consolidated_insight memory entries. This mirrors how humans consolidate memories during sleep.

Target users

Teams who need autonomous, persistent, multi-provider agent infrastructure that can run unattended with scheduled tasks and organizational delegation.

Architecture

SwarmClaw — Architecture

Distribution

npm package: @swarmclawai/swarmclaw (global install)
Electron desktop app (macOS Apple Silicon/Intel, Windows, Linux AppImage + .deb)
Docker deployment option
CLI binary: swarmclaw (starts web server at http://localhost:3456)

Install

npm i -g @swarmclawai/swarmclaw
swarmclaw               # starts server at localhost:3456

# Desktop app: download from swarmclaw.ai/downloads
# Docker:
docker compose up -d --build

Data directory

macOS: ~/Library/Application Support/SwarmClaw
Windows: %APPDATA%\SwarmClaw
Linux: ~/.config/SwarmClaw

Key directories in repo

swarmclaw/
├── src/
│   └── app/
│       ├── home/        # Next.js dashboard pages
│       ├── agents/      # Agent management UI
│       ├── api/         # REST API routes
│       ├── marketplace/ # Skill marketplace
│       ├── knowledge/   # Knowledge base
│       ├── logs/        # Audit logs UI
│       └── inbox/       # Task inbox
├── skills/              # Built-in skills
│   ├── coding-agent/
│   ├── github/
│   ├── google-workspace/
│   ├── summarize/
│   ├── tools/           # Tool usage documentation
│   └── swarmclaw.md     # Platform skill (main doc)
├── electron/            # Electron main process
├── bin/swarmclaw.js     # CLI entry point
├── data/                # Runtime data
└── docker-compose.yml

Technology stack

Next.js (App Router) with React
Electron 33 for desktop distribution
TypeScript throughout
Tailwind CSS 4
@modelcontextprotocol/sdk for MCP integration

Required runtime

Node.js 22.6+
npm 10+
Docker Desktop (optional, for sandbox browser execution)

Components

SwarmClaw — Components

Agent primitives (6 universal tools every agent has)

Tool	Purpose
`files`	Read, write, edit, list, search files on workspace filesystem
`execute`	Run bash scripts (sandboxed or host), curl, shell commands
`memory`	Store/retrieve persistent knowledge (working + durable memory)
`platform`	Tasks, communication, delegation, projects, agent coordination
`browser`	Control headless browser for dynamic web content
`skills`	Discover and load skill documentation

Built-in skills (in `skills/`)

Skill	Purpose
`coding-agent`	Full-stack coding guidance for agents
`github`	GitHub API operations
`google-workspace`	Google Docs, Sheets, Gmail integration
`nano-banana-pro`	(specialty skill)
`nano-pdf`	PDF processing
`openai-image-gen`	Image generation
`resourceful-problem-solving`	General problem-solving framework
`skill-creator`	Create new skills via conversation
`summarize`	Document/conversation summarization
`tools/`	Tool usage documentation (files, execute, etc.)
`swarmvault`	Credential vault integration
`swarmclaw.md`	Platform skill: core SwarmClaw usage documentation

Web dashboard features

Feature	Purpose
Org chart view	Visual agent hierarchy with delegation and live activity
Agent chat	Per-agent chat with durable history, tools, operator controls
Inbox	Task management
Marketplace	Browse/install skills and extensions
Knowledge base	Searchable agent knowledge
Logs	Audit log viewer
Activity feed	Real-time agent activity
MCP servers	Configure and manage MCP connections
Connectors	Slack, email, Telegram, Discord bridge
Autonomy settings	Enable/disable agent autonomous behavior
Scheduler	Cron-based task scheduling per agent

Memory system

Working memory (session-scoped): scratch notes, intermediate results
Durable memory (cross-session): preferences, project facts, decisions
Dream memory: dream_reflection and consolidated_insight entries
Embeddings-based dedup (optional): near-duplicate reflection filtering
reflectionMinQuality gating for automatic memory writes

ClawHub / OpenClaw integration

openclaw skills install swarmclaw

Exposes SwarmClaw's management API to OpenClaw agents.

Prompts

SwarmClaw — Prompts

Verbatim excerpt 1: swarmclaw.md (platform skill — the main agent context document)

# SwarmClaw Platform

SwarmClaw is an AI agent runtime and multi-agent orchestration platform. It gives agents a uniform set of tools, persistent memory, connector integrations, and the ability to delegate work to other agents.

## The 6 Primitive Tools

Every agent has access to these core tools. They cover the full range of agent capabilities.

| Tool | Purpose | When to Use |
|------|---------|-------------|
| **files** | Read, write, edit, list, search files | Any file operation on the workspace filesystem |
| **execute** | Run bash scripts (sandboxed or host) | Shell commands, curl, data processing |
| **memory** | Store and retrieve persistent knowledge | Facts, preferences, decisions that should survive across sessions |
| **platform** | Tasks, communication, delegation, projects | Coordinating with humans and other agents |
| **browser** | Control a headless browser | Interactive web pages, JavaScript-rendered content |
| **skills** | Discover and load skill documentation | Learning how to use tools, APIs, or workflows |

## When to Load Skills

- Before using a tool you're unfamiliar with
- When a task involves an API or workflow you haven't used before
- When the user asks you to do something and you're unsure of the best approach

Prompting technique: Capability catalog injection. Every agent receives this as its base context. The skill system is self-referential — agents use the skills tool to look up other skills, making the documentation discoverable at runtime rather than front-loaded.

Verbatim excerpt 2: dreaming behavior specification (from swarmclaw.md)

## Dreaming

Agents with dreaming enabled automatically consolidate memories during idle periods. You can also trigger a dream manually:

#### Manual dream trigger
Use the platform API to trigger a dream cycle:
{ "tool": "execute", "command": "curl -s -X POST http://localhost:3456/api/memory/dream -H 'Content-Type: application/json' -d '{\"agentId\":\"YOUR_AGENT_ID\"}'" }

Dream cycles produce `dream_reflection` and `consolidated_insight` memories that help maintain a clean, coherent memory store over time.

Prompting technique: Self-administered maintenance protocol. The agent is instructed to trigger its own memory consolidation — an unusual inversion where the agent manages its own cognitive hygiene.

Verbatim excerpt 3: delegation protocol (from swarmclaw.md)

## Delegation

Agents can delegate work to other agents:
- **delegate**: route a task to a specific agent and wait for the result
- **spawn**: create a subagent that runs independently (fire-and-forget or session-based)
- Use `agents.list` to discover available agents and their specializations

Prompting technique: Explicit delegation API contract. Agents know how to spawn and delegate — not just humans. This enables true agent-to-agent orchestration.

Uniqueness

SwarmClaw — Uniqueness & Positioning

differs_from_seeds

SwarmClaw occupies a different category from all 11 seeds — it is not a Claude Code augmentation plugin but a full autonomous agent runtime platform. The closest seeds are ccmemory (cross-session memory via Neo4j) and claude-flow (MCP-anchored multi-agent with SQLite+vector memory), but SwarmClaw adds 23+ LLM providers, org-chart delegation visualization, the dreaming/memory-consolidation model (unique in this corpus), conversation-to-skill learning, and continuous background daemon operation. Unlike claude-flow's 305 MCP tools (all outbound from the app), SwarmClaw's 6 primitive tools are available TO each agent — a simpler and more controlled capability surface. The explicit credential injection + redaction system (env vars → auto-scrubbed from output) is a production security feature absent from all seeds.

Positioning

"A practical Claude Code and LangChain alternative" — explicitly targets both the coding-agent and the AI framework communities
Self-hosted emphasis: all data stays in the user's OS data directory or their own Docker deployment
23+ LLM providers: maximum flexibility vs. single-model frameworks
Dreaming model: distinctive cognitive metaphor for memory management

Observable failure modes

Complexity: the breadth of features (org chart, dreaming, connectors, 23 providers, schedules) creates a steep learning curve
No git worktree isolation: agents operate on the host filesystem (file conflicts possible)
Credential secret recovery complexity (v1.9.35 changelog mentions ongoing issues)
macOS Gatekeeper issues documented in README (damaged-app warnings for ad-hoc-signed builds)

Inspired by

LangChain (multi-agent framework patterns)
Claude Code (CLI-based coding agent)

Competitors named in README

Claude Code (explicitly named as alternative)
LangChain (explicitly named as alternative)

Cross-references

OpenClaw / ClawHub ecosystem (separate product family, integrated)
Hermes Agent (separate product, integrated)

Workflow

SwarmClaw — Workflow

Agent lifecycle

idle → running → completed | error | waiting

Agents are long-lived entities with persistent identity. They are not spawned and destroyed per task (unlike claude-swarm workers).

Delegation workflow

Phase	Action	Artifact
Task creation	Human or agent creates task, assigns to agent	Task record in database
Dispatch	Orchestrator agent delegates via `platform.communicate.delegate`	Task assigned to specific agent
Execution	Worker agent runs with its configured tools and skills	Output, memory updates
Review (optional)	Human reviews output in agent chat	Approval or follow-up
Learning	Agent can create skills from conversation via `skill-creator`	New skill .md file

Scheduling

Agents have cron-based schedules configured in the UI
Scheduled prompts run autonomously at the scheduled time
Powers "heartbeats" — agents that regularly check on state and report

Dreaming

Idle agents with dreaming enabled auto-trigger dream cycles
Dream cycle: consolidates working memory → dream_reflection + consolidated_insight
Manual trigger via REST API: POST /api/memory/dream

Automations

Trigger agents from external events (not documented as extensively as Dorothy)
Connectors: Slack, email, Telegram, Discord enable remote-control

Approval gates

reflectionMinQuality gates automatic reflection memory writes
Skill creation from conversation requires human review gate (based on CLAUDE.md documentation)
Human-in-the-loop via chat UI for any agent task

Memory Context

SwarmClaw — Memory & Context

Memory architecture

SwarmClaw has the most sophisticated memory system in this batch:

Memory types

Type	Scope	Content
Working memory	Session-scoped	Scratch notes, intermediate results
Durable memory	Cross-session	User preferences, project facts, decisions
Dream reflections	Cross-session	`dream_reflection` entries from idle consolidation
Consolidated insights	Cross-session	`consolidated_insight` entries from dream cycles

Memory operations (via `memory` tool)

Store: { "tool": "memory", "action": "store", "content": "...", "category": "..." }
Retrieve: { "tool": "memory", "action": "list", "category": "dream_reflection" }
Search: semantic search (if embeddings configured)

Automatic memory surfacing

Relevant memories are automatically surfaced in agent context when the agent starts a new conversation.

Dreaming (memory consolidation)

Idle agents with dreaming enabled auto-trigger dream cycles
Dream cycle consumes working memory → produces dream_reflection and consolidated_insight
reflectionMinQuality setting gates quality of automatic reflection writes
Embedding-based dedup (optional) prevents near-duplicate reflection entries
Per-agent dreamConfig can override global dream settings

Compaction routing

compactionProvider setting routes auto-compaction summaries through a configurable (potentially cheaper/faster) model — distinct from the main agent model.

Credential security

Credentials are:

Configured per agent in the UI
Injected as environment variables into execute tool runs
Automatically redacted from all tool output and chat history

State files

OS app-data directory: ~/Library/Application Support/SwarmClaw (macOS)
Session history, agent configs, memories stored in the platform's database

Orchestration

SwarmClaw — Orchestration

Multi-agent support

Yes — org chart with delegation, spawning, and hierarchical coordination.

Orchestration pattern

Hierarchical with delegation — agents can:

delegate: route a task to a specific agent and wait for result (synchronous)
spawn: create a subagent that runs independently (fire-and-forget or session-based)

The visual org chart shows the delegation hierarchy at runtime.

Agent types (examples from org chart)

CEO agent: high-level goal + delegation
Developer agent: coding tasks
Researcher agent: information gathering
Orchestrator agent: workflow coordination

Isolation mechanism

Process — each CLI backend (Claude Code, Codex, etc.) runs as a separate subprocess. No git worktree isolation.

Multi-provider / multi-model support

Yes — 23+ LLM providers:

OpenClaw, Claude (Anthropic), GPT (OpenAI), Gemini (Google), OpenRouter, Ollama, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, Hermes, and more
Per-agent dreamConfig can route dream cycles through different models
compactionProvider for routing compaction summaries
All OpenAI-compatible providers use a shared streamOpenAiChat handler

Scheduling

Cron-based per-agent schedules for autonomous task execution.

Execution mode

Continuous / background daemon — SwarmClaw runs as a server (swarmclaw starts a daemon on port 3456); agents are persistent and run continuously or on schedule.

Connectors

Slack, email, Telegram, Discord — external events can trigger agent tasks.

Memory consolidation

Dream cycles consolidate agent memory autonomously during idle periods — a background autonomous maintenance process.

Consensus mechanism

None formal — hierarchical delegation with human oversight.

Ui Cli Surface

SwarmClaw — UI & CLI Surface

CLI binary: `swarmclaw`

npm i -g @swarmclawai/swarmclaw
swarmclaw               # starts Next.js server at localhost:3456
swarmclaw server --build  # build mode

The CLI is a server launcher, not an interactive agent CLI. All management happens via the web dashboard.

Web dashboard (port 3456)

Built with Next.js (App Router) + React 19 + Tailwind CSS 4.

Page/Feature	URL	Purpose
Home	/home	Overview and activity
Agents	/agents	Manage agents, org chart view
Org chart	/agents (org chart tab)	Visual delegation hierarchy with live activity
Agent chat	/agents/{id}	Chat with specific agent, view history
Inbox	/inbox	Task inbox
Marketplace	/marketplace	Browse/install skills
Knowledge	/knowledge	Knowledge base
Logs	/logs	Audit log viewer
Activity	/activity	Real-time agent activity stream
MCP Servers	/mcp-servers	Configure MCP connections
Connectors	/connectors	Slack, email, Telegram, Discord
Autonomy	/autonomy	Enable/disable autonomous behaviors

Desktop app

Full Electron 33 desktop app — all of the above in a desktop window. Available for macOS (Apple Silicon + Intel), Windows, Linux (AppImage + .deb).

Observability

Audit logs at /logs
Real-time activity feed
Per-agent conversation history
Memory inspection via chat interface
No formal JSONL replay capability

ClawHub

Skills installable via openclaw skills install swarmclaw — cross-platform skill registry integration.

Mobile / remote access

Web dashboard accessible from any browser; no dedicated mobile app or QR code.

Related frameworks

same archetype · same primary tool · same memory type

MemPalace ★ 53k

A10 Memory engine

Verbatim local-first AI memory with 96.6% R@5 retrieval on LongMemEval using zero API calls — structured into a palace hierarchy…

Beads (Yegge) ★ 24k

A10 Memory engine

Dolt-powered distributed graph issue tracker where AI agents track tasks with hierarchical IDs and dependency edges, claim work…

deepagents (LangChain) ★ 23k

A10 Memory engine

Opinionated Python agent harness on top of LangGraph with sub-agents, filesystem, memory, and context compaction bundled in

agentmemory ★ 18k

A10 Memory engine

Persistent, searchable memory for AI coding agents that captures every tool interaction, compresses it via LLM, and injects…

Open Multi-Agent ★ 6.3k

A10 Memory engine

Give a natural-language goal to a coordinator agent and get a dynamically decomposed, parallelized task DAG executed by…

Basic Memory ★ 3.1k

A10 Memory engine

Gives AI agents a persistent, human-readable knowledge graph of project decisions, observations, and relations stored as plain…

Distribution

Type: desktop-app
License: MIT
Install: one-liner
Version: 1.9.35

Surfaces

CLI binary: swarmclaw
CLI subcmds: 2
Local UI: web-dashboard
UI port: 3456
Tech stack: Next.js App Router, React 19, Tailwind CSS 4, Electron 33

Components

Commands: 0
Skills: 11
Subagents: 0
Hooks: 0
MCP servers: 1
Scripts: 2
Templates: 0

Workflow

Phases: 5
Approval gates: 1
Spec format: none
Spec storage: db
Delta or full: none

Orchestration

Multi-agent: Yes
Pattern: hierarchical
Isolation: process
Consensus: none
Prompt chaining: Yes

Multi-model

Multi-model: Yes
BYOK: Yes
Modal: text+vision

Execution

Mode: background-daemon
Crash recovery: Yes
Compaction: Yes
Session handoff: Yes
Streaming: Yes

Memory

Type: proprietary
Persistence: global
Search: vector
State files: 3 files

Quality

TDD: No
TDD mechanism: none
Self-review: none

Git / Observability

Auto commit: No
Auto PR: No
Auto merge: No
Worktree/feat: No
Audit log: Yes
Audit format: proprietary
Replay: No

Tools

Primary: claude-code
Targets: 10
Portability: high

Signals

Stars: 523
Last commit: 2026-05-20
Maintainer: active
Quality score: 5.5/10

Summary

SwarmClaw — Summary

Overview

SwarmClaw — Overview

Origin

Philosophy

Core metaphor

The 6 primitive tools (philosophy)

Dreaming model

Target users

Architecture

SwarmClaw — Architecture

Distribution

Install

Data directory

Key directories in repo

Technology stack

Required runtime

Components

SwarmClaw — Components

Agent primitives (6 universal tools every agent has)

Built-in skills (in skills/)

Web dashboard features

Memory system

ClawHub / OpenClaw integration

Prompts

SwarmClaw — Prompts

Verbatim excerpt 1: swarmclaw.md (platform skill — the main agent context document)

Verbatim excerpt 2: dreaming behavior specification (from swarmclaw.md)

Verbatim excerpt 3: delegation protocol (from swarmclaw.md)

Uniqueness

SwarmClaw — Uniqueness & Positioning

differs_from_seeds

Positioning

Observable failure modes

Inspired by

Competitors named in README

Cross-references

Workflow

SwarmClaw — Workflow

Agent lifecycle

Delegation workflow

Scheduling

Dreaming

Automations

Approval gates

Memory Context

SwarmClaw — Memory & Context

Memory architecture

Memory types

Memory operations (via memory tool)

Automatic memory surfacing

Dreaming (memory consolidation)

Compaction routing

Credential security

State files

Orchestration

SwarmClaw — Orchestration

Multi-agent support

Orchestration pattern

Agent types (examples from org chart)

Isolation mechanism

Multi-provider / multi-model support

Scheduling

Execution mode

Connectors

Memory consolidation

Consensus mechanism

Ui Cli Surface

SwarmClaw — UI & CLI Surface

CLI binary: swarmclaw

Web dashboard (port 3456)

Desktop app

Observability

ClawHub

Mobile / remote access

Related frameworks

Built-in skills (in `skills/`)

Memory operations (via `memory` tool)

CLI binary: `swarmclaw`