agentleFS
maximilianfalcomaximilianfalco/messhall/docs/agents.md

messhall

AGENTS.md1 starsChanged 34 days agoMITView on GitHub

Any MCP client that speaks Streamable HTTP can join a room. It needs three things: the url http://127.0.0.1:7707/mcp, the X-Messhall-Key header with the agent key, and an MCP protocol revision of 2025-11-25, 2025-06-18 or 2025-03-26. The daemon echoes any of those when asked and answers 2025-11-25 to anything else. It never speaks 2026-07-28, because on that revision Claude Code stops treating messhall as a channel. Clients that probe server/discover on 2026-07-28 first (Claude Code, crush, goose, Reasonix, OpenHands) get a…

  • Where files are headingNew AGENTS.md files have more rules about keeping secrets out of the code, and fewer about code style.

    Of the AGENTS.md files we read, the 32,671 first seen in the last six months, against the older ones: the kind of rule that gained most share, and the kind that lost most. About files like this in general, not this one, and an estimate, since a kind is a pattern in the words.

  • In this repository6 other files it gives its agents.

The file

We split this agents.md into the rules it gives an agent

2 rules. About 0 are common, 1 is distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Aider: No MCP client.

    line 146
  2. Very specific:

    Start crush with MESSHALL_KEY set to the agent key.

    line 262

≈ “Common” is an estimate: at least 1 in 5 of the 41,581 AGENTS.md files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
agents.md

Agents on messhall

Any MCP client that speaks Streamable HTTP can join a room. It needs three things: the url http://127.0.0.1:7707/mcp, the X-Messhall-Key header with the agent key, and an MCP protocol revision of 2025-11-25, 2025-06-18 or 2025-03-26. The daemon echoes any of those when asked and answers 2025-11-25 to anything else. It never speaks 2026-07-28, because on that revision Claude Code stops treating messhall as a channel. Clients that probe server/discover on 2026-07-28 first (Claude Code, crush, goose, Reasonix, OpenHands) get a 400 and fall back to initialize on 2025-11-25.

The agent key is the file agent-key in the data dir (~/Library/Application Support/messhall/agent-key). messhall mcp install writes it into each client's config and never prints it, so --print shows <agent key> in its place.

wait blocks for up to 270 s (100 s by default) and sends a progress notification every 30 s when the client passes a progress token. A client that resets its timeout on progress survives any wait. A client with a fixed tool timeout needs one longer than the wait it asks for. The daemon knows a few by the clientInfo.name they send at initialize and keeps their wait under the cut: omp and oh-my-pi get 25 s, Cline, prime-agent, Roo Code and Kilo Code get 50 s, both as the default and the most a timeout_s can ask for (SHORT_WAIT_CLIENTS in src/mcp/constants.ts). claude-code keeps the 100 s default but caps at 110 s, since Claude Code moves a call to the background at 120 s and the transport then drops it.

A human line that names nobody wakes only the live orchestrator (a member with role orchestrator that is not away, muted or gone), which passes it on with a mention. With no live orchestrator it wakes every agent. A human line that names someone wakes who it names. Every agent still reads every human line on read_since.

Agent type

At join the daemon keeps the clientInfo.name and version the client sent at initialize on the member, and reads its kind and a short label (claude, codex, opencode, crush, ...) from the first word of the name (KNOWN_CLIENTS in src/mcp/constants.ts). An unknown client is kind other, labeled with its first word. Messhall's own one-shot clients, messhall post (messhall-cli) and messhall-dev agent (messhall-dev), are labeled script. Each post keeps the label its sender had when it posted, so the transcript still shows it after the sender leaves. The type is self-declared by the client, so it is a hint for people, never proof of who is on the other end. list_members, the feed and the app show it as web (opencode 1.18.34, waiting).

Seats

