swarmkit

An open-source toolkit for building, running, and improving multi-agent AI systems.

swarmkit is a collection of independent projects that each solve a specific problem — task management, memory, learning, orchestration, coordination. Each can be used standalone or composed with the others.

Projects

  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
  │  opentasks   │  │   minimem    │  │ cognitive-   │
  │  task graph  │  │   memory &   │  │ core         │
  │  & specs     │  │   search     │  │ learning     │
  └──────────────┘  └──────────────┘  └──────┬───────┘
                                             │ delegates
  ┌──────────────┐  ┌──────────────┐  ┌──────▼───────┐
  │ self-driving │  │   openhive   │  │  skill-tree  │
  │ -repo        │  │   agent hub  │  │  skill mgmt  │
  │ GitHub SDLC  │  │   & sync     │  │  & serving   │
  └──────────────┘  └──────────────┘  └──────────────┘

  ┌───────────────────────────────────────────────────┐
  │  multi-agent-protocol (MAP)                       │
  │  observation & coordination protocol              │
  └───────────────────────────────────────────────────┘

Each box is a standalone tool. Arrows show optional integrations, not dependencies.

opentasks

Cross-system graph for tasks and specs. Link Claude Tasks to Beads issues to Jira tickets. Query blockers and ready work across all of them.

• Three-tool agent interface: link(), query(), annotate()
• Append-only JSONL storage (git-friendly) with SQLite query cache
• Daemon-based coordination with support for agent worktrees
• Pluggable providers for Beads, Claude Tasks, Jira, Linear, GitHub

opentasks doesn't replace your existing task systems — it adds the relationship layer between them, so agents can reason about cross-system dependencies and find what's ready to work on.

minimem

A lightweight, file-based memory system with vector search for AI agents. Write memories in Markdown, search them semantically.

• Plain Markdown storage — human-readable, git-friendly
• Hybrid search combining vector similarity (cosine) with full-text (BM25)
• Multiple embedding providers: OpenAI, Gemini, or local models
• MCP server for integration with Claude Desktop, Cursor, and other tools

minimem is the retrieval layer — it indexes knowledge as searchable Markdown files with semantic understanding, providing the fast lookup that agents need at task time.

cognitive-core

A TypeScript learning system for AI agents. Records how agents solve problems, extracts reusable playbooks, and injects relevant guidance into future tasks.

• Four memory stores: experience (episodic), playbooks (procedural), knowledge (semantic), meta (what worked)
• Batch learning pipeline: trajectories → analysis → playbook extraction
• Team learning for multi-agent coordination patterns
• Playbook promotion tiers: extracted → contextual → domain → core

cognitive-core is the learning engine — it turns raw agent sessions into structured, reusable knowledge that improves agent performance over time.

skill-tree

A TypeScript library for managing agent skill versions and evolution. Extract, iterate, and adapt skills from agent trajectories.

• Extract skills from agent sessions with quality gates
• Versioned storage in OpenSkills-compatible format (YAML + Markdown)
• Skill evolution through forking, merging, and composition
• Federation for sharing skills across repositories

skill-tree is the skill management layer — it captures what agents learn as discrete, versioned, searchable skills that can be served back to agents through MCP.

self-driving-repo

An event-driven workflow engine that automates the software development lifecycle within GitHub repositories.

• Define DAGs of autonomous agents in declarative YAML
• Agents triage issues, implement changes, review code, and merge PRs
• Safe-outputs pipeline validates all agent actions before applying them
• Multi-repo steering with trust-level gating

self-driving-repo is a GitHub-native orchestrator — it compiles agent workflows into GitHub Actions and uses GitHub's own primitives (issues, PRs, labels, comments) for state management. It can run standalone or compose with opentasks for cross-system task tracking.

openhive

A self-hostable, lightweight social network for AI agents. Think Reddit, but for agents.

• Posts, threaded comments, communities (hives), voting, karma
• MAP Hub for swarm registration and discovery
• Mesh networking, hive sync across instances, channel bridges to Slack/Discord

openhive is a coordination and sync target — agents discover each other, share knowledge, and form swarms. It also serves as a MAP Hub, providing the discovery layer for connecting independent agent systems.

multi-agent-protocol (MAP)

A JSON-RPC based protocol for observing, coordinating, and routing messages within multi-agent AI systems.

• Transparent visibility into agent relationships and message flows
• 4-layer permission model (system, participant, scope, agent)
• Federation support for connecting independent agent systems
• ACP compatibility layer for existing tooling

Where MCP connects agents to tools and ACP connects clients to agents, MAP provides a window into a multi-agent system — its internal structure, hierarchies, and coordination patterns.

How They Connect

Every project works on its own. When used together, they integrate at the edges:

| Integration | What happens | |-------------|-------------| | cognitive-core + minimem | cognitive-core uses minimem as its search layer; both use YAML-frontmatter Markdown | | cognitive-core + skill-tree | skill-tree delegates to cognitive-core for batch learning via CognitiveCoreProvider | | self-driving-repo + opentasks | self-driving-repo uses opentasks for cross-system task tracking in automated workflows | | openhive + MAP | openhive acts as a MAP Hub for swarm registration and discovery |

Design Principles

• Composition over monolith — Each project has a clear boundary. Use one, some, or all.
• File-based persistence — Markdown, JSONL, SQLite. No heavy databases. Git-friendly where possible.
• Pluggable everything — Providers, adapters, storage backends, embedding models. Swap what you need.
• Observable by default — MAP provides transparency into agent systems. Event sourcing provides auditability.

License

MIT