Skip to content
/
Tier A A10 Memory engine

Agor

agor · preset-io/agor · ★ 1.2k · last commit 2026-05-25

Team-first spatial canvas for AI agent work — branches as cards on a Figma-style board with zone-triggered prompts, real-time multiplayer, and session genealogy.

Best whenBranch is the unit of work, not the task or the session — everything (conversation, dev environment, PR, prompts) anchors to one git branch, and teams collab…
Skip ifSingle-user agent tools, Ephemeral sessions without ancestry
vs seeds
claude-flow(multi-agent + worktree), but Agor adds multiplayer, spatial orchestration, and session trees as first-class design feat…
Primitive shape 5 total
Commands 4 MCP tools 1
00

Summary

Agor — Summary

Agor is a self-hosted team workspace for AI agents — a Figma-style 2D spatial canvas where git branches are the unit of work, coding agents (Claude Code, Codex, Gemini, OpenCode, Copilot) run in isolated branch environments, teams collaborate in real-time with live cursors and spatial comments, and agents drive their own sessions via an MCP HTTP endpoint. The daemon runs locally (npm daemon + SQLite via LibSQL) or via Docker/Postgres, with a React web UI and an oclif CLI.

Problem it solved: Existing agent tools are single-user and single-session. Agor makes agent work multiplayer and spatial: teams see live cursors, leave scoped comments, share sessions, and spatial zones on the canvas trigger automated agent prompts when branches are dropped into them.

Distinctive traits: (1) Figma-style 2D spatial canvas ("board") with zones that auto-trigger agent prompts; (2) Real-time multiplayer (live cursors, facepile, shared sessions, shared dev environments); (3) Session genealogy — sessions can be forked and spawned as sub-sessions with full ancestry tracking; (4) Agents have MCP tokens issued per session and can drive their own Agor session via the MCP HTTP endpoint; (5) Sandpack-powered live artifact rendering (interactive apps on the canvas).

Target audience: Engineering teams who want a shared, spatial workspace for coordinating AI agent work across branches — not solo developer tools.

differs_from_seeds: Agor is closest to taskmaster-ai in the MCP-anchored toolserver cluster (agents drive via MCP), but adds multiplayer team collaboration, spatial canvas UX, session genealogy, and branch-centric organization — none present in the 11 seeds. The Figma-style canvas metaphor is unique in this corpus.

01

Overview

Agor — Overview

Origin