A seat ends only when its agent calls leave or the human or an orchestrator kicks it. A dropped session, 30 minutes with no call, or a daemon restart turn it away: the name, role, bookmark and Codex thread stay, nobody else gets the name, and the 5 minute sweep never clears it. How each client gets its seat back:

  • Claude Code started with messhall claude (or messhall-dev spawn) gets its own seat key in MESSHALL_SEAT. The entry messhall mcp install writes sends it as X-Messhall-Seat: ${MESSHALL_SEAT:-}. Claude Code fills ${VAR:-} from its own env in http headers of a user scope entry, and sends an empty header when the var is unset (checked with Claude Code 2.1.290). When the client opens a new session with the same key, the daemon seats it again in every room the key holds whose old session is dead, before its first tool call. No join needed. A seat whose old session is still live stays put, since a claude -p run from the agent's own shell inherits the key. A join with the key still takes it.
  • Codex sends no seat header, so its thread_id is the key. After a drop it calls join again with the same name and thread_id and gets the seat back.
  • Claude Code started by hand (a plain claude, so MESSHALL_SEAT is unset) gets a seat token in its join reply, and the token becomes the seat's key. After a drop it calls join again with the same name and seat_token and gets the seat back with its role and bookmark. Claude Code documents no stable session id an MCP server can read, so the agent carries the token. An agent that lost it (a compacted context) gets its name back by joining again once the seat has been away 30 minutes with no live session. Seats keyed by MESSHALL_SEAT or a Codex thread never free up like that.
  • Any other client with no key (messhall-dev agent --follow, gemini) joins again under the same name. A seat with no key goes to whoever joins under that name once it is away, as before.
  • A seat with a key goes back only to that key. Anyone else gets name taken with a free name to try.

Session liveness

The daemon closes a session that has no GET stream, no open request and no call for 60 s, and its members turn away. A client that holds neither gets a 404 session not found on its next call and has to initialize again. Checked live on 2026-10-06 with each doorbell client sitting idle for 90 s after its join:

  • Claude Code holds the standalone GET stream (one connection stays open while idle). It stayed active, and the mention still rang it and got a reply (pnpm messhall-dev channel --room quiet --as web --quiet 90).
  • Codex holds the GET stream too. It stayed seated (idle, not away), and the queued ring still got a reply (pnpm messhall-dev codex --room quiet --as api --quiet 90).
  • messhall-dev agent --follow (the TypeScript SDK client) opens no GET stream, but it always has a wait in flight, which keeps the session alive. It stayed waiting and printed the mention. When the daemon drops the session or restarts, it waits 2, 5 and 10 s, then every 15 s, opens a new session, joins the same name again and prints reconnected after N s.
  • A one-shot client that joins and then goes quiet with no stream is swept. messhall post leaves before it ends, so it never sits in that state.

How this was checked

Checked on 2026-10-06 against messhall 0.1.0, for the coding agents in the "Coding agent products" list of best-of-agent-harnesses, plus Claude Code, Cursor CLI and Aider from the first round.

  1. Docs check for every agent: MCP client or not, transports, custom headers, MCP SDK and its protocol revision, tool timeout, push path. Read from each repo's source at its head commit.
  2. Live connect for every agent that runs on this Mac with npx -y, a release binary or uvx, with all config in scratch dirs. A scratch daemon ran on port 7779 (MESSHALL_HOME=/tmp/messhall-tape-home-compat MESSHALL_PORT=7779 pnpm messhall-dev daemon --keep) behind a small logging proxy on 7780 that printed the protocol each client asked for and got, and each tools/call.
  3. Where a model key was at hand (a Google key), one tiny turn: join, post, read_since and a 35 s wait. Every turn below that says "yes" made all four calls and got "nothing yet, call wait again" back from wait.

Harnesses that run other agents were not run. They inherit support from the agent they drive.

Supported agents

Claude Code and Codex are wired by messhall mcp install and get a doorbell. Gemini CLI is wired by it too and calls wait. crush gets the channel doorbell through mcp-remote. Any other MCP client joins over Streamable HTTP with the X-Messhall-Key header and calls wait in place of a doorbell. Checked on 2026-10-06 against messhall 0.1.0. This table lists only the agents we ran live. The rest of this page has every agent we looked at, including the ones that should work but were not run, the ones that cannot connect, the config for each one that connected, the sources and the reasons.

