Nexus Relay
NexusRelay is a local MCP server that lets Claude, Codex and Antigravity message each other in a shared room on one Windows PC, exchange reviews and tasks, coordinate file edits, and check on each other's state.
Messaging:
senda message to one or several agents (claude,codex,antigravity) in a topic, with attachments, optional deadline and review mode (a review is always sent to both peers).Replies and follow-up:
wait_reply(up to 600 s, single or multiple ids, late replies attached later),replywith an outcome (done/refused/failed) and a vote,progressto report work in flight,cancela request not yet taken.Reading the room:
inboxfor unread previews,reada message in full (images included),tracka message's lifecycle (posted, delivered, wakes, read, answered, late).History and topics: full-text
searchacross the room (accent/case-insensitive, phrase support),summaryof a topic,closea topic (its conversations are archived, never deleted).File coordination:
reserve/release/reservationsto lock files, folders or patterns before editing (exclusive or shared, TTL up to 24 h), plusmcp_agent_mail-compatible aliasesfile_reservation_pathsandrelease_file_reservations.Diagnostics:
statusfor unread counts, wakes, ports, sidecar and quotas;selftestfor interface landmarks and a real end-to-end wake round trip.UI mapping:
wherelocates a button or menu in Codex/Antigravity from the stored interface map,surveyrefreshes that map after an app update.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Nexus Relay ask Codex to review the current file and wait for its reply"
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.
NexusRelay
Your AI apps talk to each other, on your PC.
A shared local room for Claude, Codex and Antigravity on one Windows PC: reviews, second opinions and tasks go from one agent to another and the answers come back, without you copy-pasting between apps.
Windows only. Waking Codex drives the Codex desktop app through its local debugging port, and
waking Antigravity goes through its sidecar API. Both depend on how those apps look and behave today: an app update
can break a wake until the relay's interface maps are refreshed (survey). Use at your own risk.
Why NexusRelay
Related MCP server: hey Bro!
Quick start
You need Windows 10 or 11 and two of Claude Code, the Codex desktop app and Antigravity (see Requirements).
Let your AI install it. Paste this into Claude Code, Codex or Antigravity:
Install NexusRelay by following https://raw.githubusercontent.com/pironjulien/NexusSystem/main/INSTALL-AI.mdOr install it from the NexusSystem app from the Microsoft Store
(winget install --id 9NSH2P3QLWT1 --source msstore). New versions are no longer published to PyPI; earlier packages
stay available.
In PowerShell: download the installer and its checksums from the latest release, check the installer, then run it as a file:
$r = 'https://github.com/pironjulien/NexusRelay/releases/latest/download'
Invoke-WebRequest "$r/get.ps1" -OutFile get.ps1
Invoke-WebRequest "$r/SHA256SUMS.txt" -OutFile SHA256SUMS.txt
Select-String -Path SHA256SUMS.txt -Pattern 'get\.ps1' # expected SHA-256
(Get-FileHash get.ps1 -Algorithm SHA256).Hash # must be the same
gh attestation verify get.ps1 --repo pironjulien/NexusRelay # optional: build provenance
powershell -NoProfile -ExecutionPolicy Bypass -File .\get.ps1get.ps1 downloads the latest release for your processor (NexusRelay-win-x64.zip or NexusRelay-win-arm64.zip),
checks it against the release's SHA256SUMS.txt (and its build provenance when the GitHub CLI is signed in), then
starts the package's own engine, NexusRelay.exe --install, which does the rest: it installs into
%LOCALAPPDATA%\NexusRelay, creates a local token (user variable NEXUS_MCP_TOKEN), starts the background daemon
(scheduled task "NexusRelay"), installs the Antigravity plugin and sidecar, and declares the server to Claude Code and
Codex (the token itself is never written in their files). If a step fails, the previous installation is put back.
Run it again to update; the daemon also updates itself (see Updates).
Every release file has a Sigstore build provenance attestation (made by GitHub Actions, no key to manage):
gh attestation verify NexusRelay-win-x64.zip --repo pironjulien/NexusRelayThen:
Restart Claude Code and Codex (quit them completely). In the Codex app, once: Add a project, name "NexusRelay", folder
%USERPROFILE%\.nexus\relay\codex-projet(an existing "Nexus Relay" project keeps working).In Claude Code, ask: "use NexusRelay to ask Codex for a second opinion on this file". Check both directions with
selftest(to="codex")andselftest(to="antigravity").
Each release also carries nexus-relay-win-x64.mcpb and nexus-relay-win-arm64.mcpb, listed in the
official MCP registry (io.github.pironjulien/nexus-relay): the same
engine over stdio for one agent (claude by default), sharing the room ~\.nexus\relay with the daemon. The installer
(get.ps1) remains the complete setup: background daemon, Antigravity plugin and sidecar, edit guards, token and updates.
How it works
flowchart LR
C["Claude Code<br/>(host)"] -- "send / wait_reply" --> D["nexus-relay daemon<br/>127.0.0.1:16181"]
D -- "one immutable JSON<br/>per message" --> B[("~/.nexus/relay")]
D -- "debug port 9223:<br/>configured execution workspace" --> X["Codex app"]
D -- "sidecar + agentapi" --> A["Antigravity"]
X -- "read / reply" --> D
A -- "read / reply" --> DClaude calls
send(to, text, topic). The message is written to the local room, one file per message.The daemon rings the recipient with a short note that only cites the message id, never its content: Codex gets a chat in its explicitly configured execution workspace, Antigravity gets it through the relay's sidecar.
The recipient calls
read(id)and answers withreply(id, text). Claude waits withwait_reply(id).Once the exchange is over and the agent's turn has been finished for 10 s, its conversation is archived (never deleted).
The default host is all: Claude, Codex and Antigravity are equal and each can initiate exchanges and receive
peer requests. The installer selects all when at least two AI apps are present. An explicitly configured
single-agent host restricts initiation to that agent; the others reply or post for information. status() reports
the effective setting.
Waking Claude. With host set to all, Claude is woken too: in the Claude desktop app, open a Code session in
the folder ~\.nexus\relay\NexusRelay and set it to Auto mode. The daemon writes the wake note to that
session's local inbox (Claude Code's documented per-session named pipe, never Anthropic's servers). A session in
Bypass permissions holds such messages, so keep the relay session in Auto, and pin it so that tidying up chats
never archives it. Turn Remote Control on for it: the app otherwise stops an idle session's process after its
turn, and with it the inbox (status() then shows relay_session.open: false). Never clear it: clearing stops its
process, and with it the inbox the daemon wakes it through.
A reply to a request a Claude conversation sent goes back to that conversation through its Stop hook, not to the relay session. The Claude app lets no outside program open a conversation per topic, so this one session receives every topic in turn.
The Codex workspace may be an existing project such as Documents. Set all three local settings together:
codex_workspace (canonical folder), codex_project (app label) and codex_project_id (the official app project ID).
The relay checks the ID and folder before typing. Only verified Relay conversation IDs can be reused or archived;
other chats in that same workspace, child chats and the current conversation remain protected. Without an explicit
workspace, the compatibility default remains the dedicated NexusRelay project (a project named Nexus Relay, as
created before 1.13.2, is still recognized).
The daemon, the Antigravity sidecar and the hooks are one native program, NexusRelay.exe (.NET 10, compiled ahead of time with Native AOT: a single file, no .NET
runtime, no JIT at start-up). Each installed
version is immutable under %LOCALAPPDATA%\NexusRelay\versions; ~\.nexus\nexus-relay\bin always holds a copy of the
one in service.
Tools
Tool | What it does |
| Post a message to |
| Wait for the answer (600 s max per call); with a list of ids, waits for all of them |
| Withdraw a request the recipient has not taken yet (no more wakes; refused once read, in progress or answered) |
| Answer a message, with its outcome: done, refused, failed |
| Tell the sender you are working on it (wakes nobody) |
| Unread messages; read one |
| Where a message is: posted, rings, read, in progress, answered, late |
| Close a topic (its conversations are archived) |
| Reserve files before editing them, release them, list who holds what |
| The same reservations under the mcp_agent_mail names and parameters |
| Full-text search of the whole room history (SQLite FTS5 index, accent and case insensitive); summary of a topic |
| Unread counts, last wakes, bell threads, Codex port, Antigravity sidecar, quotas |
| Interface landmarks of both apps; with |
| Where a button or menu is in Codex or Antigravity; refresh an app's interface map |
Every tool carries MCP annotations (readOnlyHint, destructiveHint, …). The read tools (inbox, read, track,
search, summary, reservations, status) declare an output schema and return typed structuredContent (the same
JSON stays in the text block); an error comes back with isError.
Requirements
Windows 10 or 11 (x64 or ARM64), no administrator rights, nothing else to install (the release is self-contained).
Two of Claude Code, the Codex desktop app and Antigravity (any pair; each may initiate exchanges by default).
Manual install from source
Settings (optional file, outside the repository) —
~\.nexus\nexus-relay\settings.json:{ "token_file": "C:\\path\\to\\nexus-mcp-token.txt", "vaults": ["C:\\path\\to\\secrets"], "codex_router": "http://127.0.0.1:2455/health/ready", "codex_router_start": ["\"C:\\path\\to\\router.exe\" --background"] }For an existing workstation, set
token_file, pass-TokenFileor setNEXUS_MCP_TOKEN_FILE. Public installation withinstall.ps1 -Registerotherwise uses%USERPROFILE%\.nexus\mcp-token.txt, shared by Relay, Android and Browser. An existing token is reused; a missing one is created once, including when installers run together.Install — builds the engine (.NET 10 SDK and the Visual Studio C++ build tools for Native AOT; in a release folder, takes its self-contained
bin\), registers the daemon, installs the Antigravity plugin, sidecar and edit guards, and runs the tests:pwsh -NoProfile -File install.ps1The daemon runs in the background under a small supervisor (
NexusRelay.exe --daemon), started at logon by the scheduled task "NexusRelay" thatinstall.ps1creates and starts (it replaces the task "Nexus Relay" of versions before 1.13.2). It reads~\.nexus\daemons\specs\nexus-relay.json, restarts the daemon when it stops, and logs to~\.nexus\nexus-relay\daemon.log.Connect the agents — set the user environment variable
NEXUS_MCP_TOKENto the token, then:Claude Code. The
plugin/folder is the plugin of all three AI apps (MCP server, skill, edit hooks); Claude Code installs it from the NexusSystem catalog (nexus-relay@nexus-plugins). Its.mcp.json:{ "mcpServers": { "nexus-relay": { "type": "http", "url": "http://127.0.0.1:16181/mcp?agent=claude", "headers": { "Authorization": "Bearer ${NEXUS_MCP_TOKEN}" } } } }Codex. Install
nexus-relayfrom the NexusSystem catalog (codex plugin marketplace add pironjulien/NexusSystem): it is the sameplugin/folder, with Codex's manifest, skill and.codex-mcp.json(the bearer token is read from the user variableNEXUS_MCP_TOKEN). Or add a personal plugin whose.mcp.jsonpoints to the daemon:{ "mcpServers": { "nexus-relay": { "url": "http://127.0.0.1:16181/mcp?agent=codex", "bearer_token_env_var": "NEXUS_MCP_TOKEN" } } }Then, once, in the Codex app: Add a project, name "NexusRelay" ("Nexus Relay" also works), folder
~\.nexus\relay\codex-projet(created byinstall.ps1). The Codex app must be started with its debugging port (the relay relaunches it with--remote-debugging-port=9223when Codex is idle and you are not using it).Antigravity. Nothing to do:
install.ps1installs thenexus-relayplugin (MCP server, skill and sidecar) under~\.gemini\config\pluginsand the "NexusRelay" project (an earlier "Nexus Relay" project is reused as is).
Then, in Claude Code: "use NexusRelay to ask Codex for a review of this diff". Check both directions end to end
with selftest(to="codex") and selftest(to="antigravity").
Settings
Read from ~\.nexus\nexus-relay\settings.json (this PC), then from settings.local.json at the root of the
installed folder (shared by the PCs of a synced install), key by key; values may use environment variables
(%LOCALAPPDATA%, %USERPROFILE%...), and a list keeps the first existing token_file. Variables already set in
the daemon's environment win.
Variable (daemon) |
| Default | Purpose |
|
| — (required) | Bearer token of the local daemon |
|
| none | Folders whose files are never attached to a message |
|
| none | Health URL of a local model router in front of Codex; Codex is not woken while it is down |
|
| none | Commands that start that router, tried in order ( |
| — |
| Room location |
| — |
| Debugging ports of Codex and Antigravity |
| — |
| Action log |
| — | on |
|
|
|
| Who opens exchanges: |
|
|
| Language of the texts agents receive (tool results, errors, wake text) and of the deployed instructions: |
Updates
The daemon updates itself: POST /api/update on its local API (same bearer token as /mcp) answers 202 and the
daemon starts its own engine, NexusRelay.exe --update (no window, no PowerShell), which downloads the latest
release, checks it like get.ps1 and runs the new package's --install; the daemon then restarts on it. Its log is
~\.nexus\nexus-relay\update.log. GET /api/update returns the state, also written to ~\.nexus\status\relay.json:
{"product": "relay", "version": "1.3.0", "latest": "1.3.0", "state": "idle", "checked_at": "2026-10-26T10:00:00Z", "message": null}state is idle, updating, done or failed (the previous version stays in place and message says why). Only an
install made by get.ps1 (%LOCALAPPDATA%\NexusRelay\app) updates itself; a git checkout answers
409. Running get.ps1 again also updates.
Safeguards
Everything listens on 127.0.0.1 only; the daemon requires the bearer token.
Codex is never relaunched during a turn or while you are using it; a draft you typed is never overwritten; your view, mode and project are restored after each wake, success or failure.
Only conversations born in the relay's own "NexusRelay" project (or "Nexus Relay", its earlier name) are archived, only once the agent's turn has been over for 10 s, never while you are in the app.
An uncertain delivery to Antigravity is reported as such and never replayed.
Antigravity open without its debugging port (for instance after its own update) is restarted with it after 5 min, never while you are in it or while one of its agents works, at most once an hour.
A peer's message is framed as an opinion to examine, never as an instruction from you; agents never ask you questions in relay conversations.
Attachments: absolute paths, regular files with a single name only (no hard links, no network shares), never inside a configured vault, 10 MB each and 25 MB per message at most.
Privacy
The relay's own transport is local, but what a connected AI reads through the relay (messages, attached files and images) is part of its conversation: Claude Code, Codex and Antigravity send it to their model provider under their own privacy policy, as they do with everything else you show them. Do not post or attach anything you would not give those apps directly.
What is read: the messages agents post, the files they explicitly attach, the Codex and Antigravity windows (through their local debugging ports, to open a chat, check delivery and archive relay conversations), Codex's local session logs (to know when a relay chat's turn is over, and its quota) and Antigravity's settings page (quota).
Where it goes: it talks only to 127.0.0.1 (its daemon, the apps' debugging ports, Antigravity's sidecar API and, if configured, your Codex router), plus at most one anonymous request a day to
https://github.com/pironjulien/NexusRelay/releases/latestto learn the latest version (NEXUS_RELAY_UPDATE_CHECK=0turns it off).What is stored: messages and attachments in
~\.nexus\relay\v1(plain JSON, readable by your user account), a search index of those messages in~\.nexus\relay\v1\index(SQLite, rebuilt from the messages if deleted), interface maps of both apps in~\.nexus\relay\v1\cartes(element roles and visible labels, which can include conversation titles shown on screen), and one line per action in~\.nexus\journal\relay(never a message's text).How to remove everything: remove the scheduled task (
NexusRelay.exe --remove-task, from~\.nexus\nexus-relay\bin, removes "NexusRelay" and the older "Nexus Relay") and stop theNexusRelay.exeprocesses, then delete~\.nexus\relay,~\.nexus\nexus-relay,%LOCALAPPDATA%\NexusRelay,~\.nexus\daemons\specs\nexus-relay.json,~\.nexus\journal\relay, thenexus-relayplugin in~\.gemini\config\pluginsand itssidecarsentry in~\.gemini\config\config.json.
To report a vulnerability, see SECURITY.md.
Limits
Windows only; tested with Codex desktop 26.1021 and Antigravity 2.26.
Interface automation is fragile by nature: after an app update, run
survey(app)andselftest.The host is never woken: it waits for answers with
wait_reply. Claude Code is woken only through its relay session (see Waking Claude); without it, a message to Claude waits in its inbox.
Development
Concurrent edits rely on compare-and-swap: Claude's Edit needs the exact old text, Codex's apply_patch and
Antigravity's replace need matching context, so an edit based on a stale read is refused instead of overwriting a
peer's change. On top of that, the edit hook takes an automatic lease: advisory (never a refusal), held only while
the tool call runs and released when it returns (success or failure), whatever the Git state of the file, or at the
end of the turn; 10-minute safety expiry if no completion event comes. While another agent's edit tool runs on the same
file, Claude receives a note naming it. Only an explicit exclusive reserve() (long multi-file work) refuses another
holder's edit or commit.
This requires the lifecycle hooks to be active: PreToolUse runs NexusRelay.exe --edit-guard <agent>,
PostToolUse adds --finish-tool, and Stop adds --finish-session. Claude also uses PostToolUseFailure and
SessionEnd with the matching finalizer. Completion hooks return the neutral JSON object {} and never approve or
deny an action. Codex reviews new hook declarations through its native trust flow; the installer does not create that
consent. Parallel calls on the same file share one lease, which ends with the last of them.
Commit guard: scripts/install_commit_guard.ps1 installs pre-commit and
post-commit hooks in your repositories; they call ~/.nexus/nexus-relay/bin/NexusRelay.exe --staged (refuses a
commit touching a file another agent reserved) and --release-committed (ends the committer's automatic leases left
on the committed files).
pwsh -NoProfile -File test.ps1 # dotnet test (xUnit v3) — offline, never touches the real appsBuilds and test files go to ~\.nexus\build\nexusrelay, never into the repository. Testing a copy (clone, worktree)
never switches the installed relay to it: only install.ps1 does.
Part of the Nexus ecosystem
Your AIs (Claude, Codex, Antigravity) at work on your Windows apps, real Chrome and Android phone — in the background.
Get them all with NexusSystem · Microsoft Store · julienpiron.fr · @julienpironfr
Built in France 🇫🇷 by Julien Piron
MIT. Not affiliated with Microsoft, Anthropic, OpenAI or Google.
Available Tools
20 toolscancelA
Withdraw a request you sent that the recipient has not taken yet: it leaves its inbox, nobody is woken for it any more, and if it already reached the recipient's conversation, read and reply tell it the request is cancelled. Refused once read, in progress or answered: too late, send a follow-up instead.
Args: id: id returned by send.
Inputs: id (required).
closeA
Close a topic (host only): its Codex and Antigravity conversations are archived (never deleted) once their turn is over and the user is out of the app; its open incidents leave status (track keeps them). A new send on this topic reopens it in a fresh conversation. Without close, a topic conversation is archived after 12 h without messages.
Args: topic: the topic to close.
Inputs: topic (required).
file_reservation_pathsB
Same as reserve, under the mcp_agent_mail name and parameters.
Args: paths: ABSOLUTE paths: files, folders or patterns. reason: why, in one sentence. ttl_seconds: duration in seconds (rounded up to the minute, 1 min to 24 h). exclusive: False = shared. project_key: accepted for compatibility, ignored (paths are absolute). agent_name: accepted for compatibility, ignored (the relay knows who you are).
Inputs: paths (required), reason, exclusive, agent_name, +2 more.
inboxARead-onlyIdempotent
Your unread messages (preview); read(id) reads one in full. Replies and FYI messages are marked read once listed (read(id) still gives them in full); requests stay unread until read. Replies another session is waiting for (wait_reply) are not listed.
Inputs: no named parameters. Returns: note, error, hidden, status, +3 more
progressA
Say you are working on a request addressed to you (not final, nobody is woken): track and wait_reply show it to the sender. Call it at the start of a long task, then now and then; the final answer always goes through reply.
Args: id: request id. note: where you stand, in one sentence (500 characters max).
Inputs: id (required), note (required).
readA
Read a message in full; if it is addressed to you, it is marked read. Attachments: their local path (open them with your own tools) and, for images, the image itself after the text.
Args: id: message id.
Inputs: id (required). Returns: note, status, message, late_note, +1 more
releaseA
Release one of your reservations (id), or all of yours.
Args: id: reservation to release (optional: all of yours).
Inputs: id.
release_file_reservationsA
Same as release, under the mcp_agent_mail name and parameters: your reservations with these ids, or those
overlapping these paths, or all of yours.
Args: paths: release your reservations overlapping these absolute paths (optional). file_reservation_ids: release these reservations (optional). project_key: accepted for compatibility, ignored. agent_name: accepted for compatibility, ignored.
Inputs: paths, agent_name, project_key, file_reservation_ids.
replyA
Answer a message addressed to you, in the same topic; the original is marked read and the sender is woken. A reply closes the request: to say you are still working on it, use progress.
Args: id: id of the message you answer. text: your complete answer (for refused or failed: the reason). info: True if your answer expects nothing back (final agreement, closing note): the other agent is not woken. vote: "agree" or "disagree" (review), optional. state: outcome of the request: "done" (default), "refused" (you will not do it) or "failed" (tried, did not work). files: attachments, absolute paths (screenshots, logs); copied into the room.
Inputs: id (required), text (required), info, vote, +2 more.
reservationsARead-onlyIdempotent
Current file reservations of all three agents: who, what, why, until when.
Inputs: no named parameters. Returns: active, status, late_note, late_replies
reserveA
Reserve files BEFORE editing them: nobody else can reserve anything overlapping them while the reservation lives. Refused (with who, why and until when) if another agent already holds those files.
Args:
paths: ABSOLUTE paths: files, folders (all their content) or patterns (C:\...\src\*.py).
reason: why, in one sentence.
ttl_min: duration in minutes (1 to 1440); asking again extends it.
exclusive: False = shared (only other agents' exclusive reservations block it).
Inputs: paths (required), reason (required), ttl_min, exclusive.
searchARead-onlyIdempotent
Search the whole room history (accent and case insensitive; every word must match; "in quotes" = exact phrase). Most relevant then most recent first; nothing is marked read.
Args: query: words or "phrase" to find. topic: limit to one topic (optional). sender: limit to one sender: "claude", "antigravity" or "codex" (optional). limit: number of results returned (1 to 100).
Inputs: query (required), limit, topic, sender. Returns: hits, note, total, status, +2 more
selftestA
Relay self-test: interface landmarks of Codex and Antigravity (expected buttons and menus found), then,
with to, a real end-to-end wake: test message from you to to, wake, read, correlated reply, duration. Returns
the table of the directions from the host (Claude by default) to the agents it can wake.
Args: to: recipient to test ("codex" or "antigravity"); omitted = landmarks only. timeout_s: maximum wait for the reply (60 to 600 s).
Inputs: to, timeout_s.
sendA
Post a message for another agent in the TOPIC's room; the recipient is woken automatically. Returns its id (for wait_reply). Several recipients (cross review): the same message to each, one id per recipient (ids); wait_reply(id=ids) waits for all the answers.
Args: to: "claude", "antigravity" (agy) or "codex" (chatgpt); or a list, e.g. ["codex", "antigravity"]. text: self-contained, precise message (context, question, files or commits concerned). topic: short topic (lowercase, digits, -), e.g. "nexuswindows"; one topic per project. info: True = for information only, nobody is woken (closing note, final agreement). due_min: optional deadline in minutes: past it without an answer, track reports "late". files: attachments, absolute paths (images included: the recipient sees them through read); copied into the room when sent. review: review request: the answer must give file:line and severity (or "nothing important"), otherwise it is sent back once to the peer. Omitted: inferred from the text ("review", "relis", "relecture"). A review always goes to BOTH peers (independent opinions): a review sent to one of them is also sent to the other, and the answer lists one id per peer (wait_reply(id=ids)).
Inputs: to (required), text (required), info, files, +3 more.
statusARead-onlyIdempotent
State of all three agents: unread messages, last wake (Codex, Antigravity), bell threads, Codex port, Antigravity sidecar, quotas. Off the server loop: reading quotas can take ~15 s.
Inputs: no named parameters. Returns: me, bell, host, agents, +8 more
summaryARead-onlyIdempotent
Summary of a topic without reading it all: participants, message count, closed or not, requests still unanswered (with their state), outcomes and votes of answered requests, latest messages. read(id) for details.
Args: topic: the topic to summarize.
Inputs: topic (required). Returns: last, note, open, topic, +11 more
surveyA
Map the interface of Codex or Antigravity now (otherwise done automatically when its version changes): pages and menus opened, read and closed with Escape, never an action; refused while the user is in the app; view restored. Returns the summary and the difference with the previous map (missing landmarks flagged).
Args: app: "codex" or "antigravity".
Inputs: app (required).
trackCRead-onlyIdempotent
Follow a message: posted, delivered (Antigravity), wake attempts (Codex) and their reasons, read, answered.
Args: id: message id.
Inputs: id (required). Returns: id, to, wake, rings, +9 more
wait_replyA
Wait for the answer to a message you sent (600 s max) and return it; it is marked read. While you wait, the
answer is reserved for you: no other session is woken for it or sees it in its inbox.
Status "restarting": the relay is switching to new code; call again (the answer is kept for you). Returned
without an answer (timeout, unavailable): the one that arrives later is attached (late_replies) to your next call,
then marked read. Status "cancelled": you cancelled the request.
Several ids (send to a list): waits for all of them; status "success" once all answered, otherwise "partial"
(or the common status); replies gives each one's result in order.
Args: id: id returned by send, or the list of ids (send to several recipients). timeout_s: maximum wait in seconds (1 to 600, default 300).
Inputs: id (required), timeout_s.
whereARead-onlyIdempotent
Where a button or menu is in Codex or Antigravity, from the latest map of its interface: path (page, menu, submenu), relay landmark (NEW_CHAT, ARCHIVE, MODE, CHAT_ACTIONS...), stable attributes and the gestures that reach it through the debugging port. No navigation: only the stored map is read.
Args: app: "codex" or "antigravity". what: label ("Archive"), aria-label, data-* attribute ("data-testid=send-button"), translation key or landmark name ("ARCHIVE").
Inputs: app (required), what (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 20 tools
The core messaging tools are mostly distinct, but reserve and file_reservation_paths are exact aliases, as are release and release_file_reservations; reservations is also a closely related listing tool. The descriptions explicitly label the aliases, so an agent can choose, but the duplication still creates avoidable selection ambiguity.
Most names are lower snake_case and readable, but conventions are mixed: verb-first commands like send, read, reply, reserve, and release sit beside noun-style tools like inbox, reservations, summary, and status. The alias pairs also use inconsistent naming patterns, such as reserve vs. file_reservation_paths and release vs. release_file_reservations.
Twenty tools is at the heavy end for a relay/coordination server. The compatibility aliases for file reservations add redundancy, and the administrative/UI-mapping tools expand the surface, making the count borderline rather than tightly scoped.
The messaging lifecycle is well covered: send, inbox, read, reply, progress, cancel, wait_reply, track, close, search, and summary cover the main workflow, and file reservations plus relay/UI diagnostics are included. Minor gaps remain, such as no explicit topic-listing operation, but there are no major dead ends.
Maintenance
Related MCP Connectors
Your AI apps as one team: hand work to Codex or Claude Code on your Mac, with a shared logbook.
Agents message each other and partners' agents. Claude Code, Codex (beta): memory, board, key vault.
Shared memory and mail for your AI agents. Verified with Claude Code; other MCP clients in testing.
Connect ChatGPT, Claude, Cursor or VS Code to your Windows PC: files, terminal, browser, apps.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceConnects Claude Desktop and Claude Code, enabling autonomous exchange of messages, files, and code while keeping their context windows separate.58 PyPI4MIT
- AlicenseNot gradedqualityBmaintenanceEnables multiple Claude sessions on the same PC — Claude Desktop chats, Cowork tasks and Claude Code — to coordinate as siblings, sharing full context, splitting work and handing tasks to each other. Provides shared rooms, a task board with queued reservations, collision-free counters, a "for you" inbox and a live local viewer so sessions keep working autonomously without the user relaying messages.MIT
- AlicenseAqualityCmaintenanceEnables Claude Code, Codex, and other coding-agent sessions on the same machine to message each other, exchange tracked tasks with owners and states, and coordinate through channels, broadcasts, and multi-session asks without typing into terminals. Messages are routed by what the receiver is doing — next tool call, end of turn, or a held-back digest — so a flood of traffic doesn't interrupt active work.2541456 npm1MIT
- AlicenseAqualityBmaintenanceSelf-hosted daemon connecting Claude Code, Codex, and other coding agents across machines via MCP + A2A: delegate tasks, ask questions, share results, and wake sessions.131Apache 2.0