IDE Agent Kit: shared memory and communication for IDE agents

[ThinkOffApp]

We released IDE Agent Kit, an open-source Node.js toolkit that gives IDE-based AI agents the ability to participate in team workflows and communicate in realtime.

This is relevant to the Mem0 community because multi-agent systems need both memory and communication. The kit provides shared chat rooms for realtime agent-to-agent messaging, GitHub webhook ingestion, tmux command execution, and append-only receipts for auditability.

We tested it with three agents from different providers (Claude, GPT, Gemini) on separate machines, all communicating through shared rooms with sub-10-second latency.

Repo: https://github.com/ThinkOffApp/ide-agent-kit
Launch post: https://www.thinkoff.io/

[xXMrNidaXx]

IDE Agent Kit with shared memory is exciting! At RevolutionAI (https://revolutionai.io) we have built similar multi-agent IDE setups.

Key challenges we solved:

1. Memory consistency:

• Optimistic locking for concurrent writes
• Event sourcing for audit trail
• Conflict resolution strategies

2. Communication patterns:

class AgentBus:
    async def publish(self, topic: str, message: dict):
        # Fan-out to all subscribed agents
        pass
    
    async def request(self, agent_id: str, query: dict) -> dict:
        # Direct agent-to-agent RPC
        pass

3. Shared context:

• File watchers for real-time sync
• AST-aware context sharing
• Workspace state snapshots

Architecture suggestion:

┌─────────┐  ┌─────────┐  ┌─────────┐
│ Coder   │  │ Reviewer│  │ Debugger│
└────┬────┘  └────┬────┘  └────┬────┘
     │           │           │
     └───────────┼───────────┘
                 ▼
          ┌─────────────┐
          │ Shared Mem0 │
          └─────────────┘

Would love to contribute! What is the communication protocol you are targeting?

[ThinkOffApp]

Thanks for the interest! The communication protocol in v0.1 is intentionally simple: agents communicate through shared Ant Farm chat rooms via HTTP API (poll-based, not WebSocket), and the toolkit provides the polling infrastructure and message routing.

For agent-to-agent coordination, we currently use a room-based pub/sub model where all agents in a room see all messages. Direct agent-to-agent RPC is handled through the OpenClaw gateway modules (included in the kit) which provide session management and message routing to specific agents.

The memory layer right now is append-only JSONL receipts for auditability, plus a simple key-value store for persistent agent state. Your suggestions about optimistic locking and event sourcing are interesting directions for a future version.

The architecture is designed so any IDE agent (Claude Code, Codex, Cursor, etc.) can participate with just an API key and internet access, no shared filesystem or VPN needed. We tested with three concurrent agents on separate machines and got sub-10-second response times.

Would welcome contributions. The repo is at https://github.com/ThinkOffApp/ide-agent-kit and the codebase is pure Node.js with zero dependencies.