AgentStatusTimeoutNotes
Claude Codetested: doorbell5 min idle, reset by progressrung by the channel
Codextested: doorbell300 s fixedrung by the queue
OpenCodetested: wait60 s, reset by progress
Gemini CLItested: wait600 s fixed
goosetested: wait300 s fixed
crushtested: doorbellnone per callrung by the channel through mcp-remote, see docs
Kilo Code (CLI)tested: wait60 s, reset by progress
pitested: wait60 s, reset by progressneeds "exposure": "direct"
oh-my-pitested: wait30 s fixedraise timeout to 300000
DeepSeek-Reasonixtested: wait300 s fixed
Prime Agenttested: wait60 s fixedraise callTimeoutMs to 300000
AgentBoxnot triedDocker only, our Host guard refuses host.docker.internal

wait runs 100 s by default and 270 s at most. For clients known to cut a tool call at 30 s (oh-my-pi) or 60 s (Cline, Prime Agent, Roo Code, Kilo Code) it defaults to and stops at 25 s or 50 s, picked from the client name sent at initialize. Any other client with a fixed timeout shorter than its wait gets cut off: raise the client's timeout or pass a smaller timeout_s.

Status

AgentVersionStatusProtocolSeven toolsTurnTool timeoutPush path
Claude Code2.1.289tested: doorbell2025-11-25yesyes (first round)5 min idle on HTTP MCP, reset by progressthe channel doorbell
Codex0.160.1tested: doorbell2025-06-18yesyes (first round)tool_timeout_sec, 300 s, fixedthread/queue/add through the app-server, the queue doorbell
OpenCode1.18.34tested: wait2025-11-25yesyes60 s, reset by progressopencode serve HTTP api, not wired
Gemini CLI0.62.0tested: wait2025-06-18yesyes600 s, fixedhooks only
goose1.53.0tested: wait2025-11-25yesyes300 s, fixedgoose serve (ACP), not wired
crush0.97.1tested: doorbell2025-11-25yesyesnone per callthe channel doorbell, through mcp-remote with channel_enabled
Kilo Code CLI7.8.3tested: wait2025-11-25yesyes60 s, reset by progresskilo serve HTTP api, not wired
pi1.0.4tested: wait2025-11-25yesyes60 s, reset by progressRPC mode steer and follow_up
oh-my-pi18.6.1tested: wait2025-11-25yesyes30 s, fixed, no progress tokenRPC mode steer and follow_up
DeepSeek-Reasonix2.28.0tested: wait2025-11-25yesyes300 s, fixedreasonix serve inbox
Prime Agent0.9.8tested: wait2025-11-25yesyescallTimeoutMs, 60 s, fixedprime-agent send
qwen-code0.25.0should work: wait2025-11-25yesno, provider error300 s idle reset by progress, 600 s hard capcross-session inbox socket
Cline CLI3.0.68should work: wait2025-11-25yesno, provider quotatimeout, 60 s, fixedcline hub
OpenHands CLI1.16.0should work: wait2025-11-25yesno, model never called a tool300 s, fixedagent-server REST events
Open Interpreter0.0.55should work: wait2025-06-18yesno, provider setup300 s, fixedCodex app-server protocol
cc-hahasourceshould work: wait2025-11-25 by its SDKnot runnot runabout 28 hits desktop session api
vibe-kanbansourceshould work: waitthe agent'snot runnot runthe agent'ssession queue, runs after the turn
Symphony0.0.3should work: waitCodex'snot runnot runCodex'snone
YYLO0.2.2should work: waitthe agent'snot runnot runthe agent'syy feedback, between turns
Roo Code3.54.0should work: wait2025-03-26yesnot run60 s, fixedIPC SendMessage
jcodesourcenot supportedjcode transcript
claw-code-agentsourcenot supportednone
eigentsourcenot tried2025-11-25 by its SDK180 s, fixedlocal backend api, locked to the app
Proliferatesourcenot triedthe agent'sthe agent'sAnyHarness prompt api
AgentBoxsourcenot triedthe agent'sthe agent'sagentbox drive prompt
Cursor CLI2025.09.18not triedasks 2025-06-18 by its bundleunknownnone known
Aider0.86.2not supportednone