Created by the preset-io team (Preset/Apache Superset ecosystem). License unknown (README doesn't specify; no LICENSE field in GitHub API response). npm package agor-live. Website: agor.live. Version 0.1.0 (CLI). Actively maintained.

Philosophy

From README:

"Team command center for all things agentic." "Agor is a shared canvas where coding agents (Claude Code, Codex, Gemini) and long-lived assistants run side-by-side on isolated git branches — the anchor entity where sessions, dev environments, prompts, and PRs converge."

Three foundational concepts:

  1. Branches — the unit of work: one git branch, one board card, with its own isolated environment and conversations
  2. Sessions & Trees — agent conversations with genealogy: fork to explore alternatives, spawn sub-sessions
  3. Boards & Zones — a Figma-style 2D canvas: drop a branch into a zone to trigger a templated prompt

Key principle

"Multiplayer is the core differentiator. Live cursors, facepile, scoped comments, shared sessions and dev envs."

Pledge

"⭐️ I pledge to fix a GitHub issue for every star Agor gets :)"

Target users

Engineering teams wanting a shared, visual, spatial workspace for AI agent coordination — the opposite of solo developer tools.

02

Architecture

Agor — Architecture

Distribution

  • npm global package: agor-live (wraps the daemon)
  • CLI binary: agor (oclif-based)
  • Web UI: React app served by the daemon
  • Docker deployment for teams
  • Postgres variant for production

Install

npm install -g agor-live
agor init           # creates ~/.agor/ and database
agor daemon start   # runs in the background
agor open           # opens the UI in browser

Architecture diagram (from README)

Clients: CLI (oclif) + Web UI (React)
  ↓ REST + WebSocket (Feathers Client)
Agor Daemon (FeathersJS Server)
  ├── MCP HTTP Endpoint (/mcp?sessionToken=...)
  ├── Services: Sessions, Tasks, Messages, Boards, Branches, Repos
  ├── Agent SDKs: Claude, Codex, Gemini
  └── Drizzle ORM
Storage:
  ├── LibSQL Database (~/.agor/agor.db)
  ├── Git Branches (~/.agor/worktrees/)
  └── Config (~/.agor/config.yaml)

Monorepo structure

agor/
├── apps/
│   ├── agor-cli/        # oclif CLI (bin: agor)
│   ├── agor-daemon/     # FeathersJS backend + MCP endpoint
│   ├── agor-ui/         # React frontend
│   └── agor-docs/       # Documentation site
├── packages/            # Shared packages
├── context/             # Context documentation
├── docker-compose.yml   # Docker deployment
├── .agor.yml           # Variants config (sqlite/postgres/full/docs)
└── migrations/          # Database migrations

Required runtime

  • Node.js >= 22.12
  • Git
  • Docker (optional, for team deployment or Docker-based dev)

Target AI tools

  • Claude Code
  • Codex
  • Gemini CLI
  • OpenCode
  • Copilot CLI (any interchangeable per session)
03

Components

Agor — Components

CLI (agor) — oclif binary

Command Purpose
agor init Initialize ~/.agor/ and database
agor daemon start Start background daemon
agor daemon stop Stop daemon
agor open Open web UI in browser

Agor Daemon (FeathersJS)

Service Purpose
Sessions service Manage agent conversation sessions with genealogy
Tasks service Task tracking
Messages service Message storage + streaming
Boards service 2D canvas boards
Branches service Git branch management
Repos service Repository management
MCP HTTP Endpoint /mcp?sessionToken=... — agents drive their own session via JSON-RPC 2.0

Web UI features

Feature Purpose
Spatial 2D Canvas (Board) Figma-style canvas with branches and zones
Branch cards One card per git branch with conversation + env + PR
Zones Canvas regions that trigger templated prompts when branches are dropped in
Zone trigger modal Configure prompt template per zone
Session tree Fork/spawn sub-sessions with ancestry tracking
Multiplayer Live cursors, facepile, spatial comments, shared sessions
Multiplayer terminal Shared terminal session visible to all team members
Rich chat UX Per-prompt token + dollar accounting, model selector, structured tool blocks
Environments One-click dev servers per branch with auto-managed ports
Scheduler Cron-based triggers for templated prompts
Artifacts Sandpack-powered live interactive app rendering on canvas
Cards (Beta) Generic workflow entities for non-code workflows
Message Gateway Slack and GitHub as portals to Agor sessions

Long-lived assistants

Persistent agents with identity, memory (file-based), and skills published for the whole team. OpenClaw-style.

Scaffolding

.agor.yml at repo root defines deployment variants (sqlite, postgres, full, docs) for self-hosted deployments.

05

Prompts

Agor — Prompts

Agor's core prompt mechanism is zone-triggered prompt templates. The specific template content is user-defined per zone, not hardcoded in the framework.

Zone trigger modal (from README screenshot description)

When a branch is dropped into a zone, a modal appears to confirm the prompt template configured for that zone. Example zones might be:

  • "Code Review Zone" → triggers a code review prompt
  • "Security Scan Zone" → triggers a security analysis prompt
  • "Documentation Zone" → triggers a doc generation prompt

These are user-configured, not framework-shipped.

Long-lived assistants

From README:

"Assistants — long-lived AI companions with file-based memory and skills, OpenClaw-style."

Assistants have:

  • File-based memory (persisted between sessions)
  • Skills (documented markdown files)
  • Identity (name, personality)

The skill format follows an OpenClaw-style pattern — skills are markdown documentation files, not executable code.

Rich chat UX (prompt accounting)

From README:

"Rich Chat UX — per-prompt token + dollar accounting, model/effort selectors, structured tool blocks, completion chimes."

Each prompt includes model selection and effort level — users can adjust the "effort" parameter (likely Claude's thinking budget or Codex's compute level) per message.

MCP-driven prompting

Agents with MCP tokens issue JSON-RPC 2.0 calls to Agor's MCP endpoint. The specific tools available to agents via MCP are described at agor.live/guide/internal-mcp (not accessible via curl without auth).

Prompting technique: spatial trigger + template hydration

The zone-triggered workflow is the primary novel prompting pattern: the user's physical action (dragging a branch to a zone on the canvas) becomes the trigger for template hydration. This is gesture-as-prompt — unique in this corpus.

09

Uniqueness

Agor — Uniqueness & Positioning

differs_from_seeds

Agor is the only team-first framework in this batch and introduces three capabilities absent from all 11 seeds: (1) Figma-style 2D spatial canvas where branch cards live and zones auto-trigger agent prompts via drag-and-drop; (2) Real-time multiplayer with live cursors, facepile, and spatial comments (no seed has multi-user collaboration); (3) Session genealogy — a full ancestry tree of forked and spawned sub-sessions. The agent-driven MCP pattern (agents receive session tokens and call back to the Agor MCP endpoint to drive their own session) is closer to the reverse-MCP pattern of its-maestro-baby than to claude-flow's outbound tool server. Closest seeds: taskmaster-ai (MCP-anchored orchestration) and claude-flow (multi-agent, worktree support), but Agor adds multiplayer, spatial canvas, and session trees.

Positioning

  • "The team command center for all things agentic" — explicitly team-first, not solo-dev
  • From preset.io / Apache Superset ecosystem — engineering-org heritage
  • Self-hosted: all data in ~/.agor/ or your own Docker + Postgres
  • "Star pledge" (fix one issue per star) signals community-first attitude

Observable failure modes

  • The spatial canvas UX has a learning curve compared to list-based apps
  • Real-time multiplayer requires team adoption — less useful solo
  • Zone trigger automation requires upfront zone configuration
  • Background daemon model: requires agor daemon start before any work
  • License not documented publicly (no LICENSE in GitHub API response)

Inspired by

  • Figma (2D spatial canvas UX)
  • Miro (spatial collaboration)
  • Linear (issue-centric workflow for branches)

Competitors named in README

None explicitly.

Cross-references

  • .agor.yml in repo root: Agor uses itself (dogfooding)
  • OpenClaw-style assistant memory model
  • FeathersJS (same stack as some preset.io infrastructure)
04

Workflow

Agor — Workflow

Primary workflow: branch-centric with zones

Phase Action Artifact
1. Board setup Create a Board, define Zones with templated prompts Board with zones
2. Branch creation Create a branch card on the board Git branch + isolated environment
3. Zone drop Drag branch card into a zone → auto-triggers the zone's prompt template Agent session started
4. Agent execution Agent works in isolated environment; team sees live progress Conversation + code changes
5. Collaboration Team members see live cursors, leave spatial comments Comments on canvas
6. PR creation Agent or user creates PR from the branch GitHub PR
7. Artifact rendering Agent creates interactive app → Sandpack renders it on canvas Live artifact

Session genealogy workflow

Phase Action Artifact
Fork Fork session from any message → creates child session Child session linked to parent
Spawn Spawn sub-session for focused subtask Sub-session with link
Navigate Browse session tree showing full ancestry Session genealogy view

MCP-driven workflow (agents drive their own session)

  1. Agent session starts → receives MCP token
  2. Agent connects to /mcp?sessionToken=<token> via JSON-RPC 2.0
  3. Agent calls Agor MCP tools to manage its own session, create tasks, send messages

Scheduler workflow

  • Cron-configured per assistant
  • Powers assistant heartbeats (regular state checks)
  • Automated audit runs

Approval gates

  • Zone prompt trigger: user drags branch to zone (explicit action)
  • Human-in-the-loop via multiplayer chat
  • No automated merge gates
06

Memory Context

Agor — Memory & Context

Primary storage

  • LibSQL (SQLite-compatible): ~/.agor/agor.db — all sessions, messages, branches, boards, tasks
  • Git worktrees: ~/.agor/worktrees/ — per-branch isolated working directories
  • Config: ~/.agor/config.yaml — user configuration

Session genealogy

Sessions have full ancestry tracked in the database. Forked sessions link to their parent; sub-sessions link to their spawning session. This creates a navigable tree of agent conversation history.

Long-lived assistant memory

From README:

"Assistants — long-lived AI companions with file-based memory and skills"

Assistants have file-based memory (markdown files) that persist between sessions. This is conceptually similar to CLAUDE.md but scoped to individual named assistant identities.

Cross-session state

  • Session tree with full ancestry (SQLite)
  • Assistant memory files (file-system)
  • Branch history (git)

Multiplayer state

Live cursors, facepile, spatial comments — synchronized via FeathersJS WebSocket in real time. This state is session-scoped (volatile — reset when all users leave).

Context compaction

Not documented. Likely delegated to the underlying Claude Code/Codex runtime.

Postgres variant

For team deployments, Agor supports Postgres as the database backend (via docker-compose.postgres.yml). This enables multi-user horizontal scaling.

07

Orchestration

Agor — Orchestration

Multi-agent support

Yes — multiple branch sessions running simultaneously, each with its own agent and environment.

Orchestration pattern

Parallel fan-out (multiple branch sessions) + hierarchical (session trees with forked/spawned sub-sessions).

Novel pattern: spatial orchestration

Zone triggers create a spatial orchestration pattern: the canvas itself becomes the orchestrator. Dropping a branch into a zone dispatches it to that zone's configured prompt template. Multiple zones with different templates enable workflow routing via physical canvas gestures.

Isolation mechanism

Git worktree — each branch session has its own isolated working directory at ~/.agor/worktrees/.

Agent-driven orchestration via MCP

Agents receive MCP session tokens and can:

  • Create new sessions
  • Send messages to other sessions
  • Manage tasks
  • Drive the Agor workspace from inside an agent conversation (agents orchestrate agents)

Multiplayer coordination

Real-time collaboration via FeathersJS WebSocket:

  • Live cursors: see where teammates are on the canvas
  • Facepile: see who's active in a session
  • Spatial comments: leave scoped comments at canvas coordinates
  • Shared terminal: multiple users in the same terminal session

Multi-model support

Yes — any agent tool can be selected per session (Claude Code, Codex, Gemini, OpenCode, Copilot). Model and effort selectors per message in chat.

Execution mode

Background daemon — agor daemon start runs persistently; sessions persist and can be resumed.

Scheduling

Cron-based per-assistant scheduling for heartbeats and automated audits.

Max concurrent agents

Unknown (limited by system resources and git worktree capacity).

08

Ui Cli Surface

Agor — UI & CLI Surface

CLI binary: agor (oclif)

agor init           # Initialize ~/.agor/ and database
agor daemon start   # Start background daemon
agor daemon stop    # Stop daemon
agor open           # Open web UI in browser

Thin CLI wrapper — all substantive work happens in the web UI.

Web dashboard

React app served by the FeathersJS daemon at a local port.

View Description
Board (2D Canvas) Figma-style spatial canvas with branch cards and zones
Session view Conversation UI with tool blocks, model/effort selector
Session tree Genealogy view of forked/spawned sessions
Environment panel Dev server status per branch with auto-managed port
Multiplayer Live cursors, facepile, spatial comments
Shared terminal Multiplayer terminal session
Scheduler Cron configuration for assistant heartbeats
Artifacts Sandpack live app rendering on canvas
Cards (Beta) Non-code workflow entities
Settings MCP servers, branch management

Observability

  • Per-prompt token + dollar accounting in chat
  • Session history and genealogy in database
  • Structured tool blocks in chat display
  • Completion chimes
  • No JSONL audit log or replay

IDE integration

None — standalone web app + daemon.

Mobile

Not documented (no PWA or mobile-specific mentions).

Comparison: spatial canvas vs other UIs in batch

All other desktop apps (Crystal, RunMaestro, its-maestro-baby, Parallel Code, 1Code, Dorothy) use traditional list/panel/grid UIs. Agor's 2D spatial canvas is the unique UX paradigm — branches are cards that can be dragged between zones, creating a Figma/Miro-like visual workflow.

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…