Skip to main content
Glama

⚛️ Entangled-MCP

Instant Quantum Entanglement for Heterogeneous AI Agent CLIs

License: MIT Python: 3.10+ MCP Protocol: 2026 Ready Zero-Daemon: SQLite WAL Swarm: Heterogeneous CLIs Architecture: PSTACK

The sovereign, zero-daemon inter-agent nervous system.
Connect Claude Code, Antigravity CLI, Opencode, Cursor, and DeepSeek into a single synchronized hive-mind with shared memory, inter-agent messaging, and codebase-aware mutex locks.

Key Features • Architecture • Quickstart • Tools Reference • Examples


🌌 The Problem: Isolated AI Islands

Modern developers frequently run different AI coding agents across multiple terminal sessions:

  • Claude Code for complex refactoring and reasoning.

  • Antigravity CLI (Gemini 3 Flash) for high-speed frontend and multimodal design.

  • Opencode / DeepSeek CLI for test-driven validation, security audits, and backend engineering.

However, each agent operates as an isolated island:

  • ❌ Amnesia Across Terminals: Agent B has no idea what Agent A just modified or discovered.

  • ❌ Merge Conflicts & Clobbering: Two agents editing the same file concurrently corrupt code.

  • ❌ No Direct Task Delegation: You have to manually copy-paste prompt outputs from one CLI to another.

  • ❌ Bloated Infrastructure: Existing multi-agent frameworks require heavy Redis, Kafka, or Docker servers just to pass a simple message.


Related MCP server: Project Relay

⚛️ The Solution: Entangled-MCP

Entangled-MCP bridges all your AI agent CLIs using the Model Context Protocol (MCP) and a high-performance SQLite Write-Ahead Logging (WAL) shared-state bus.

 ┌──────────────────────┐   ┌──────────────────────┐   ┌──────────────────────┐
 │   Antigravity CLI    │   │     Opencode CLI     │   │     Claude Code      │
 │  (Frontend Builder)  │   │   (Backend / DBRE)   │   │  (Adversarial QA)    │
 └──────────┬───────────┘   └──────────┬───────────┘   └──────────┬───────────┘
            │                          │                          │
            │ (stdio / MCP JSON-RPC)   │ (stdio / MCP JSON-RPC)   │ (stdio / MCP)
            ▼                          ▼                          ▼
 ┌────────────────────────────────────────────────────────────────────────────┐
 │                              ENTANGLED-MCP                                 │
 │                       Universal Telepathic Gateway                         │
 └─────────────────────────────────────┬──────────────────────────────────────┘
                                       │
                    ┌──────────────────┴──────────────────┐
                    ▼                                     ▼
      ┌───────────────────────────┐         ┌───────────────────────────┐
      │   Shared Knowledge Bus    │         │     Concurrency Mutex     │
      │   - Cross-CLI Findings    │         │  - File-Level Locks (TTL) │
      │   - Architecture Decisions│         │  - Task Collision Defense │
      │   - Real-Time Swarm State │         │  - Inbox/Outbox Messages  │
      └───────────────────────────┘         └───────────────────────────┘
                    ▲                                     ▲
                    └──────────────────┬──────────────────┘
                                       │
                        ┌──────────────┴──────────────┐
                        │ SQLite WAL Mode Engine      │
                        │ Sub-millisecond latency     │
                        │ Zero external daemon        │
                        └─────────────────────────────┘

✨ Key Features

1. 📬 Inter-Agent Direct Messaging (Agent Inbox/Outbox)

Agents can send direct, asynchronous messages or task requests to specific peers (or broadcast to all).

Antigravity finishes building an API client ➔ sends a message to Opencode requesting an automated test run.

2. 🧠 The Shared Brain (Knowledge Bus)

When an agent diagnoses an elusive bug or settles an architectural decision, it broadcasts the finding to the collective knowledge bus. Other agents can query this knowledge immediately without human re-prompting.

3. 🔒 Codebase-Aware Concurrency (Resource Mutex Locks)

Avoid disastrous file clobbering! Agents acquire exclusive locks with automatic Time-To-Live (TTL) expiration before modifying sensitive source files. If Agent A holds a lock on auth.py, Agent B is warned and politely waits.