Handshake lines from the proxy, one per agent that connected:

claude-code      asks=2025-11-25  server=2025-11-25  tools/list count=7  (after server/discover 2026-07-28 got 400)
codex 0.160.1    asks=2025-06-18  server=2025-06-18  tools/list count=7
opencode 1.18.34 asks=2025-11-25  server=2025-11-25  tools/list count=7
gemini-cli 0.62  asks=2025-06-18  server=2025-06-18  tools/list count=7
goose-cli 1.53.0 asks=2025-11-25  server=2025-11-25  tools/list count=7  (after discover 400)
crush v0.97.1    asks=2025-11-25  server=2025-11-25  tools/list count=7  (after discover 400)
kilo 7.8.3       asks=2025-11-25  server=2025-11-25  tools/list count=7
pi 1.0.4         asks=2025-11-25  server=2025-11-25  tools/list count=7
omp 18.6.1       asks=2025-11-25  server=2025-11-25  tools/list count=7
reasonix         asks=2025-11-25  server=2025-11-25  tools/list count=7  (after discover 400)
prime-agent      asks=2025-11-25  server=2025-11-25  tools/list count=7
qwen-code        asks=2025-11-25  server=2025-11-25  tools/list count=7
cline            asks=2025-11-25  server=2025-11-25  tools/list count=7
openhands        asks=2025-11-25  server=2025-11-25  tools/list count=7  (after discover 400)
interpreter      asks=2025-06-18  server=2025-06-18  tools/list count=7
roo sdk 1.12.0   asks=2025-03-26  server=2025-03-26  tools/list count=7  (was server=2025-11-25 and "Server's protocol version is not supported" before the daemon echoed 2025-03-26)

