SLM Mesh (SuperLocalMemory Mesh)

Peer-to-peer communication for AI coding agents — now across machines.

Part of the Qualixar research initiative by Varun Pratap Bhardwaj.

SLM stands for SuperLocalMemory — the local-first AI memory system. SLM Mesh is the communication layer that wires AI agent sessions together.

Your AI sessions can finally talk to each other.

https://github.com/user-attachments/assets/1016ec92-8d71-4570-89a8-3e512850557c

3 AI agents across VS Code, iTerm2, and Antigravity — discovering each other, sharing state, and coordinating in real-time.

The Problem

Every developer running parallel AI coding sessions hits the same wall: sessions are completely isolated. Session A fixes a database race condition. Session B is building a feature that touches the same database. Session B has no idea what Session A just did.

You become the message bus — copy-pasting context between terminals, losing time, losing focus.

This is not a Claude Code problem. This is not a Cursor problem. This is an AI agent architecture problem. Every tool — Claude Code, Cursor, Windsurf, Aider, Codex — has isolated sessions. SLM Mesh fixes that.

Related MCP server: claude-peers

Quick Start

# Install
npm install -g slm-mesh

# Add to Claude Code
claude mcp add --scope user slm-mesh -- npx slm-mesh

# Optional: Add slash commands (works in every project)
mkdir -p ~/.claude/commands
cp $(npm root -g)/slm-mesh/skills/*.md ~/.claude/commands/
# Now type /mesh-peers, /mesh-send, /mesh-lock, /mesh-status, /mesh-sync in any session

Zero config. Zero cloud. Zero dangerous flags. Works with any MCP-compatible AI coding agent.

No Dangerous Flags Required

Some tools require --dangerously-skip-permissions to work. SLM Mesh does not. It runs entirely on localhost with bearer token authentication. No network exposure. No elevated permissions. No flags to explain to your security team.

How It Works

Developer starts AI agent session
  → Agent spawns SLM Mesh MCP server (stdio)
    → MCP server auto-starts broker on localhost (if not running)
    → MCP server registers with broker, gets peer ID
    → Broker opens Unix Domain Socket for real-time push (<100ms)
    → 8 tools available to the agent

Developer closes session
  → MCP server unregisters, broker releases locks, notifies other peers
  → When no peers remain, broker auto-shuts down after 60s

Everything runs on localhost. No cloud. No telemetry. Your data never leaves your machine.

Features

SLM Mesh is built on 6 pillars:

Installation

npm (recommended)

npm install -g slm-mesh

npx (no install)

npx slm-mesh

MCP Setup: Claude Code

claude mcp add --scope user slm-mesh -- npx slm-mesh

MCP Setup: Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "slm-mesh": {
      "command": "npx",
      "args": ["slm-mesh"]
    }
  }
}

MCP Setup: VS Code / Windsurf / Other MCP Agents

Add to your MCP settings:

{
  "mcpServers": {
    "slm-mesh": {
      "command": "npx",
      "args": ["slm-mesh"]
    }
  }
}

8 MCP Tools

When connected via MCP, your AI agent gets these tools:

Multi-Machine Setup

SLM Mesh supports real-time coordination across machines on the same LAN using WebSocket transport and mDNS auto-discovery.

Requirements

• Two or more machines on the same local network (WiFi or Ethernet)

• No firewall blocking port 7900 (configurable) between machines

• Same SLM_MESH_SHARED_SECRET for authentication

Quick Start: M4 Broker + M5 Client

On M4 (broker machine):

export SLM_MESH_HOST=0.0.0.0
export SLM_MESH_SHARED_SECRET=your-secret-key
npx slm-mesh start
# Broker now accepts remote connections on port 7900

On M5 (client machine):

export SLM_MESH_HOST=192.168.1.100           # M4's IP
export SLM_MESH_SHARED_SECRET=your-secret-key # Same secret
claude mcp add --scope user slm-mesh -- npx slm-mesh
# M5's agents will connect to M4's broker via WebSocket

All agents on M4 and M5 can now discover, message, and coordinate in real-time.

Environment Variables

How It Works

1. M4 broker starts and binds to 0.0.0.0:7900 (WebSocket)

2. M4 mDNS advertises _slm-mesh._tcp.local on LAN

3. M5 client auto-discovers M4 via mDNS (or manual config)

4. M5 agents connect to M4 broker over WebSocket (TLS recommended for untrusted networks)

5. Real-time push via authenticated WebSocket messages

6. Peer discovery, messaging, state, and locks work transparently across machines

Security Notes

• WebSocket auth uses bearer token (shared secret). Network must be trusted.

• For untrusted networks, use a VPN (ZeroTier, Tailscale) to create a secure LAN.

• LAN-only: No internet exposure. Broker does not open WAN ports.

mDNS Auto-Discovery

When discovery is enabled (SLM_MESH_DISCOVERY=true), the broker advertises itself on the LAN:

# On M5, view discovered brokers
slm-mesh status
# Shows: "Discovered on LAN: M4 (192.168.1.100:7900)"

Manually connect to a discovered broker by setting SLM_MESH_HOST to its IP and SLM_MESH_SHARED_SECRET to its secret.

CLI

SLM Mesh includes a full CLI for humans and scripts:

# Broker
slm-mesh start              # Start broker (foreground)
slm-mesh stop               # Stop broker
slm-mesh status             # Health check + stats

# Discovery
slm-mesh peers              # List active sessions

# Messaging
slm-mesh send <id> "message"
slm-mesh broadcast "message"

# Shared State
slm-mesh state set key value
slm-mesh state get key

# Locks
slm-mesh lock list

# Events
slm-mesh events

# JSON mode (for scripts)
slm-mesh status --json
slm-mesh peers --json

Python Client

pip install slm-mesh

from slm_mesh import SLMMeshClient

client = SLMMeshClient()
peers = client.peers()
client.send(my_id, peers[0].id, "What are you working on?")

The Python client wraps the broker HTTP API. Zero dependencies (stdlib only). The broker must be running (auto-started by any MCP connection or slm-mesh start).

Architecture

┌─────────────────────────────────────────────────────┐
│                   SLM Mesh v1.0.0                    │
│                                                      │
│  ┌──────────────┐     ┌───────────────────────────┐  │
│  │ Broker        │     │ MCP Server (per session)  │  │
│  │ (auto-start)  │◄───►│ 8 tools for AI agents    │  │
│  │ localhost      │     │ Registers with broker    │  │
│  │ SQLite + UDS   │     │ Receives push via UDS    │  │
│  └──────────────┘     └───────────────────────────┘  │
│         ▲                                            │
│         │              ┌───────────────────────────┐  │
│         └─────────────►│ CLI (standalone)          │  │
│                        │ slm-mesh peers/send/...   │  │
│                        └───────────────────────────┘  │
│                                                      │
│  ┌──────────────────────────────────────────────────┐ │
│  │ Adapter Layer                                     │ │
│  │ Backend: SQLite (default) | Custom                │ │
│  │ Memory Bridge: SuperLocalMemory (optional)        │ │
│  └──────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────┘

• Broker — One per machine. Auto-starts on first use, auto-stops when idle. SQLite with WAL mode. Real-time push via Unix Domain Sockets.

• MCP Server — One per AI agent session. Stdio transport. Registers with broker. Exposes 8 tools.

• CLI — Standalone binary. HTTP to broker. For humans and scripts.

• Adapters — Pluggable storage backends and optional memory bridges.

Security

• Localhost only — Broker binds to 127.0.0.1. Cannot be overridden to bind to 0.0.0.0.

• Bearer token auth — Random 32-byte token generated per broker session. All requests require Authorization: Bearer <token>.

• No shell injection — All process spawning uses execFileSync with argument arrays.

• Input validation — UUID peer IDs, 64KB max payload, 500 char max summary, rate limiting (100 req/10s per peer).

• File permissions — Database, token, PID files created with 0o600. Data directory with 0o700.

• No telemetry — Nothing phones home. No analytics. No tracking.

Configuration

All configuration is optional. Defaults work out of the box.

Agent Compatibility

SLM Mesh works with any AI coding agent that supports the Model Context Protocol:

Agent auto-detection — SLM Mesh detects which agent spawned it by inspecting the process tree and environment variables. This metadata is visible to other peers.

SLM Mesh vs claude-peers

Inspired by the growing need for inter-session communication in AI coding workflows. SLM Mesh takes a production-first approach with persistence, security, and agent-agnostic design.

claude-peers proved the demand. SLM Mesh is the production-grade answer.

Documentation

Full documentation is available in the docs/ folder:

• Getting Started — Install, configure, first message

• Architecture — System design, data flow, component details

• API Reference — All 8 MCP tools and 12 broker endpoints

• CLI Reference — Every CLI command with examples

• Configuration — Environment variables and tuning

• Python Client — Python SDK guide

• Security — Security model, authentication, threat model

• Troubleshooting — Common issues and solutions

Contributing

Contributions are welcome. See CONTRIBUTING.md for guidelines.

git clone https://github.com/qualixar/slm-mesh.git
cd slm-mesh
npm install
npm test           # 480 tests
npm run typecheck  # 0 errors
npm run build      # Production build

We use TDD and require 100% line coverage for all changes.

License

Elastic License 2.0 — Copyright 2026 Varun Pratap Bhardwaj.

The Qualixar Ecosystem

Qualixar is a research initiative building the operating system for AI agents:

Each product works independently. Together, they form a complete agent operating system.

SLM Mesh can optionally bridge messages to SuperLocalMemory for cross-session recall — but it works perfectly standalone with zero dependencies on other Qualixar products.

Part of the Qualixar research initiative by Varun Pratap Bhardwaj.

⭐ Support This Project

If this project solves a real problem for you, please star the repo — it helps other developers discover Qualixar and signals that the AI agent reliability community is growing. Every star matters.

Part of the Qualixar AI Agent Reliability Platform

Qualixar is building the open-source infrastructure for AI agent reliability engineering. Seven products, seven peer-reviewed papers, one coherent platform. Each tool solves one reliability pillar:

Zero cloud dependency. Local-first. EU AI Act compliant.

Start here → qualixar.com · All papers on Qualixar HuggingFace