What Is the Munder Difflin Message Protocol Based On?

The Munder Difflin message protocol is built on the Model Context Protocol (MCP), utilizing a JSON-based message schema defined in PROTOCOL.md that the Hive layer implements in src/main/hive.ts to route agent communications.

The chaitanyagiri/munder-difflin repository implements a distributed agent architecture where the Munder Difflin message protocol governs how components exchange structured data. Rather than inventing a proprietary wire format, the protocol grounds itself in the Model Context Protocol (MCP) standard and layers application-specific conventions—such as hive-identity injection and boot-time seeding—atop this foundation.

Model Context Protocol: The Foundation

The protocol’s core vocabulary originates from the Model Context Protocol (MCP), an open standard maintained within the @modelcontextprotocol ecosystem. In src/shared/mcpCatalog.ts, the project declares its dependency on this suite by importing various MCP server packages, ensuring all messages conform to MCP’s JSON schema specifications for acts, payloads, and metadata.

The Hive Protocol Layer

While MCP defines the syntax, the Hive protocol—formally documented in the repository’s PROTOCOL.md—defines the semantics for Munder Difflin’s specific use case. This abstraction, implemented primarily in src/main/hive.ts, wraps raw MCP messages with routing logic that associates each payload with a specific hive identity and manages the lifecycle of agent-to-agent communication.

Protocol Seeding and Initialization

Before an agent processes its first task, the Hive injects the protocol definition into the worker’s environment. According to src/shared/agentProvider.ts, the system delivers the protocol text either as a positional CLI argument or through the TUI after the worker boots, ensuring every agent receives the schema specification as its inaugural "turn" prior to processing user commands.

Message Routing and Handling

Once initialized, the Hive monitors designated inbox directories for JSON files adhering to the protocol. The src/main/hive.ts module constructs the PROTOCOL_MD constant and registers handlers that parse incoming messages, validate their act fields against known types, and dispatch payloads to the appropriate agent routines.

Message Structure and JSON Schema

Every message exchanged within the system is a JSON object containing standardized fields. The renderer layer, specifically src/renderer/src/scene/office/MessageEnvelope.ts, maps these act values—such as request, inform, or propose—to visual color codes in the UI, while the underlying data structure consistently includes from, to, payload, and timestamp properties.

Constructing a Protocol Message

The following TypeScript example demonstrates how to compose a valid message and deposit it into the Hive’s inbox:

// Example payload sent from an agent to the Hive
const message = {
  act: 'request',               // one of the MessageAct values
  to: 'agent-42',               // recipient identifier
  from: 'agent-7',              // sender identifier
  payload: {
    // Arbitrary command‑specific data
    command: 'fetch',
    url: 'https://api.example.com/data'
  },
  timestamp: Date.now()
};

// Serialize and drop into the inbox – the Hive will pick it up
import { writeFileSync } from 'fs';
import { inboxPath } from '@/shared/agentProvider';
writeFileSync(`${inboxPath}/msg-${Date.now()}.json`, JSON.stringify(message));

Parsing and Handling Messages

Agents consume protocol messages by reading inbox files and switching on the act field:

import { readFileSync } from 'fs';
import { resolve } from 'path';

function handleMessage(file: string) {
  const raw = readFileSync(resolve(file), 'utf8');
  const msg = JSON.parse(raw) as {
    act: string;
    from: string;
    to: string;
    payload: any;
  };

  switch (msg.act) {
    case 'request':
      // Process the request …
      break;
    case 'inform':
      // Log informational updates …
      break;
    // …other acts as defined in MessageAct
  }
}

Extending the Protocol with MCP Servers

The protocol’s extensibility derives directly from its MCP foundation. Developers can augment message capabilities by registering additional MCP-compatible servers—such as @modelcontextprotocol/server-github for repository operations or @modelcontextprotocol/server-brave-search for web queries—simply by listing them in src/shared/mcpCatalog.ts, where the Hive discovers and integrates new act types dynamically.

Summary

• The Munder Difflin message protocol extends the Model Context Protocol (MCP) with Hive-specific routing conventions.
• Protocol definitions reside in PROTOCOL.md and are injected at runtime via src/shared/agentProvider.ts.
• The Hive orchestrates message flow through src/main/hive.ts, which manages the PROTOCOL_MD seed and inbox monitoring.
• Messages follow a strict JSON schema with act, from, to, payload, and timestamp fields, visualized in the UI via MessageEnvelope.ts.
• New capabilities are added by registering MCP servers in src/shared/mcpCatalog.ts.

Frequently Asked Questions

Is the Munder Difflin protocol custom-built from scratch?

No. The protocol is not built from scratch; it is an application layer atop the Model Context Protocol (MCP). The system leverages existing MCP standards for message serialization and extends them only where necessary for hive-identity management and boot-time protocol delivery.

Where is the official protocol schema documented?

The human-readable specification lives in PROTOCOL.md at the repository root. The programmatic implementation, including the PROTOCOL_MD constant and routing logic, is located in src/main/hive.ts, while TypeScript type definitions for UI rendering appear in src/renderer/src/scene/office/MessageEnvelope.ts.

How does the Hive handle incoming messages?

The Hive monitors filesystem inboxes for JSON files. When a file appears, src/main/hive.ts parses the content, validates the act field against known MessageAct types, and routes the payload to the targeted agent based on the to property, effectively treating the filesystem as a message queue.

Can I add custom message types to the protocol?

Yes. Because the foundation is MCP, you can introduce new act types by extending the message schema and registering compatible MCP servers in src/shared/mcpCatalog.ts. The UI layer in MessageEnvelope.ts can then be updated to assign visual cues to the new act values.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}