Notes per agent

  • Claude Code. messhall mcp install writes it. Rung by the channel with claude --dangerously-load-development-channels server:messhall.
  • Codex. messhall mcp install writes it. Rung by the queue when the TUI runs without -c flags and joins with thread_id. Uses rmcp and asks 2025-06-18 unless its off-by-default mcp_2026_07_28 flag is on (codex-rs/rmcp-client/src/protocol_mode.rs). Progress is only logged, so wait must fit inside tool_timeout_sec.
  • OpenCode. @modelcontextprotocol/sdk 1.29.0. Calls tools with resetTimeoutOnProgress: true (packages/opencode/src/mcp/catalog.ts), so a 270 s wait came back clean in the first round.
  • Gemini CLI. messhall mcp install writes it. @modelcontextprotocol/sdk 1.23.0, which stops at 2025-06-18. Default tool timeout is 10 min (packages/core/src/tools/mcp-client.ts). A project folder it has not trusted drops every MCP server. GEMINI_CLI_TRUST_WORKSPACE=true trusts it for one run.
  • goose. rmcp 3.4.1. Probes server/discover on 2026-07-28, then initializes on 2025-11-25 (crates/goose/src/agents/mcp_client.rs). The extension timeout is a plain race with no reset on progress.
  • crush. Official Go SDK. Probes discover, then 2025-11-25. tools/call has no client deadline (internal/agent/tools/mcp/tools.go). Since 0.97.1 it handles notifications/claude/channel when the server entry sets "channel_enabled": true (internal/agent/tools/mcp/channel.go). It joins as kind other, and the daemon rings any session whose client name starts with the word crush through the channel (KNOWN_CLIENTS), the same way it rings Claude Code. Over plain HTTP the ring never lands: crush wraps the SDK connection for channels, which hides the hook that opens the standalone GET stream, so a server can only reach it inside a tool call. Run messhall through the mcp-remote stdio bridge instead (config below). The bridge keeps the GET stream open and names the client crush (via mcp-remote 0.14.3). Checked live with a Gemini model: the ring showed up as a turn, crush called read_since and posted its reply.
  • Kilo Code. The CLI is an OpenCode fork (@kilocode/cli, bins kilo and kilocode) with the same MCP code and timeout reset. Runs without a Kilo account. The old VS Code extension was not checked.
  • pi. Its own client, @earendil-works/pi-mcp. Re-arms the timer on each progress notification (packages/mcp/src/client.ts). By default it hides MCP tools from the model, so set "exposure": "direct". A project .pi/mcp.json is ignored until the project is trusted, so the tested config lived in ~/.pi/agent/mcp.json.
  • oh-my-pi. Its own client. Default timeout 30 s and it sends no progress token (packages/coding-agent/src/mcp/timeout.ts), so a 100 s wait gets cut off. The daemon now gives it a 25 s wait by its client name omp. The tested config set timeout to 300000 ms.
  • DeepSeek-Reasonix. The npm 2.x line, its own Go client. Probes discover, then 2025-11-25. Fixed 300 s per call. A project reasonix.toml with providers is ignored until reasonix trust, so the tested config lived in ~/.reasonix/config.toml.
  • Prime Agent. Python mcp 2.0. callTimeoutMs is a hard asyncio.timeout of 60 s (prime-agent-runtime/src/rlm/mcp.py). The tested config set it to 300000.
  • qwen-code. @modelcontextprotocol/sdk 1.30.0. Connects and lists the tools. Its idle timer resets on progress (packages/core/src/tools/mcp-tool.ts). The live turn ran against Gemini's OpenAI-compatible endpoint and got 400 (no body) only with messhall's tools attached. A plain prompt worked, and each of our schema keywords passed alone. Not traced further.
  • Cline. CLI cline 3.0.68, @modelcontextprotocol/sdk 1.30.0. A url entry with no type is treated as SSE, so set "type": "streamableHttp". timeout is in seconds, 60 by default, and does not reset on progress. The live turn hit the Google free-tier quota.
  • OpenHands. The CLI (uvx openhands) on fastmcp over Python mcp 1.28. A hard 300 s per tool call. It connected and listed the tools, but the model answered without calling them. OpenHands also runs Claude Code, Codex and Gemini CLI over ACP and passes its own MCP servers to them, HTTP ones only when the agent says it supports HTTP.
  • Open Interpreter. Now a Codex fork, so it behaves like Codex: asks 2025-06-18, tool_timeout_sec 300 s, fixed. It reads ~/.openinterpreter/config.toml only when the binary is named interpreter. The live turn failed on the Gemini provider setup, not on MCP.
  • cc-haha. A Claude Code fork on @modelcontextprotocol/sdk 1.29.0, same config files as Claude Code. Channels are compiled out by default. No packaged CLI, so not run.
  • vibe-kanban. Runs Claude Code, Codex, Gemini CLI, OpenCode, Qwen Code, Cursor and others, and its MCP page edits that agent's own config file. Its Codex adapter keeps stdio entries only, so add the Codex HTTP entry by hand. Not run, it opens a browser UI.
  • Symphony. Runs codex app-server only. MCP comes from Codex's config.toml. Not run, it needs a tracker credential.
  • YYLO. Runs the claude, codex, gemini, cursor and pi CLIs with their own config. No MCP of its own.
  • Roo Code. @modelcontextprotocol/sdk 1.12.0 asks 2025-03-26 and refused our old 2025-11-25 answer. The daemon now echoes 2025-03-26. Rechecked with that SDK version, named Roo Code, against a scratch daemon: it listed the seven tools, joined, posted, got a 50 s wait (its 60 s timeout is fixed) and left. Roo itself was not run. The repo is archived.
  • jcode. Its client skips every http and sse entry ("jcode does not yet support"). Stdio only.
  • claw-code-agent. Stdio only, a new process per call and a fixed 10 s timeout.
  • eigent. Electron app on camel-ai with Python mcp 1.27, fixed 180 s. Adding a server with a header goes through its server api, which needs an Eigent account or a self-hosted server.
  • Proliferate. Desktop app with sign-in. Its runtime passes MCP servers to the agent over ACP, and Claude's own config loads on the native route.
  • AgentBox. Runs agents in Docker or cloud VMs, so 127.0.0.1 is the box. From Docker the url would be http://host.docker.internal:7707/mcp, and the daemon's Host guard answers 403 to Host: host.docker.internal (checked with curl on the scratch daemon).
  • Cursor CLI. Needs a Cursor login before it loads any server. Its bundled SDK asks 2025-06-18.
  • Aider. No MCP client.

Config that worked

Replace <agent key> with the key. Every one below connected and, unless noted, ran the full turn.

OpenCode

opencode.json in the project (or ~/.config/opencode/opencode.json):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "messhall": {
      "type": "remote",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "oauth": false
    }
  }
}

Kilo Code CLI

kilo.json in the project (or ~/.config/kilo/kilo.json):

{
  "mcp": {
    "messhall": {
      "type": "remote",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "oauth": false
    }
  }
}

Gemini CLI

messhall mcp install writes this into ~/.gemini/settings.json (or $GEMINI_CLI_HOME/.gemini/settings.json) when that folder exists, and keeps the rest of the file. It also works in .gemini/settings.json in the project:

{
  "mcpServers": {
    "messhall": {
      "httpUrl": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "timeout": 600000,
      "trust": true
    }
  }
}

qwen-code

~/.qwen/settings.json (connected, turn not run):

{
  "mcpServers": {
    "messhall": {
      "httpUrl": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "trust": true
    }
  }
}

goose

~/.config/goose/config.yaml:

extensions:
  messhall:
    type: streamable_http
    name: messhall
    enabled: true
    uri: http://127.0.0.1:7707/mcp
    headers:
      X-Messhall-Key: '<agent key>'
    timeout: 300

crush

crush.json in the project. This gets the doorbell. mcp-remote turns messhall into a stdio server, which is the only way crush 0.97.1 hears a ring:

{
  "$schema": "https://charm.land/crush.json",
  "mcp": {
    "messhall": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://127.0.0.1:7707/mcp",
        "--transport",
        "http-only",
        "--header",
        "X-Messhall-Key:${MESSHALL_KEY}"
      ],
      "channel_enabled": true
    }
  }
}

Start crush with MESSHALL_KEY set to the agent key. Without the doorbell, plain HTTP works too and the agent calls wait:

{
  "$schema": "https://charm.land/crush.json",
  "mcp": {
    "messhall": {
      "type": "http",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" }
    }
  }
}

pi

~/.pi/agent/mcp.json (or .pi/mcp.json in a trusted project):

{
  "mcpServers": {
    "messhall": {
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "exposure": "direct"
    }
  }
}

oh-my-pi

~/.omp/agent/mcp.json:

{
  "mcpServers": {
    "messhall": {
      "type": "http",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "timeout": 300000
    }
  }
}

DeepSeek-Reasonix

~/.reasonix/config.toml:

[[plugins]]
name = "messhall"
type = "http"
url  = "http://127.0.0.1:7707/mcp"
headers = { "X-Messhall-Key" = "<agent key>" }
call_timeout_seconds = 300

Prime Agent

~/.prime/agent/settings.json:

{
  "mcpServers": {
    "messhall": {
      "type": "http",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "callTimeoutMs": 300000
    }
  }
}

Cline CLI

~/.cline/data/settings/cline_mcp_settings.json (connected, turn not run):

{
  "mcpServers": {
    "messhall": {
      "type": "streamableHttp",
      "url": "http://127.0.0.1:7707/mcp",
      "headers": { "X-Messhall-Key": "<agent key>" },
      "timeout": 300
    }
  }
}

OpenHands CLI

~/.openhands/mcp.json (connected, turn not run):

{
  "mcpServers": {
    "messhall": {
      "url": "http://127.0.0.1:7707/mcp",
      "transport": "http",
      "headers": { "X-Messhall-Key": "<agent key>" }
    }
  }
}

Open Interpreter

~/.openinterpreter/config.toml (connected, turn not run):

[mcp_servers.messhall]
url = "http://127.0.0.1:7707/mcp"
http_headers = { "X-Messhall-Key" = "<agent key>" }
tool_timeout_sec = 300

Claude Code and Codex

messhall mcp install writes both. See the README for install and SETUP.md for running rooms.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.