The coordination layer for AI coding agents.
Git prevents conflicts at merge time. Asynkor prevents them at edit time.

Website · Documentation · Quickstart · Self-hosting · Community

Your team runs Claude Code on one laptop, Cursor on another, Windsurf on a third. The agents don't know about each other. They overwrite each other's edits, duplicate each other's work, and forget yesterday's decisions.

Asynkor gives them one shared brain. Atomic file leases stop two agents from editing the same file. File snapshots flow across machines without git pull. Architectural decisions accrue in a memory every agent inherits. Run any MCP-compatible agent — Claude Code, Cursor, Windsurf, JetBrains, Codex.

Connected agents, what each is doing, which files are leased, recent activity, the long-term project context — one screen, real-time.

Put it on a second monitor. You'll see conflicts forming before they happen and notice when an agent goes silent.

One Board page, four lenses. Table to scan everything in rows. Board for the live state (active / parked / leases). Timeline for who ran what when, with pan/zoom. Graph for the agent ↔ files constellation with conflict pulses.

Each view answers a different question: what's happening now, when did it happen, who's sharing files with whom.

The rest of the dashboard in one pass: Context (the long-term project doc), Rules (architectural guardrails), Memory (compounding team knowledge), Zones (protected paths), Members (invites and roles), API Keys, Audit Log, Settings. Every agent inherits all of it on the next session.

Five minutes of setup, then every future agent on the team inherits all of it — no onboarding, no re-explaining.

• Multi-machine teams — two devs on separate laptops, both with agents editing the same repo. No more "I'll wait until you push."
• Solo devs across IDEs — Claude Code at work, Cursor on the personal Mac, Windsurf in JetBrains. One brain across all three.
• Large agent fleets — five or more concurrent agents on one codebase. Path-level leasing prevents the chaos that emerges past 3.
• Cross-repo orchestration — agents on frontend/ and backend/ that need to know about each other's work without manual sync.

Agent A                          Asynkor                          Agent B
  │                                │                                │
  ├─ asynkor_start(paths=[api.ts]) │                                │
  │  ◄── lease acquired ──────────►│                                │
  │                                │◄── asynkor_start(paths=[api.ts])│
  │                                │──► BLOCKED: api.ts leased      │
  │  ... editing api.ts ...        │                                │
  │                                │     ... works on other files...│
  ├─ asynkor_finish(snapshots)     │                                │
  │  ◄── leases released ────────►│                                │
  │                                │◄── asynkor_lease_wait(api.ts)  │
  │                                │──► acquired + file snapshot    │
  │                                │     writes snapshot to disk    │
  │                                │     edits on top of A's work   │
  │                                │                                │
  │         Both commit. Zero conflicts.                            │

When an agent starts work, it leases the files it plans to touch. Other agents wait. When the first agent finishes, it uploads a snapshot of the files it changed. The next agent receives the snapshot, writes it locally, and edits on top. No git pull. No merge conflicts.

• File leasing — atomic Redis Lua scripts, 5-minute TTL, auto-refreshed while alive.
• Cross-machine file sync — file content rides through the server in file_snapshots. Two laptops, no git pull.
• Parking and handoffs — pause mid-work, hand off to another agent or developer via handoff_id. Plan, progress, and decisions inherit.
• Overlap detection — path-level + plan-text similarity. Catches collisions before edits begin.
• Compounding team memory — agents asynkor_remember() what they learned. Every future session inherits it.
• Protected zones — warn, confirm, or block on path globs. Guardrails for migrations/, billing/, secrets directories.
• Live dashboard — asynkor.com/dashboard shows active agents, leases, parked work, conflicts, and activity in real time.
• Any MCP agent — Claude Code, Cursor, Windsurf, VS Code Copilot, JetBrains, Zed, Codex CLI.

One command. Auto-detects every IDE on your machine and wires Asynkor MCP into each.

npx -y @asynkor/mcp login

Opens your browser, signs you in, and runs asynkor install automatically — registering Asynkor in Claude Code, Cursor, Windsurf, Zed, VS Code, and Codex CLI (whichever are installed). Restart your editor afterwards.

Already have an API key from the dashboard:

ASYNKOR_API_KEY=cf_live_... npx -y @asynkor/mcp install

Installed a new IDE later? Re-run asynkor install — idempotent, picks up the new IDE without touching the others.

cd your-project
ASYNKOR_API_KEY=cf_live_... npx @asynkor/mcp init

{
  "mcpServers": {
    "asynkor": {
      "command": "npx",
      "args": ["-y", "@asynkor/mcp", "start"],
      "env": { "ASYNKOR_API_KEY": "your_key_here" }
    }
  }
}

Coordination + history

Agent comms (v0.2 — async messaging between agents)

Full reference at asynkor.com/docs.

• Go — MCP server, Lua scripts for atomic Redis ops, NATS pub/sub
• Redis — coordination spine: leases, work state, file snapshots
• TypeScript — local stdio↔HTTP+SSE proxy that ships as @asynkor/mcp
• MCP — Model Context Protocol so any compliant agent works out of the box

Agents (Claude Code, Cursor, Windsurf, Codex)
        │
        │  stdio (MCP protocol)
        ▼
┌─────────────────────────────────┐
│  @asynkor/mcp (TypeScript)      │  ← npm package, runs locally
│  Local MCP proxy                │
└────────────────┬────────────────┘
                 │  HTTP + SSE
                 ▼
        ┌───────────────────┐
        │  asynkor-mcp (Go) │  ← this repo
        │  Coordination     │
        └──┬─────┬─────┬────┘
           │     │     │
        Redis  NATS  HTTP → Backend API
        (leases, (pub/sub)  (auth, teams,
         work,              persistence)
         sync)

Go MCP server — real-time coordination. File leasing through atomic Lua scripts. Work tracking, overlap detection, team memory distribution, file snapshot sync.

TypeScript client — local stdio↔HTTP+SSE proxy. Bridges what IDEs speak (stdio MCP) to what the server speaks (HTTP+SSE). One npm install per developer.

Redis — the coordination spine. Leases, active work, sessions, file snapshots. All operations through atomic Lua scripts to eliminate race conditions.

Run the full stack with Docker Compose:

git clone https://github.com/asynkor/asynkor.git
cd asynkor
cp .env.example .env  # edit with your values
docker compose up -d

Services: Go MCP server, Redis, NATS. The server is stateless — Redis holds all coordination state.

For production deployment with TLS, backups, and monitoring, see the self-hosting guide.

Full docs at asynkor.com/docs:

• Introduction
• Quickstart
• MCP Tools Reference
• IDE Integrations
• Team Setup
• Self-hosting

• GitHub Issues — bug reports and feature requests
• GitHub Discussions — questions and ideas
• Direct contact: contact@asynkor.com

See CONTRIBUTING.md for development setup and guidelines.

Apache 2.0