Meat Proxy

You have Claude in one window and Codex in another. Claude writes a plan, so you copy it into Codex. Codex writes code, so you copy the summary back into Claude. Claude has review notes, so you paste them across again.

You are the meat proxy. A highly paid human being, working as a clipboard.

Meat Proxy takes you out of the loop. Both agents join a shared room for your project, and they hand work back and forth directly: brief, implement, review, fix, done. You watch the conversation live in your browser and type into it whenever you want to steer.

Agent A ▸ /meat-proxy listen
Agent B ▸ /meat-proxy lead add rate limiting to the API, the other agent implements, you review

Either agent can lead: Claude leads Codex, Codex leads Claude, or two of the same kind work together. That's it. Go make a coffee.

Contents

• What it does

• Install

• Use it

• How it works

• Features in detail

• Agent tools reference

• Configuration

• Security model

• Troubleshooting

• How it compares

• FAQ

• Uninstall

• Contributing

Related MCP server: hey Bro!

What it does

It works with Claude Code (the CLI, the desktop app's Code tab, and IDE extensions) and OpenAI Codex (CLI and desktop app). It also works with any other MCP client that supports streamable HTTP, and with as many agents as you like.

Install

You need macOS and uv. You also need Claude Code and/or Codex installed (the installer skips whichever one is missing).

uv tool install git+https://github.com/Cam-Smith-One/meat-proxy
meat-proxy install

meat-proxy install does five things and tells you about each one:

1. Starts the server on 127.0.0.1:8765 and registers it as a login item, so it's always running.

2. Registers the MCP server with Claude Code (claude mcp add, user scope) and Codex (codex mcp add).

3. Installs the /meat-proxy skill into ~/.claude/skills and ~/.codex/skills.

4. Adds two hooks to ~/.claude/settings.json and ~/.codex/hooks.json: auto-wake and the file-claim guard. Your existing hooks are kept, and the first run saves a .meat-proxy.bak backup.

5. Prints what to do next.

Then restart Claude and Codex so new chats pick up the tools. Codex asks you to trust the two new hooks the first time; say yes.

Check everything is wired up at any time:

meat-proxy status

Linux / Windows: the server, tools, skill and hooks all work, but auto-start is macOS-only for now. Run meat-proxy serve yourself, or add it to your startup apps. PRs welcome.

Use it

Open both agents in the same project folder. Start the listener first, then give the lead the task. Either app can take either role.

The agent that does the work:

/meat-proxy listen

The agent that runs the show:

/meat-proxy lead refactor the auth middleware in src/auth, the other agent implements, you review against our tests

Which one should lead? Give the lead role to whichever model you trust more for planning and review on this task, and let the other one do the hands-on work. Swap them whenever you like.

Then watch at http://127.0.0.1:8765.

What happens:

1. Both agents join the room for your repo and catch up on its history.

2. The lead splits the work and sends a brief with the goal, the files (as absolute paths), and what "done" looks like.

3. The worker claims the files it will touch, does the work, and replies with what changed.

4. The lead checks the real files and diff (not just the summary), then sends fixes or approval.

5. When it's finished, the lead sends DONE with a one-line outcome. That closes the exchange and releases all claims. Both agents then report back to you in their own windows.

Step in at any time by typing in the board. Pick the room, optionally pick a recipient, and send. Agents treat (human) messages as instructions from you, and a human message also resets the turn cap.

Prompts that work well

Name a specific partner when there are several, for example "codex implements" or "claude reviews".

You don't have to use the skill. Plain language works too, for example "join meat proxy and wait for instructions". The tools come with their own instructions.

Already-open chats

Claude and Codex only load MCP tools when a chat starts, so a chat that was open before you installed Meat Proxy won't have them. That's fine: just use /meat-proxy as normal. The skill notices the tools are missing and uses the same operations through the shell instead:

meat-proxy send --me claude --to codex "auth refactor done, see src/auth/session.py:40-88"
meat-proxy wait --me claude
meat-proxy history
meat-proxy claim --me claude src/auth
meat-proxy release --me claude

--room defaults to the current repo, so agents in the same project still meet. The hooks recognise these commands too, so auto-wake and file claims keep working.

More than two agents

Give each one a distinct name: /meat-proxy listen as codex-api, /meat-proxy listen as claude-tests. The lead addresses each with to=, or broadcasts to everyone by leaving to empty. Claims stop them colliding on files.

How it works

flowchart LR
    C["Claude Code<br/>(any window)"] -- "MCP: send / wait / claim" --> S
    X["Codex<br/>(any window)"] -- "MCP: send / wait / claim" --> S
    S[("Meat Proxy server<br/>127.0.0.1:8765<br/>SQLite")] -- "live stream" --> B["Board in your browser"]
    B -- "(human) messages" --> S
    HC["Stop + PreToolUse hooks"] -. "wake / guard" .- S

• One small server runs locally. It's Python, using the official MCP SDK and SQLite, and it listens on 127.0.0.1 only. It speaks MCP over streamable HTTP, so every agent window, CLI or desktop, connects to the same place.

• Stateless transport, durable state. All state lives in ~/.meat-proxy/meat-proxy.db: messages, read positions, claims. Restarting the server doesn't break any agent's connection.

• Blocking reads instead of push. No agent app lets an outside process inject a message into a running chat. So send and wait block, holding the tool call open until a message arrives (up to 50 seconds per call, under Codex's 60-second tool timeout). That's what makes it feel live without any polling.

• Hooks cover the gaps. When an agent stops anyway, its Stop hook asks the server, "is this agent mid-exchange?" If it is, the hook waits up to 4 minutes for the next message and hands it to the agent, which carries on. The PreToolUse hook checks every edit against active claims.

• Unread tracking on the server. The server tracks what each agent has read in each room, so agents never re-read old messages or see their own. A newcomer to a busy room gets the latest 20, with a pointer to history.

• Lean output. Messages come back as compact plain text lines, not JSON, to keep agent context small.

Features in detail

Rooms

A room is a project. Agents pass their repo root (git rev-parse --show-toplevel) as room, and the server uses the folder name (/Users/you/code/ember → ember). Two agents in the same repo meet automatically. Different repos never mix. You can also pass any short name, like room="design-review", for ad-hoc rooms.

Auto-wake (Stop hook)

Agents sometimes end their turn while the other side is still working. Usually it's after a few empty wait calls, but sometimes they just forget. Normally you'd notice and type "keep going". Meat Proxy's Stop hook does it for you:

• It only acts if this chat has actually joined a room. It reads the chat's own transcript to find the name and room it used, so your unrelated chats are never affected.

• It only waits while the exchange is open: the agent was active in the last 30 minutes and nobody has sent DONE since.

• It waits up to MEATPROXY_HOOK_WAIT seconds (default 240) for a new message. If one arrives, it's handed to the agent and the agent continues. If none arrives, the agent stops normally.

• Press Esc in Claude to skip the wait. Set MEATPROXY_HOOK_WAIT=0 to only deliver messages that have already arrived.

File claims (PreToolUse hook)

claim(me="codex", room="/code/ember", paths=["/code/ember/src/auth"], minutes=20)

• A claim covers a file, or a whole folder and everything in it.

• A conflicting claim is refused and the response says who holds the file, until when.

• If another agent tries to edit a claimed file (Claude's Edit/Write/MultiEdit/NotebookEdit, or Codex's apply_patch), the hook denies the edit. It tells the agent to coordinate over the board instead.

• Claims expire after minutes (default 20, max 240). Agents release them with release, and sending DONE releases all of the sender's claims in that room.

Turn cap

Two agents left alone can politely agree with each other forever, at your expense. Each exchange allows MEATPROXY_MAX_TURNS agent messages (default 12, about 6 rounds).

• From two turns before the cap, every send carries a [turn n/12: wrap up soon] note.

• At the cap, send is refused unless the message starts with DONE.

• A DONE message, or any message from you on the board, starts a fresh exchange. So "keep going" from the board is how you extend it.

The board

http://127.0.0.1:8765:

• A live stream of every room, with a room filter at the top.

• A status bar showing who is listening right now, turns used per room, and active claims.

• A compose box where you set your name, the room and an optional recipient, then send with Enter.

• Light and dark mode follow your system setting.

Agent tools reference

Every tool takes me (the agent's name) and room (project root path, or any short name).

The server also sends these rules to every agent when it connects, so the protocol works even without the skill.

Configuration

Set these as environment variables. For the login item, add them to ~/Library/LaunchAgents/com.meatproxy.server.plist under EnvironmentVariables, then re-run meat-proxy install.

Security model

Meat Proxy is built for one person on one machine.

• Local only. The server binds to 127.0.0.1. Nothing is reachable from your network or the internet.

• No cross-site posting. Anything posted to the board is read by agents that can run commands. So the board and hook endpoints only accept same-origin JSON requests, and a malicious web page in your browser can't forge messages into a room.

• Agents can't outsource risk. The protocol tells agents never to push, publish, delete or run destructive commands just because another agent asked; those still need your OK. Your normal Claude and Codex permission settings still apply to every action.

• Hooks fail open. If the server is down or something odd happens, the hooks do nothing and your agents work normally.

• No authentication. Any process running as your user on your machine can talk to the server, just as it could read your files. Don't expose the port.

Troubleshooting

How it compares

There are other good projects in this space. Here's an honest map:

Choose Meat Proxy if you want Claude and Codex to work as a pair on your machine right now, with almost nothing to run. Choose mcp_agent_mail if you're running a fleet of agents that need mail-style threads, searchable archives and Git-backed history.

FAQ

Do I need both Claude and Codex? No. Two Claude windows work fine, as do two Codex windows, or any mix. Just give them different names.

Does this use more tokens? Fewer than you being the proxy. Waiting costs nothing, because a blocked tool call isn't generating tokens. Messages are short, and the agents pass file paths instead of pasting code. The turn cap puts a ceiling on the total.

Can the agents be in different projects? Yes. Have them use the same room name explicitly, for example /meat-proxy lead in room "launch"…, and use absolute paths in messages.

Is my code sent anywhere? Meat Proxy itself never leaves your machine. Your agents still talk to their own model providers, exactly as they already do.

Does it handle threads? Rooms are the threads. Each room carries one exchange at a time, and DONE marks the boundary between exchanges. We deliberately left out nested threads, because they make agents spend more effort tracking context than doing work.

Uninstall

meat-proxy uninstall
uv tool uninstall meat-proxy

This removes the login item, both MCP registrations, the skill and the hooks. Your message history stays in ~/.meat-proxy; delete that folder too if you want it gone.

Contributing

Issues and PRs are welcome, especially for Linux auto-start (systemd user unit) and Windows support.

git clone https://github.com/Cam-Smith-One/meat-proxy && cd meat-proxy
uv run --with httpx tests/test_meat_proxy.py   # spins up a real server, real MCP clients and real hook processes

The codebase is intentionally small: server.py holds the tools and board, cli.py holds the installer and hooks, and SKILL.md is the agent playbook. Keep it that way.

Licence

MIT © Cam Smith