Skip to content

Angelo

Multi-agent coordination framework for Cursor and Claude Code. Four MCP servers — coordinator, memory, memory-artifacts, and zettelkasten — expose task-graph orchestration, persistent knowledge management, DVC/S3 experiment artifacts, and multi-source literature-review tools over stdio.

Angelo end to end: a single request becomes research — sources mined into grounded claims, clustered into a semantic knowledge tree, flattened into an outline and turned into a coding plan — then handed to the coordinator, which executes it in waves (engineer, reviewer, critic, tester) to produce both a codebase and a memory record; the codebase ships the app, and when the user asks why a decision was made, the agent queries the memory tree and recalls the rationale in a chat thread

Where to go

  • Getting started

    Learn angelo by setting up a project and running it for the first time.

  • Explore the features

    The three pillars — coordinator, memory, and zettelkasten — explained, with the decision record mined from the memory graph.

  • User guides

    Task-focused recipes: install, update, use the dashboards, run experiments, build a matrix, and troubleshoot.

  • Reference

    Auto-generated MCP tool reference and Python API docs.

How the pieces fit together

Angelo is four MCP servers over stdio plus an install CLI, sharing two file-backed knowledge stores in your repo. The coordinator orchestrates work, records outcomes to memory, and drives grounded extraction straight into the zettelkasten. Memory can optionally be backed by memory-artifacts for large files and experiments on a remote. A separate optional package — stream — feeds the zettelkasten from a continuous document source; it sits alongside this core picture rather than inside it.

optional add-on records to drives extraction backs coordinator task graphs memory research tree · skills memory-artifacts large files · experiments zettelkasten literature graph
Solid = core: coordinator, memory, and zettelkasten. Dashed = optional: memory-artifacts (large files & experiments on a DVC/S3 remote). All state is plain markdown + YAML in .memory/ and .zettelkasten/, committed to git; caches under .angelo/ are disposable.

Three design commitments hold it together:

  • Files are the source of truth. .memory/ and .zettelkasten/ are markdown
  • YAML, committed to git, so your knowledge travels with the repo and its history. Caches under .angelo/ are disposable and rebuilt on demand.
  • Lean MCP surface. Cursor caps the total number of tools across servers, so each server keeps a deliberately small, dispatch-style tool set.
  • Two dashboards, one per store. Each knowledge store ships a read-mostly web UI, launched from its own MCP server: the memory dashboard (angelo-dashboard) over .memory/, and the zettelkasten dashboard (angelo-zk-dashboard) over .zettelkasten/.

Design choices recorded during development are promoted into browsable architecture decision records, generated from the memory graph.

The three pillars

  • Coordinator

    Task-graph orchestration: scope a task, design a DAG of agents, execute it in waves of subagents. Lightweight by design — no runtime, no server, riding the editor's native subagent spawning. Console script angelo-coordinator.

  • Memory

    Persistent knowledge across sessions: a research tree, a skills library, a live code graph, and session continuity — plus a toggleable experiments & artifacts companion (memory-artifacts). Console script angelo-memory.

  • Zettelkasten

    Multi-source literature-review knowledge graph: read a whole corpus into grounded notes, then organize them into spines and comparison matrices without forking the truth. Console script angelo-zettelkasten.

Project layout

See each package's README for module-level detail: