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

> Discover the 7 FIPA-Lite speech acts request inform propose query agree refuse and done used in Munder Difflin for efficient agent communication.

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

---

**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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/MessageEnvelope.ts) for the renderer and [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/renderer/src/scene/office/MessageEnvelope.ts) and mirrored in [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/hive.ts) to maintain consistency across the renderer/main process boundary:

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

```typescript
// 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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/hive.ts) and responds:

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

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

```typescript
// 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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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.

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

```typescript
// 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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/renderer/src/scene/office/MessageEnvelope.ts) — defines envelope structure and speech act literals
- **Main**: [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/hive.ts) — re-exports identical type for agent runtime
- **Preload**: [`src/preload/index.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/mockEvents.ts) store contains literal speech-act strings for integration testing:

```typescript
// 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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/MessageEnvelope.ts) and [`hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/renderer/src/scene/office/MessageEnvelope.ts) and [`src/main/hive.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/hive.ts). Extension would require modifying both files and updating the IPC validation layer in [`src/preload/index.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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`](https://github.com/chaitanyagiri/munder-difflin/blob/main/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.