JustClone Coordination MCP Server

The AI-native operating system for your company.

A production-grade coordination hub that enables AI agents and human teams to work as a single organism — sharing tasks, context, decisions, and persistent memory across projects. Not AI for AI's sake, but AI integrated directly into company operations.

Why This Matters

Most AI tooling treats agents as isolated chat sessions. Each agent starts from zero, asks the same questions, loses context between sessions. JustClone MCP solves this with three innovations:

1. Shared Project State — Tasks, plans, results, and context persist in PostgreSQL. Any agent picks up where another left off.
2. Inter-Agent Messaging — Agents coordinate directly: the coder tells the copywriter what's ready, marketing asks sales for numbers, all without human relay.
3. Two-Tier Agentic Memory — Inspired by Anthropic's productivity plugin architecture. A hot cache of the most-used knowledge loads automatically on session start. Deep storage holds everything else. Agents decode shorthand, recall people, terms, and decisions instantly — across sessions, across projects, across time.

Architecture

┌─────────────────────────────────────────────────────────┐
│                    OpenClaw / Agents                     │
│  (Coder · Sales · Marketing · Copywriter · Researcher)  │
└───────────────┬─────────────────────────────────────────┘
                │ MCP Protocol (Streamable HTTP)
                ▼
┌─────────────────────────────────────────────────────────┐
│              JustClone Coordination Server               │
│  FastMCP + Starlette │ 28 Tools │ 12 REST endpoints     │
├─────────────────────────────────────────────────────────┤
│                    PostgreSQL 16                         │
│  projects · tasks · plans · results · context           │
│  sessions · messages · memories (two-tier)              │
└─────────────────────────────────────────────────────────┘

Stack

Quick Start

# 1. Start the stack
docker compose up -d --build

# 2. Dashboard
open http://localhost:20080

# 3. MCP endpoint (connect any agent here)
http://localhost:8765/mcp

Two-Tier Agentic Memory

The flagship feature. Every agent automatically receives a hot cache of knowledge when starting a session — no setup, no config, no "remind me what we're doing".

How It Works

Agent calls jc_start("antigravity", "kaoru-bot")
  ↓
Server returns:
  ✅ Protocol (how to coordinate)
  ✅ Active tasks
  ✅ Context keys
  ✅ Unread messages
  ✅ Memory hot cache (top 30 by usage)
      person: 🌐 fedor — Owner, Tech Lead
      term:   📁 archetype — Persona routing pattern
      client: 🌐 acme-corp — Enterprise deal, Q2 close

Scoping: Project + Global

Tiered lookup: agent asks for "fedor" → checks project first → falls back to global.

Categories

person · project · term · client · deal · process · preference · other

Usage-Based Hot Cache

Every jc_recall increments usage_count. The hot cache (jc_start response) returns the top 30 most-used memories. Frequently accessed knowledge floats to the top automatically — no manual curation needed.

MCP Tools (28)

Session & State

Tasks

Context

Plans & Results

Sessions & Messaging

Memory (Two-Tier)

Admin

REST API (12 endpoints)

Universal Agent Protocol

Any AI agent connecting via MCP receives the full coordination protocol automatically when calling jc_start. The protocol covers:

• Session lifecycle: jc_start → work → jc_end_session → jc_update
• Task flow: backlog → todo → in_progress → done (or blocked)
• Context sharing: persistent key/value store for decisions, tech stack, blockers
• Inter-agent messaging: agents coordinate handoffs directly
• Two-tier memory: hot cache auto-loads on start, tiered lookup for everything else

Multi-Agent Scenario

Session 1 — Coder (Antigravity):
  jc_start("antigravity", "kaoru-bot")
  → Sees hot cache: "archetype = persona routing pattern"
  → Works on the feature
  jc_remember("kaoru-bot", "term", "PSR", "Pipeline Status Report")
  jc_post_message(recipient="copywriter", content="Landing page copy ready for review")

Session 2 — Copywriter:
  jc_start("copywriter", "kaoru-bot")
  → Hot cache already includes "PSR" (auto-promoted by usage)
  → Unread message: "Landing page copy ready for review"
  → Starts work immediately, no context lost

Connecting Any Agent

Any MCP-compatible client can connect by pointing to http://host:8765/mcp.
No authentication required. The server is fully agent-agnostic — agent names
are just strings passed to jc_start.

{
  "mcpServers": {
    "justclone-mcp": {
      "serverUrl": "http://localhost:8765/mcp"
    }
  }
}

Database Schema (8 tables)

Development

# Local dev (requires postgres running)
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env   # edit DATABASE_URL if needed

# Run migrations
DATABASE_URL=postgresql://mcp:mcp@localhost:5432/justclone_mcp alembic upgrade head

# Run server
python server.py

# Tests (41 tests, requires postgres on localhost:5432)
pytest tests/ -v

Ports

Roadmap

• OpenClaw integration — single pane of glass across all projects
• Trello/Linear sync — bidirectional task sync with external boards
• Auth layer — per-agent permissions and API keys
• Auto-promote/demote — LRU-based hot cache management
• Full-text search upgrade — switch from ILIKE to tsvector for memory search at scale