Which integrations are available for this server?

Enables human-in-the-loop communication by facilitating message passing between AI agents and a human operator through Telegram, allowing agents to send structured 'oracle calls' for human judgment and receive responses.

How do I use Ordinal-MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Ordinal-MCP Ask the human if I should proceed with the database migration." That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Ordinal-MCP

An MCP server that implements an ordinal communication bus — a structured message-passing system between AI agents and humans based on ordinal levels of computation.

Built for the Rhode agent system. When an AI agent hits a decision boundary it can't resolve on its own, it makes an oracle call — a structured question sent up to the human operator. The human responds via Telegram, and the answer flows back down to the waiting agent.

The Ordinal Model

The system defines four computational levels:

Level	Role	Description
0	Infrastructure	Filesystem, network, containers
1	Subagent	Worker agents executing delegated tasks
2	Orchestrator	Rhode — the lead agent
3	Oracle	The human operator

Communication flows upward (oracle calls — asking the human) and downward (task delegation — assigning work to subagents). Messages are typed, structured, and archived.

How It Works

┌──────────┐ oracle_call() ┌──────────┐ Telegram ┌──────────┐ │ Subagent │ ──────────────────> │ Bus │ ─────────────> │ Human │ │ (Lv 1-2) │ <────────────────── │ (~/.rhode│ <───────────── │ (Lv 3) │ └──────────┘ response │ /bus/) │ reply └──────────┘ └──────────┘

An agent calls oracle_call("Should I deploy to production?")
The request is written as JSON to ~/.rhode/bus/requests/
Rhode's bus monitor picks it up and sends it to the human via Telegram
The human replies in Telegram
The response is written to ~/.rhode/bus/responses/
The agent receives the answer and continues
The exchange is archived to ~/.rhode/bus/history/

MCP Tools

`oracle_call`

Send a question to the oracle and wait for a response.

question: str — The question to ask (be clear and specific) context: str = "" — Optional context for the oracle urgency: str = "normal" — low | normal | high | critical timeout_seconds: int = 300 — How long to wait (default 5 min)

`bus_status`

Check the current state of the bus — pending requests, responses, and history count.

`list_pending_calls`

List all oracle calls currently waiting for a response.

`respond_to_oracle_call`

Answer a pending oracle call (used by the oracle/orchestrator side).

request_id: str — ID of the pending request answer: str — The response

`bus_history`

View recent completed exchanges.

limit: int = 10 — Max number of exchanges to show

Bus Directory Structure

~/.rhode/bus/ ├── requests/ # Pending oracle call requests (JSON) ├── responses/ # Oracle responses (JSON) └── history/ # Archived exchanges └── 20260207_143052/ ├── request_a1b2c3d4.json └── response_a1b2c3d4.json

Configurable via the ORDINAL_BUS_DIR environment variable.

Installation

Requires Python 3.13+ and uv.

git clone https://github.com/bobbyhiddn/Ordinal-MCP.git cd Ordinal-MCP uv sync

Run standalone

uv run ordinal-mcp

Configure as an MCP server

Add to your .mcp.json (e.g. in your Claude Code project root):

{ "mcpServers": { "ordinal-mcp": { "type": "stdio", "command": "uv", "args": ["run", "--directory", "/path/to/Ordinal-MCP", "ordinal-mcp"] } } }

Background

This implements a practical version of Turing's O-machine concept — a computation model where the machine can query an external oracle for answers to undecidable questions. In this system, the "undecidable questions" are judgment calls, preference decisions, and ambiguous requirements that only a human can resolve.

The ordinal levels give the system a clear hierarchy: infrastructure at the bottom, human at the top, with agents in between. Each level can call upward when it needs help and delegate downward when it can break work apart.