FIPA-Lite Speech Acts in Munder Difflin: The 7 Message Types Powering Agent Communication

Munder Difflin implements seven FIPA-Lite speech acts—request, inform, propose, query, agree, refuse, and done—to enable lightweight, intention-driven messaging between autonomous agents and the orchestrator.

The Munder Difflin paper company simulation uses a streamlined subset of the Foundation for Intelligent Physical Agents (FIPA) Agent Communication Language. This FIPA-Lite model trades the full ACL taxonomy for pragmatism: seven speech acts cover command, response, negotiation, and completion patterns without overwhelming the system with semantic complexity. The implementation appears in MessageEnvelope.ts for the renderer and src/main/hive.ts for the main process, with both files sharing an identical TypeScript union type that enforces type safety across the Electron IPC boundary.

The 7 FIPA-Lite Speech Acts Defined

All agent-to-agent and UI-to-agent messages in Munder Difflin carry an act field drawn from this exhaustive list:

Speech Act	FIPA-Lite Purpose	Typical Usage Pattern
request	Directive to perform an action	User or agent commands another agent
inform	Unsolicited information delivery	Search results, status updates, answers
propose	Suggestion awaiting acceptance	Plan recommendations, meeting scheduling
query	Information-seeking question	Clarification requests, data lookups
agree	Acceptance of prior proposal/request	Confirmation of action intent
refuse	Denial of proposal or request	Rejection with optional explanation
done	Task completion notification	Final state signaling for workflows

These values are defined once in src/renderer/src/scene/office/MessageEnvelope.ts and mirrored in src/main/hive.ts to maintain consistency across the renderer/main process boundary:

// src/renderer/src/scene/office/MessageEnvelope.ts
// src/main/hive.ts (identical definition)

export type MessageAct = 
    'request' | 'inform' | 'propose' | 'query' | 'agree' | 'refuse' | 'done';

Speech Act Patterns in Practice

The FIPA-Lite speech acts in Munder Difflin support four fundamental interaction patterns. Each pattern combines specific acts to achieve coherent conversational flow.

Request-Inform: Basic Command-Response

The simplest pattern: one agent requests action, another informs of results.

// Renderer component sends a request
import { hive } from '@/preload';
import type { MessageAct } from '@/scene/office/MessageEnvelope';

function askAgentToSearch(query: string) {
  const msg = {
    to: 'search-agent',
    act: 'request' as MessageAct,
    subject: 'Web Search',
    body: query,
    requires_reply: true,
  };
  hive.send(msg);
}

The search-agent processes this in src/main/hive.ts and responds:

// Agent's main loop handling
function handleMessage(msg) {
  if (msg.act === 'request' && msg.subject === 'Web Search') {
    const result = performSearch(msg.body);
    hive.send({
      to: msg.from,
      act: 'inform',
      subject: 'Search Results',
      body: JSON.stringify(result),
    });
  }
}

The requires_reply: true flag in the request enables the system to track pending conversations and apply timeout policies.

Propose-Agree-Refuse: Negotiation Flow

Multi-agent coordination requires bargaining. The propose act initiates, with agree or refuse terminating the negotiation thread.

// Initiate a meeting proposal
hive.send({
  to: 'planner-agent',
  act: 'propose',
  subject: 'Schedule Meeting',
  body: JSON.stringify({ time: '10am', participants: ['alice', 'bob'] }),
});

The planner evaluates constraints and replies with binary resolution:

// Acceptance path
hive.send({ 
  to: 'requester', 
  act: 'agree', 
  subject: 'Schedule Meeting', 
  body: '' 
});

// Or rejection path
hive.send({ 
  to: 'requester', 
  act: 'refuse', 
  subject: 'Schedule Meeting', 
  body: 'Time conflict with existing event' 
});

This pattern appears throughout terminalRecovery.ts for resource allocation and scheduling scenarios.

Query-Inform: Information Discovery

When an agent lacks context, query elicits inform responses without implying obligation to act.

