MAP Documentation

Every MAP protocol is exposed as an MCP tool. Stdio and SSE transports. Four tool categories.

MAP runs an MCP (Model Context Protocol) server at services/mcp/. Every protocol operation is exposed as a callable tool. Any MCP-compliant agent — Claude, ChatGPT with MCP support, custom MCP clients — can call MAP's full surface.

How tools are named

Every MAP operation maps to an MCP tool with the canonical name:

map.<protocol_id>.<operation>

Examples:

MCP tool	MAP dispatch
`map.macs.auth_negotiation`	`MACS::auth_negotiation`
`map.mind.recall_memory`	`MIND::recall_memory`
`map.marc.reasoning_task`	`MARC::reasoning_task`
`map.max.audit_query`	`MAX::audit_query`
`map.maker.execute_action`	`MAKER::execute_action`

The tool name is matched on the MCP host side; the engine routes by parsing the protocol and operation back out.

Tool categories

MAP groups tools into four MCP categories so agents can scope discovery:

Category	Protocols included
`map-cognitive`	MIND, MARC, MAVEN, MAGE, MEAL, MANTLE, MARE, MAME, MARI
`map-governance`	MOAT, MERIT, MACE, MAXIM, MOOT, MIMESIS, MAUSOLEUM
`map-commerce`	MARKET, MANA, MADE, MAT
`map-infrastructure`	MIM, MAX, MACS, MARS, MOON, MAESTRO, MOTE, MAZE, MATA, MAKER

A consumer agent can list only the categories it needs:

map mcp list --category map-cognitive

Transports

Two transports are supported:

stdio — for local agent processes (Claude Desktop, Cursor, custom hosts)
SSE — for remote / network-attached agents

stdio (Claude Desktop)

Configure your client's MCP server file (typically claude_desktop_config.json):

{
  "mcpServers": {
    "map": {
      "command": "map",
      "args": ["mcp", "serve", "--transport", "stdio"]
    }
  }
}

The CLI handles authentication using the stored config at ~/.map/config.json. The MCP server forwards every tool call through the standard dispatch pipeline — same auth, same capability check, same audit chain.

SSE (network)

# Start the MCP server on port 8601 with SSE transport
map mcp serve --transport sse --port 8601

Then point your MCP host at http://localhost:8601. For production, run behind a reverse proxy with TLS.

Tool schema

Every MCP tool exposes a JSON schema for its input. The schema is the same JSON Schema that MAP::schemas ships for the wire protocol — see Schemas.

Example for map.marc.reasoning_task:

{
  "name": "map.marc.reasoning_task",
  "description": "Submit a bounded reasoning task to MARC. Returns a derivation tree, citations, and confidence band.",
  "inputSchema": {
    "type": "object",
    "required": ["intent", "budget"],
    "properties": {
      "intent":   { "type": "string", "description": "Natural-language statement of the reasoning intent" },
      "premises": { "type": "array",  "items": { "type": "string" } },
      "world_model_snapshot": { "type": "string", "pattern": "^mind://snapshot/" },
      "budget": {
        "type": "object",
        "required": ["tokens", "deadline_ms"],
        "properties": {
          "tokens":      { "type": "integer", "minimum": 1, "maximum": 1000000 },
          "deadline_ms": { "type": "integer", "minimum": 100, "maximum": 600000 }
        }
      },
      "return_fields": {
        "type": "array",
        "items": { "type": "string", "enum": ["derivation", "citations", "confidence", "alternatives"] }
      }
    }
  }
}

Identity flow

When an MCP host calls a MAP tool, the MCP server:

Reads the host's session
Resolves the host's MAP identity (from the CLI config in stdio mode, or from the SSE session in network mode)
Builds an InvokeContext with the resolved identity
Runs the standard 8-stage pipeline

Cross-host calls require a MOAT treaty between the host's organization and the target. The MCP server does not bypass any engine policy.

Tool categories vs. protocol planes

The MCP categories don't perfectly match the seven planes. They are deliberately coarser — designed for agent consumption rather than internal taxonomy. An agent doesn't usually care that MAVEN is Truth and MAX is Awareness; it cares that both are "informational" tools it can call to retrieve facts and records.

MCP category	Planes it draws from
`map-cognitive`	II (Cognition) + III (Truth, partial) + VII (Awareness, partial)
`map-governance`	III (Truth, partial) + IV (Governance)
`map-commerce`	VI (Economic) + V (Execution, MAT)
`map-infrastructure`	I (Identity) + V (Execution, partial) + VII (Awareness, partial)

Discovering tools as an agent

import { MCPClient } from '@modelcontextprotocol/sdk';

const mcp = new MCPClient({ transport: 'stdio', command: 'map', args: ['mcp', 'serve'] });
await mcp.connect();

const allTools = await mcp.listTools();
console.log(allTools.tools.filter(t => t.name.startsWith('map.marc.')));

Or with the CLI:

map mcp list --json | jq '.tools[] | select(.category=="map-cognitive") | .name'

Calling tools as an agent

The agent passes a normal JSON payload; the MCP server dispatches through the engine; the response data is returned to the agent.

const result = await mcp.callTool({
  name: 'map.marc.reasoning_task',
  arguments: {
    intent: 'is the treaty enforceable?',
    budget: { tokens: 8000, deadline_ms: 12000 }
  }
});

console.log(result.content);
// [{ type: 'text', text: JSON.stringify({verdict: "...", derivation: "marc://tree/0x71b..." }) }]

Audit through MCP

Every MCP-originated call is audited the same way as a direct dispatch — same MAX::audit_log_entry, same MOTET::emit, same metric counters. From the institution's perspective, MCP is just another transport.

The audit record includes an origin: mcp field so you can later filter for MCP-originated activity. Useful for monitoring agent fleets.

Source

The MCP server lives in /Volumes/L1feAI/l1feosx/map/services/mcp/ and is composed of seven modules: server, categories, tool_gen, transport_stdio, transport_sse, auth_bridge, error_map. Tool listings are generated at startup from the registered ProtocolModules plus their JSON schemas.

MCP