HarnessTalk-Bridge: An MCP server that lets your harnesses consult each other

TL;DR: A local MCP server that lets AI agent harnesses (OpenClaw, Hermes, Claude, etc.) ask each other questions mid-task. Structured briefs, urgency tiers, native sessions, audit log. Python, zero external services.

---

The Problem

You're running multiple agent harnesses — maybe OpenClaw for orchestration, Hermes for coding, Claude for analysis. Each one is good at different things. But when one gets stuck, it can't ask another for help without you copy-pasting between terminals.

What HarnessTalk-Bridge Does

It's a local MCP server that sits between your harnesses. Any registered target can send a structured brief to any other target and get a response back as a tool result.

┌──────────────────┐         ┌──────────────────┐
│ OpenClaw         │         │ Hermes           │
│                  │         │                  │
│ tool: consult ───┼────┐ ┌──┼── tool: consult  │
└──────────────────┘    │ │  └──────────────────┘
                        ▼ ▼
               ┌─────────────────────┐
               │ HarnessTalk-Bridge  │
               │ (MCP server)        │
               │                     │
               │ ├─ adapter: hermes  │
               │ ├─ adapter: openclaw│
               │ └─ adapter: claude  │
               └─────────────────────┘

Key Features

• Bidirectional & symmetric — any target can call any other target
• Structured briefs — goal / tried / failing / ask format forces clear questions instead of vague "help me" prompts
• Urgency tiers — quick (stateless one-shot), deep (persistent session with follow-ups), blocker (persistent + optional stronger model swap)
• Honest capabilities — adapters declare what they can actually do (native sessions vs replay vs none, exact tokens vs estimated). The bridge validates at boot and refuses to register liars.
• Non-blocking concurrency — per-session locks + per-target semaphores. If a target is busy, you get BUSY instead of hanging.
• Bounded responses — configurable max_response_bytes per target, truncation surfaced as a flag
• Audit log — JSONL index + body store for forensics. Every consult is traceable.

Adapter Taxonomy

Each adapter declares a kind that constrains its capabilities:

Kind	Mechanism	Sessions	Tokens
HTTP_API	requests/SDK	native	exact
MCP_PROXY	calls target's MCP server	depends on harness	from harness
CLI_SUBPROCESS	spawn + stdin/stdout	replay or native	estimated
PTY_ATTACHED	pexpect against REPL	fragile	unknown

The Hermes adapter (just upgraded to v2.2) uses native sessions — it reads session IDs from Hermes's SQLite store and passes --resume <id> on follow-ups. No replay history, constant token cost per turn instead of linear growth.

Structured Briefs

Instead of freeform "ask the other agent something", callers fill in four fields:

{
  "goal": "What I'm trying to accomplish",
  "tried": ["What I've already attempted"],
  "failing": "The specific thing that's not working",
  "ask": "The precise question for the other agent"
}

This forces actual problem-solving instead of vague delegation.

Getting Started

git clone git@github.com:tuxclaw/harnesstalk-bridge.git
cd harnesstalk-bridge
python -m venv .venv && source .venv/bin/activate
pip install -e '.[dev]'

# Configure targets
cp config/targets.toml config/targets.toml.local
# Edit with your harness details

# Run (stdio for spawned servers, HTTP for shared)
harnesstalk-bridge
harnesstalk-bridge --transport streamable-http

Register the bridge as an MCP server in your harness config and you're set.

What's Next

• v3: adapter health checks, Claude API adapter validation, streaming through the server
• More adapters — if your harness has a CLI or API, an adapter is ~100 lines of Python

Repo: github.com/tuxclaw/harnesstalk-bridge

Built with Python 3.11+, FastMCP, Pydantic v2. Runs on anything — designed for Bazzite/Fedora immutable but works anywhere Python does.