// Seeking clarification
hive.send({
  to: 'knowledge-agent',
  act: 'query',
  subject: 'Employee Directory',
  body: 'Find contact for "Jim Halpert"',
});

The knowledge agent's inform response carries the same subject header for correlation tracking in the conversation store.

Done: Asynchronous Completion Signaling

Long-running operations use done to signal termination without requiring acknowledgment.

// Post-export notification
hive.send({
  to: 'god',
  act: 'done',
  subject: 'Data Export',
  body: 'Export completed successfully. 1,247 records written.',
});

The "god" orchestrator uses done messages to update progress bars and release resource locks in the UI.

Implementation Architecture

Type Safety Across Process Boundaries

Munder Difflin enforces FIPA-Lite compliance through TypeScript's type system. The MessageAct union type propagates through:

• Renderer: src/renderer/src/scene/office/MessageEnvelope.ts — defines envelope structure and speech act literals
• Main: src/main/hive.ts — re-exports identical type for agent runtime
• Preload: src/preload/index.ts — validates act field during IPC serialization

This redundancy prevents version drift between UI and agent codebases.

Routing and Policy Enforcement

The hive.ts message router inspects act values to apply behavior policies:

• request messages to destructive agents trigger confirmation dialogs
• refuse responses increment retry counters with exponential backoff
• done signals advance workflow state machines

The limited FIPA-Lite vocabulary makes these policy rules exhaustive and auditable—no unexpected speech acts bypass security checks.

Testing with Mock Events

The mockEvents.ts store contains literal speech-act strings for integration testing:

// src/renderer/src/store/mockEvents.ts (excerpt)
export const mockMessages = [
  { to: 'assistant', act: 'request', subject: 'Compose Email', ... },
  { to: 'user', act: 'inform', subject: 'Meeting Reminder', ... },
  { to: 'scheduler', act: 'propose', subject: 'Reschedule', ... },
];

These mocks validate that all seven FIPA-Lite acts render correctly in the message envelope UI.

Summary

Munder Difflin's FIPA-Lite implementation demonstrates how a minimal speech-act ontology can power complex multi-agent coordination:

• Seven acts (request, inform, propose, query, agree, refuse, done) cover the complete interaction lifecycle
• Dual-definition pattern in MessageEnvelope.ts and hive.ts maintains type safety across Electron processes
• Four conversation patterns (Request-Inform, Propose-Agree/Refuse, Query-Inform, Done-signaling) enable command, negotiation, discovery, and completion workflows
• Policy hooks on speech-act values enforce safety constraints without semantic parsing complexity

Frequently Asked Questions

What is FIPA-Lite versus full FIPA-ACL?

FIPA-Lite is Munder Difflin's curated subset of seven speech acts, while full FIPA-ACL defines over 20 communicative acts with formal semantics grounded in modal logic. The lite version sacrifices expressivity for implementation efficiency—agents don't need theorem provers to parse intent. According to the Munder Difflin source code, this trade-off was deliberate to keep the Electron-based architecture responsive.

Can agents define custom speech acts in Munder Difflin?

No—the MessageAct union type is closed. The TypeScript compiler rejects any act value outside the seven literals. This constraint appears in both src/renderer/src/scene/office/MessageEnvelope.ts and src/main/hive.ts. Extension would require modifying both files and updating the IPC validation layer in src/preload/index.ts.

How does Munder Difflin track conversation state with FIPA-Lite?

The system correlates messages through subject headers and requires_reply flags, not through explicit conversation IDs in the speech acts themselves. When requires_reply: true accompanies a request or query, the hive layer creates a promise that resolves on receiving the corresponding inform, agree, refuse, or timeout. This simpler-than-FIPA approach avoids nested conversation protocols.

Why include done instead of using inform for completion?

The done act enables distinct policy treatment for terminal states. In src/main/hive.ts, done messages bypass retry logic and immediately update persistent workflow records. An inform with completion content could be misinterpreted as intermediate progress. The dedicated act makes intention unambiguous for both human readers and automated tools.

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