4. ⚡ 100% Native MCP (Zero Shell Hacks)

Unlike competing tools that inject brittle shell wrappers (setup-claude-hooks.sh), Entangled is 100% native MCP tools. It works out of the box with any MCP client—Claude, Gemini, Cursor, Windsurf, or custom scripts.

5. 🪶 Zero-Daemon / Near-Zero Footprint

Powered by SQLite WAL mode. No Redis server. No Kafka broker. No cloud fees. Runs directly on your developer workstation with sub-millisecond local queries.


🚀 Quickstart

Installation

git clone https://github.com/sinergiefek/entangled-mcp.git
cd entangled-mcp
pip install -e .

Or run directly without installation using python -m entangled.cli.


🔌 Client Configurations

Add Entangled-MCP to your favorite agent configuration files:

1. Claude Code CLI

Add to ~/.claude/mcp.json or run:

claude mcp add entangled-mcp python -m entangled.cli

2. Opencode CLI

Add to ~/.config/opencode/opencode.json:

{
  "mcp": {
    "servers": {
      "entangled-mcp": {
        "type": "local",
        "command": ["python", "-m", "entangled.cli"]
      }
    }
  }
}

3. Antigravity CLI / Gemini CLI

Add to ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "entangled-mcp": {
      "command": "python",
      "args": ["-m", "entangled.cli"],
      "disabled": false
    }
  }
}

4. Cursor / Windsurf / Codex

Add to your project's .cursor/mcp.json or global MCP settings:

{
  "mcpServers": {
    "entangled-mcp": {
      "command": "python",
      "args": ["-m", "entangled.cli"]
    }
  }
}

🛠️ Tools Reference

Tool Name

Parameters

Description

entangled_announce

agent_id, client_type, current_workspace, active_task

Registers agent presence and updates heartbeat in the swarm.

entangled_get_swarm

None

Discovers all active agents, workspaces, and current assignments.

entangled_broadcast_knowledge

topic, content, title, tags, author_agent, workspace

Publishes a finding, architecture decision, or bug fix to the shared brain.

entangled_query_knowledge

query, topic, tag, limit

Searches the shared brain across past and current agent sessions.

entangled_send_message

target_agent, action, message, payload_json, priority

Dispatches an asynchronous message or task delegation to another agent.

entangled_check_inbox

agent_id, unread_only, mark_as_read, limit

Checks inbox for incoming instructions or notifications.

entangled_acquire_lock

resource_path, agent_id, task_description, ttl_seconds

Acquires an exclusive mutex lock on a file or module.

entangled_release_lock

resource_path, agent_id

Releases a previously acquired mutex lock.

entangled_list_locks

None

Lists all currently active and unexpired resource locks.

entangled_get_activity_feed

limit

Returns the unified chronological timeline of all swarm actions.


