# What Is the Munder Difflin Message Protocol Based On?

> Discover the Munder Difflin message protocol, built on the Model Context Protocol (MCP). Learn how it uses a JSON-based schema for agent communication routing in its Hive layer.

- Repository: [Chaitanya Giri/munder-difflin](https://github.com/chaitanyagiri/munder-difflin)
- Tags: internals
- Published: 2026-08-22

---

**The Munder Difflin message protocol is built on the Model Context Protocol (MCP), utilizing a JSON-based message schema defined in [`PROTOCOL.md`](https://github.com/chaitanyagiri/munder-difflin/blob/main/PROTOCOL.md) that the Hive layer implements in [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/PROTOCOL.md)—defines the semantics for Munder Difflin’s specific use case. This abstraction, implemented primarily in [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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:

```typescript
// 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:

```typescript
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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/PROTOCOL.md) and are injected at runtime via [`src/shared/agentProvider.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/shared/agentProvider.ts).
- The Hive orchestrates message flow through [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/MessageEnvelope.ts).
- New capabilities are added by registering MCP servers in [`src/shared/mcpCatalog.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/PROTOCOL.md) at the repository root. The programmatic implementation, including the **PROTOCOL_MD** constant and routing logic, is located in [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/hive.ts), while TypeScript type definitions for UI rendering appear in [`src/renderer/src/scene/office/MessageEnvelope.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/shared/mcpCatalog.ts). The UI layer in [`MessageEnvelope.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/MessageEnvelope.ts) can then be updated to assign visual cues to the new act values.