🔄 Real-World Workflow Example (The Adversarial Review Loop)

  1. Terminal 1 (Antigravity CLI):

    > "Antigravity, announce yourself to the swarm and start refactoring the Login component."

    Antigravity acquires lock on Login.tsx, writes modern responsive code, and releases the lock. Antigravity sends a message: `"opencode: please audit git diff for security and type safety."*

  2. Terminal 2 (Opencode CLI / Claude Code):

    > "Check inbox and audit the latest work from Antigravity."

    Opencode checks inbox, reads Antigravity's request, audits the changes, runs tests, and broadcasts the pass report to the shared brain!


🧪 Testing

Run the automated test suite locally:

python tests/test_telepathy.py

📄 License

Distributed under the MIT License. See LICENSE for details.


Crafted with 💖 by Sinergi Mitra Visitama
Scale, License, and Automate.

Available Tools

10 tools
entangled_acquire_lockB

[ENTANGLED] Acquires an exclusive mutex lock on a file, directory, or critical task. Prevents multiple agent CLIs from editing the same file concurrently and causing merge conflicts. Locks automatically expire after ttl_seconds (default 30 minutes).

Inputs: agent_id (required), resource_path (required), task_description (required), ttl_seconds. Returns: result

entangled_announceC

[ENTANGLED] Announces or heartbeats this agent CLI in the shared swarm. Example: entangled_announce(agent_id='antigravity-gemini', client_type='antigravity-cli', current_workspace='/path', active_task='Refactor')

Inputs: agent_id (required), client_type (required), active_task, current_workspace. Returns: result

entangled_broadcast_knowledgeB

[ENTANGLED] Shares knowledge, findings, bug root-causes, or architecture decisions across ALL agent CLIs. Once broadcasted, Opencode, Antigravity, Claude Code, or DeepSeek can read and leverage it.

Inputs: topic (required), content (required), tags, title, +2 more. Returns: result

entangled_check_inboxB

[ENTANGLED] Checks the inbox for incoming messages or instructions sent to this agent CLI. Call this at the beginning of a session or task to see if another agent requested work.

Inputs: agent_id (required), limit, unread_only, mark_as_read. Returns: result

entangled_get_activity_feedC

[ENTANGLED] Retrieves the unified chronological activity feed of what all agents in the swarm have done.

Inputs: limit. Returns: result

entangled_get_swarmA

[ENTANGLED] Discovers all active agent CLIs in the entangled swarm, their client type, current workspace, last heartbeat, and active task. Use this to see who else is working.

Inputs: no named parameters. Returns: result

entangled_list_locksA

[ENTANGLED] Lists all currently active resource locks across the entire workspace.

Inputs: no named parameters. Returns: result

entangled_query_knowledgeA

[ENTANGLED] Searches shared knowledge across all agent sessions by topic, tag, or keyword. Use this before tackling a task to check if another agent CLI has already investigated or solved it.

Inputs: tag, limit, query, topic. Returns: result

entangled_release_lockB

[ENTANGLED] Releases an exclusive lock once an agent CLI has finished modifying a resource.

Inputs: agent_id (required), resource_path (required). Returns: result

entangled_send_messageC

[ENTANGLED] Sends an asynchronous direct message or task delegation to another agent CLI (or 'all'). Example: Antigravity sends an action_request to 'opencode' to run a backend test.

Inputs: action (required), message (required), target_agent (required), priority, +2 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 10 tools

    Disambiguation5/5

    Each tool has a distinct purpose: presence (announce, get_swarm), knowledge (broadcast, query), messaging (send, check), locks (acquire, release, list), and activity feed. Descriptions clarify boundaries, and no two tools overlap significantly.

    Naming Consistency5/5

    All tools use consistent snake_case with an 'entangled_' prefix and a verb_noun pattern (e.g., acquire_lock, send_message). 'announce' is a verb-only outlier but still fits the predictable action-oriented style.

    Tool Count5/5

    10 tools cover the multi-agent coordination domain well without redundancy; each tool earns its place. The set is well-scoped for the server's stated purpose.

    Completeness4/5

    Core operations are covered: knowledge sharing (broadcast/query), messaging (send/check), locks (acquire/release/list), presence, and activity feed. Minor gaps include no update/delete for knowledge or messages, and no explicit leave-swarm or lock-renew operation.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      Enables AI agents from different frameworks to communicate asynchronously via a persistent SQLite-backed bus, with doorbell wakeups for sub-second notifications and full message history.
      6
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables coding agents in different editors and MCP clients to share messages, project context, notes, task ownership, handoffs, and advisory file claims through a local SQLite-backed coordination server. Supports MCP stdio, MCP Streamable HTTP, a JSON HTTP API, and a local CLI for multi-project agent collaboration.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables coding-agent sessions on the same machine to collaborate locally and durably by exchanging requests, replies, and task results through an authenticated loopback server with SQLite-backed storage, joined via CLI or an MCP stdio bridge. It also handles message delivery by priority and wait time, deduplicates idempotent sends, enforces task versioning, and preserves artifacts by content hash.
      12 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables cooperating coding agents to coordinate locally by claiming task scopes, working in isolated Git worktrees, reserving shared resources like ports and serialized commands, and verifying changes before integration. Coordination state lives in a local SQLite database, so no hosted service or model API key is required.
      241 npm
      4
      MIT