Agent connection map · route evidence reviewed October 22, 2026
See how my agents pass work to each other.
Explore the routes I’ve tested, the evidence behind them, and the gaps still to close.
A logo on this page means that platform is part of this setup. It does not mean every model can hand work to every other one.
- 5Fresh observed route
- 4Historical observation
- 5Documented; conditions untested
- 12Unsupported in this setup
- 95Unresolved; prerequisite named
A tiny test task proves the message got through, not the quality of a business deliverable. See every route, its runtime and its receipt.
Updated October 23, 2026. This top section is the current way my agents reach each other. October 22 route evidence is added further down, and the October 15 delegation map remains below it as a historical baseline.
How my agents talk to each other now
My agents no longer hand work to each other by having me paste messages between apps. Each agent has one lane where a message actually reaches him, and the record stays in our private GitHub repo. If I'm the one carrying a note from one agent to another, the system is broken.
How this team uses one shared record
These configured agents use different channels. Each task keeps its request, result and review in the shared repo. These are setup-specific routes, not capabilities guaranteed by a model logo.
- Grokevent-triggered mailbox / native desk relayxAI · configured desks · Webhook (Q mailbox) / native relay (Tanner)
- ClaudePR comment or PR review (configured per repo)Anthropic · also a GitHub worker · Reply observed in ~30 s (one test)
- CodexPR comment or PR review (configured per repo)OpenAI · PR review configured; mention wake unverified
- Meta AIDashed orange: scheduled pickup of a note fileMeta · alias Muse · Scheduled pickup
- Setup ownerDashed purple: batched escalation to the setup ownerThe human who owns this setup · Reached only via relay, batched
- GitHubShared repoWhere every channel lands and every receipt is written
- PR comment or PR review (configured per repo)
- event-triggered mailbox / native desk relay
- Dashed orange: scheduled pickup of a note file
- Dashed purple: batched escalation to the setup owner
The 11 platforms in the connection matrix
- ChatGPT
- Claude
- Grok
- Qwen (local)
- Kimi
- Perplexity
- Gemini
- Cursor
- Meta AI
- Hermes (Nous)
- OpenAI Codex
Logos are trademarks of their owners, shown only to identify each platform. Icons: Simple Icons (CC0) for OpenAI, Claude, Kimi, Gemini, Perplexity, Cursor, Meta and GitHub; LobeHub Icons (MIT, © 2023 LobeHub) for Grok, Qwen and Nous Research.
| To reach | Use this lane | Wakes him instantly? |
|---|---|---|
| Q, my Grok Bot quartermaster | A comment on our mailbox pull request ("Agent mailbox, do not merge") | Yes. A trigger wakes him the moment the comment lands. Nobody ever merges that PR. |
| Tanner and the other Grok Bot desks | Tanner's SendToAgent relay, or a comment on the thread they're watching | Yes. |
| Codex | Comments on the pull request he's working on | Not yet. He reviews when a PR is opened or marked ready, but an @codex mention doesn't reach him in this repo until a Codex environment is set up. |
| Claude | An @Claude comment on the pull request | Yes, for messages. An October 22 test received a reply in the same thread in about 30 seconds. Exact-file reading initially failed because the requested revision was absent from the worker checkout; delivery on the checked-out branch passed. |
| Muse, whom I call Happy | An agent-notes/ note with "For Happy" in the title, naming the ask, the owner and the deadline | Not yet. A GitHub comment can't wake him, so he picks notes up on his own schedule. |
| Me | Only through Tanner, and only for things that need me | I get them batched as yes/no, usually as a PDF. |
I'm stating the broken lanes plainly because the point of this page is to be accurate. We have observed handoffs through Q’s mailbox trigger, the named Grok desk relay and Claude’s GitHub worker. Those runs do not establish a ten-minute turnaround for every task. Codex’s mention wake and Muse’s scheduled pickup still have gaps, and every miss gets logged. The fix under review is a small script that checks the threads every few minutes and wakes a model only when something new is addressed to him.
Fleet Comms is retired. Older dated notes in the repo may still mention it, or WhatsApp paste, or old owners. Those are records of what happened then. When those older dated Fleet Comms notes disagree with this page, this page wins. That applies only to those older notes: docs/AGENT-HARNESS.md in the agent-runtime repo stays canonical for ownership and authority, and this page is a projection of it.
Polling is cheap. If an agent has to check for new work, a small script looks for new comments or notes and wakes the AI only when something has arrived. A timer that wakes a model every 10 minutes to find nothing burns tokens for nothing.
Every handoff needs a verified round trip, closed within 10 minutes
A file alone tells no one, and sending a message isn't a handoff. The receiver acknowledges in writing on the same lane, for example "ACK review-panel v1." Loops close within 10 minutes, not hours. That's an operating requirement we hold ourselves to, not a measured result for every route. The dated route evidence below shows which loops we've actually closed. If no acknowledgment arrives in 10 minutes, the sender escalates once through Tanner and logs the gap. That's what lets the system improve itself without me in the middle, and the receipts are how other agent teams can learn from it.
The review panel: one answer on big decisions
For important items only (core frameworks, important decisions and standing rules), my agents confer before anything reaches me. They decide what counts as important, and when in doubt, it's important. I wrote up the full process in My AI Agents Agree Before They Ask Me: The Review Panel.
- Codex is the main arbiter and has the final say.
- Grok Bot (Trenton) has medium authority. He convenes the thread and writes the summary.
- Muse (Happy) carries out the work once it's decided.
- Claude and Q give input.
- Tanner carries the one combined answer to me.
- One thread per decision, usually a pull request comment thread.
- The convener posts the question and reaches each panelist on his own lane: the mailbox PR for Q, a For Happy note for Muse, and a PR comment for Codex.
- Each receiver acknowledges in writing within 10 minutes, then gives a position within 24 hours.
- Silence counts as no objection among agents only. It never counts as approval, and it can only move a question to me, never decide it. An agent who is paused or unavailable is listed as "no reply."
- One combined yes/no to me, sent through Tanner, batched with my other open asks, with a short PDF when there's more than a paragraph. It lists Codex's ruling, who agreed, who disagreed and why, and who didn't reply. My answer is recorded in the same thread.
Hard limits. Agreement, silence or even Codex's ruling never approve sending or posting to a third party, publishing, payments or purchases, deletes, permission or access changes, production or host changes, merges, or anything strategic. Each of those still needs my explicit yes.
Handing off work, step by step
- Learn: read the current status board. If the task is already in progress, don't start a second copy.
- Claim it on the board, with one owner.
- Send it on the right lane from the table above.
- Get a written acknowledgment within 10 minutes. No acknowledgment means no handoff.
- Do it and keep receipts. Check results on the live page, not from memory.
- Teach it: file a learning note or fix the skill, and update this page if the process changed.
That's Learn, Do, Teach applied to every job. Every comment is signed with the real agent's name and ID, because a shared account name doesn't prove who acted. Every agent is "he." Humans keep their own pronouns.
Who does what (as of October 21, 2026)
- Me: I decide, and I handle all money myself.
- Tanner (Grok Bot EA): my door. He relays urgent items between desks.
- Muse / Happy: my daily coordinator. He owns Gmail and Meta (Facebook, Instagram, WhatsApp, Threads), bulk work, and monitoring, including the usage board and the 24-hour pre-reset check.
- Q (Grok Bot quartermaster): the ops desk. He reviews pull requests at the exact commit, keeps receipts and reads the mailbox PR.
- Austin: the only one who runs anything on the host. Production stays on hold until I give an exact yes.
- Trenton (Grok Bot): LinkedIn, X and public pages like this one.
- Codex: repo builder, reviewer and the review panel's arbiter.
- Cursor: cloud repo work.
People set the goal; AI tools do the approved work. Use the grid to see who can pass a task to whom in my setup. It builds on how our agents run the company, our guide to who owns each job and checks the work.
Human owners & decisions
Dennis YuGoals and consequential permissions
Dylan HaugenContent Factory knowledge
Agents work within this approved scope.
Every route gets a reason.
I want one lead agent to deliver the result and check what comes back. This matrix records the actual routes we have observed and spells out what remains unproved. Select a cell for its exact setup, evidence and next test.
All 121 cells are annotated; 95 remain unresolved. Annotation is not verification. Five matrix cells have fresh transport evidence. Four of those five also completed a checked task correction. Supplemental artifact and GitHub transport tests are recorded separately below. A tiny task proves transport, not the quality of a business deliverable.
Scope change: Fresh tests use ChatGPT Work, Claude Desktop, Kimi Work, Muse and named Grok desks on this Mac. Historical Travel Dot, Buzz, browser and shared-record claims keep their original scope. Codex still means the configured Buzz checker. Every cell below names its runtime.
Columns send; rows receive. T = fresh transport · H = historical · D = documented · X = unsupported in this setup · U = unresolved.
| Receiver ↓ / Sender → | ChatGPT | Claude | Grok | Qwen (local) | Kimi | Perplexity | Gemini | Cursor | Meta AIMuse / Happy | Hermes (Nous) | OpenAI Codex |
|---|---|---|---|---|---|---|---|---|---|---|---|
| ChatGPT | U | U | U | X | U | U | U | U | H | U | U |
| Claude | T | D | U | X | U | U | U | U | U | U | D |
| Grok | T | U | T | X | U | U | U | U | U | U | U |
| Qwen (local) | U | U | H | X | U | U | U | H | X | D | U |
| Kimi | T | U | U | X | U | U | U | U | U | U | U |
| Perplexity | U | U | U | X | U | U | U | U | U | U | U |
| Gemini | H | U | U | X | U | U | U | U | U | U | U |
| Cursor | U | U | U | X | U | U | U | U | U | U | U |
| Meta AIMuse / Happy | T | U | D | X | U | U | U | U | U | U | U |
| Hermes (Nous) | U | U | U | X | U | U | U | U | U | U | U |
| OpenAI Codex | U | D | U | X | U | U | U | U | U | U | U |
What the fresh tests returned
The bounded task used input [23, 5, 17]. The correction replaced 17 with 19. The checker expected [5, 17, 23] / 45, followed by [5, 19, 23] / 47. No client information, publication, spending or access changes were part of these tests.
ChatGPT Work → Muse / Happy native Mac app
Both outputs read directly in the receiving app; correction explicitly superseded the first result.
Acceptance: PASS for this tiny deterministic task only
Limit: No proof of autonomous wake-up, shared-record pickup, reverse initiation, file transfer, or audit quality. Native UI works in this observed run; the October 13 failed UI attempt remains historical.
ChatGPT Work → Tanner in Grok Bot → Trenton → Tanner → ChatGPT Work
Tanner UI displayed native send and receiver-message events for both rounds; Trenton returned both correct results and explicit supersession. His signed repository comment was independently fetched.
Acceptance: PASS for this tiny deterministic task only
Limit: This proves the combined UI route and the named-desk Tanner → Trenton native route. It does not prove every Grok desk, a new Trenton-initiated assignment, Buzz, or unattended UI operation.
ChatGPT Work → Kimi Work native Mac app
Both outputs read directly in Kimi Work; final result explicitly superseded the first.
Acceptance: PASS for this tiny deterministic task only
Limit: No Kimi Code CLI, reverse initiation, file transfer, or unattended operation established.
ChatGPT Work → Claude Desktop native app chat
The original matching response was read directly. The correction was visibly submitted in the same chat. The app then switched to concurrent user work; the final correction response was not recovered.
Acceptance: Initial output PASS; correction NOT VERIFIED
Limit: Transport observed, full correction loop not accepted. Desktop chat is not the configured Buzz seat or GitHub Actions worker.
Local Qwen → any independent agent
Read bin/qwen, run_agent.py, lib/llm.py and lib/tools.py. The inspected CLI sends a completion request, receives text, logs usage and saves local output; it exposes no outbound agent-dispatch step. Public operating guide also restricts this worker to drafts.
Acceptance: Not applicable
Limit: Scoped to this inspected local MLX wrapper, not all Qwen models or Qwen Code. Adding an authorized tool runner would be a different configuration.
This ChatGPT Work shell → local Qwen endpoint
GET 127.0.0.1:8080/v1/models returned connection failure from this execution context. A later lsof inspection showed a Python process listening on the same address.
Acceptance: No completion obtained
Limit: Reachability unresolved. Do not infer the server is stopped, restart it, kill a worker, or label the endpoint globally offline from these observations.
Repository comment → Claude GitHub Actions worker → same PR
Observed two-way transport: retest comment at 04:59:24Z was followed by claude[bot] at 04:59:53Z, updated 05:00:27Z, returning the requested acknowledgment in the same PR. Both comments were independently read. Earlier attempts failed.
Acceptance: Transport PASS; no substantive task or correction loop tested in that exchange
Limit: Evidence recovered from the existing team test, not commissioned by this run. Not a Buzz or Desktop test. The GitHub account alone does not authenticate which agent initiated the earlier comment; no unrelated product-pair cell is promoted.
ChatGPT Work saved repository artifact → Trenton own-account read acknowledgment
Producer readback of README, ledger and fragment matched immutable revision acdb1b8b2b30da9d0469e3597894d55f1d4282be. Trenton independently acknowledged reading that README revision and matching blob e0e536b, then returned evidence-framing feedback.
Acceptance: README read and evidence framing ACCEPTED; full ledger and visual review pending
Limit: Receiver did not yet accept matrix.json or page-fragment.html. This supplements the Grok route; it is not a completed publication or a proof of autonomous pickup.
ChatGPT Work → repository mention → Claude GitHub Actions worker → same PR
First run returned a real denial: the pinned commit was absent from the shallow PR checkout and fetch/show required approval. The producer placed identical artifact bytes on the existing PR branch. The corrective run read HEAD 54793d77500225d490898e0b76616b755bcc6591 and confirmed blob cb4b27803f4e587045c1d8c02a92befeffba8605. Its independently counted 121 cells (T5/H4/D5/X12/U95) and extracted Claude Desktop limitation matched the producer ledger. Both bot receipts were retrieved.
Acceptance: PASS after delivery repair for exact-file read and bounded analysis; first failure retained
Limit: Supplemental GitHub runtime, separate from Desktop and Buzz. This repairs delivery location, not content quality for a production deliverable. Off-branch access remains unverified/blocked in that tested setup; no workflow permissions were changed.
Repository comment → Codex GitHub integration
Existing latest checked retest at 05:01:25Z received a bot reply at 05:01:37Z asking to create an environment for this repository.
Acceptance: BLOCKED before task execution
Limit: Account/environment binding unresolved; Austin already owns the investigation. Not proof Codex cannot delegate or that the configured Buzz checker fails.
Muse → Muse internal subagent
Muse reported spawn and completion returning [5,19,23], sum 47. The underlying child invocation/result was not independently inspected, and the expected answer was included in the child brief.
Acceptance: REPORTED ONLY
Limit: Insufficient to promote the diagonal to a verified independent-worker route.
Test loop and stopping rules
- Name the sender, receiver, transport and acceptance test.
- Send one uniquely tagged task. Read the receiver’s actual answer.
- Send one correction in the same task. Open the final changed output.
- Record transport, task acceptance and autonomous wake-up separately.
- Repair a specific failure within existing authority, then retest that failure. Do not repeat unchanged failing requests.
- If the runtime lacks dispatch, mark the exact unsupported setup. If access or identity is missing, keep it unresolved and name the prerequisite.
Use an existing event or pickup mechanism for continued work. This page installs no scheduler and grants no permissions. Return traffic never proves the reverse assignment direction. A composite route needs a receipt for every hop.
121 route records
Showing all 121 routes.
ChatGPT → ChatGPT · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Claude → ChatGPT · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Grok Bot → ChatGPT · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Local Qwen → ChatGPT · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → ChatGPT · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Perplexity → ChatGPT · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Gemini → ChatGPT · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Cursor → ChatGPT · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Muse / Happy → ChatGPT · H: Historical observation
Sender: Happy / Muse historical shared-record task, October 13
Receiver: Travel Dot historical shared-record task, October 13
The October 13 record describes Happy initiating a correction/channel-confirmation request and receiving a matching acknowledgment.
Method: S · Date: 2026-10-13
Output acceptance: Historical request/return only
Next test: Recover original shared-record receipts and recheck the active pickup mechanism.
Hermes → ChatGPT · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
Codex → ChatGPT · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
No receiver address and wake trigger verified for a fresh assignment into this exact ChatGPT session.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind an existing authorized task inbox and show receiver pickup; a return message is insufficient.
ChatGPT → Claude · T: Fresh observed route
Sender: ChatGPT Work current session on this Mac
Receiver: Claude Desktop chat; not a Buzz seat
The original matching response was read directly. The correction was visibly submitted in the same chat. The app then switched to concurrent user work; the final correction response was not recovered. A separate GitHub Actions variant passed exact-file delivery after a branch-location repair; see its supplemental receipt. This does not repair the Desktop correction gap.
Method: UI · Date: 2026-10-22
Output acceptance: Initial output PASS; correction NOT VERIFIED
Next test: Run a representative file-producing task and inspect its final corrected artifact before claiming production readiness.
Claude → Claude · D: Documented; conditions untested
Sender: Configured Claude Buzz seat
Receiver: Configured Claude Buzz seat
Configured Buzz seats are documented; a fresh directed handoff and accepted correction between these exact seats was not recovered.
Method: R · Date: 2026-10-15
Output acceptance: NOT TESTED
Next test: Resolve both seat identities and a live relay before issuing one tagged task.
Grok Bot → Claude · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Local Qwen → Claude · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Claude · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Perplexity → Claude · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Gemini → Claude · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Cursor → Claude · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Muse / Happy → Claude · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Hermes → Claude · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
The configured Claude Buzz receiver and its active relay have not been inspected in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve the intended Buzz identity and live relay, then send a tagged task and correction. Desktop/GitHub evidence is a separate route.
Codex → Claude · D: Documented; conditions untested
Sender: Configured Codex Buzz seat
Receiver: Configured Claude Buzz seat
Configured Buzz seats are documented; a fresh directed handoff and accepted correction between these exact seats was not recovered.
Method: R · Date: 2026-10-15
Output acceptance: NOT TESTED
Next test: Resolve both seat identities and a live relay before issuing one tagged task.
ChatGPT → Grok Bot · T: Fresh observed route
Sender: ChatGPT Work current session on this Mac
Receiver: Tanner in Grok Bot; task delegated to Trenton
Tanner UI displayed native send and receiver-message events for both rounds; Trenton returned both correct results and explicit supersession. His signed repository comment was independently fetched.
Method: UI + N · Date: 2026-10-22
Output acceptance: PASS for this tiny deterministic task only
Next test: Run a representative file-producing task and inspect its final corrected artifact before claiming production readiness.
Claude → Grok Bot · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Grok Bot → Grok Bot · T: Fresh observed route
Sender: Tanner named desk in Grok Bot
Receiver: Trenton named desk in Grok Bot
Tanner assigned Trenton a tagged task and a separate correction; both correct responses returned through native named-desk messaging. Trenton’s signed repository receipt was independently read.
Method: N · Date: 2026-10-22
Output acceptance: PASS for deterministic task and correction
Next test: Test a representative deliverable next; do not extrapolate to every named desk.
Local Qwen → Grok Bot · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Named Tanner and Trenton desks in Grok Bot
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Grok Bot · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Perplexity → Grok Bot · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Gemini → Grok Bot · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Cursor → Grok Bot · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Muse / Happy → Grok Bot · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Hermes → Grok Bot · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
Codex → Grok Bot · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Named Tanner and Trenton desks in Grok Bot
No actual named-desk transport from this sender to the receiving Grok desk was exercised.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Choose Tanner or Trenton and an already authorized UI/native/shared-record transport; verify pickup and corrected return.
ChatGPT → Local Qwen · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
Claude → Local Qwen · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
Grok Bot → Local Qwen · H: Historical observation
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Local MLX text worker; not Qwen Code
Historical Tanner → Trenton → local Qwen chain returned a staged draft; exact first-hop transport and final acceptance were not established.
Method: L · Date: 2026-09-27
Output acceptance: Staged draft; final acceptance UNKNOWN
Next test: Retest from the named Grok desk with authorized Local execution, preserving queue locks.
Local Qwen → Local Qwen · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Local MLX text worker; not Qwen Code
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Local Qwen · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
Perplexity → Local Qwen · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
Gemini → Local Qwen · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
Cursor → Local Qwen · H: Historical observation
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Local MLX text worker; not Qwen Code
Historical Cursor-led job received and corrected a local-Qwen first pass.
Method: L · Date: 2026-08-26
Output acceptance: Historical conductor review
Next test: Run a fresh tagged completion from the actual Cursor IDE; record output acceptance separately.
Muse / Happy → Local Qwen · X: Unsupported in this setup
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Local MLX text worker; not Qwen Code
The documented Muse setup has no direct Mac shell for this local worker. A request through another conductor is an indirect route.
Method: Direct local execution · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Use an already authorized Mac conductor and test the composite route as separate hops.
Hermes → Local Qwen · D: Documented; conditions untested
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Local MLX text worker; not Qwen Code
The installed CLI bridge and public local-worker setup are documented. Installation does not establish a working gateway.
Method: L · Date: 2026-10-22
Output acceptance: No completion obtained
Next test: Test the existing bridge without changing credentials, paid provider settings, or active queues.
Codex → Local Qwen · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Local MLX text worker; not Qwen Code
The sender needs authorized access to the Mac worker; no completion from this sender was observed.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Check the exact conductor, loopback reachability and existing queue lock; run one small completion without restarting active work.
ChatGPT → Kimi Work · T: Fresh observed route
Sender: ChatGPT Work current session on this Mac
Receiver: Signed-in Kimi Work Mac app, isolated test chat
Both outputs read directly in Kimi Work; final result explicitly superseded the first.
Method: UI · Date: 2026-10-22
Output acceptance: PASS for this tiny deterministic task only
Next test: Run a representative file-producing task and inspect its final corrected artifact before claiming production readiness.
Claude → Kimi Work · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Grok Bot → Kimi Work · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Local Qwen → Kimi Work · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Kimi Work · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Perplexity → Kimi Work · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Gemini → Kimi Work · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Cursor → Kimi Work · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Muse / Happy → Kimi Work · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Hermes → Kimi Work · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
Codex → Kimi Work · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Signed-in Kimi Work Mac app; not Kimi Code CLI
No task was initiated by this sender into the signed-in Kimi Work task surface.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use this sender’s authorized Kimi Work route and collect a tagged corrected result; a Kimi Code CLI test cannot substitute.
ChatGPT → Perplexity · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Claude → Perplexity · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Grok Bot → Perplexity · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Local Qwen → Perplexity · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Max web research account; not the separately inspected Computer desktop app
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Perplexity · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Perplexity → Perplexity · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Max web research account; not the separately inspected Computer desktop app
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Gemini → Perplexity · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Cursor → Perplexity · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Muse / Happy → Perplexity · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Hermes → Perplexity · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
Codex → Perplexity · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Max web research account; not the separately inspected Computer desktop app
No handoff into the exact Perplexity Max web research account was exercised. The visible desktop app was Computer.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind the web account and task route; test Computer separately if that is the intended worker.
ChatGPT → Gemini · H: Historical observation
Sender: Travel Dot historical task, October 14
Receiver: Signed-in Gemini web app; not Gemini CLI
Travel Dot recovered original Gemini exports on October 14. Original audit failed review; revised Gemini exports were not accepted.
Method: B · Date: 2026-10-14
Output acceptance: Original audit FAIL; corrected exports NOT VERIFIED
Next test: Recover the exact revised files from the original task and inspect them; do not relabel a separate local repair as Gemini output.
Claude → Gemini · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Grok Bot → Gemini · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Local Qwen → Gemini · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Signed-in Gemini web app; not Gemini CLI
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Gemini · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Perplexity → Gemini · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Gemini → Gemini · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Signed-in Gemini web app; not Gemini CLI
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Cursor → Gemini · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Muse / Happy → Gemini · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Hermes → Gemini · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
Codex → Gemini · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Signed-in Gemini web app; not Gemini CLI
No sender-specific authorized Gemini browser handoff was exercised in this run.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use the signed-in Gemini web task surface from the actual sender and recover a tagged corrected output.
ChatGPT → Cursor · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Claude → Cursor · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Grok Bot → Cursor · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Local Qwen → Cursor · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Mac IDE agent; not Cursor Cloud Agent
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Cursor · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Perplexity → Cursor · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Gemini → Cursor · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Cursor → Cursor · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Mac IDE agent; not Cursor Cloud Agent
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Muse / Happy → Cursor · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Hermes → Cursor · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
Codex → Cursor · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Mac IDE agent; not Cursor Cloud Agent
No tagged assignment was delivered into the exact Mac Cursor IDE agent.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Bind a task input in the IDE and collect its result. Cursor Cloud launch documentation is a different surface.
ChatGPT → Muse / Happy · T: Fresh observed route
Sender: ChatGPT Work current session on this Mac
Receiver: Muse / Happy native Mac app, isolated test chat
Both outputs read directly in the receiving app; correction explicitly superseded the first result.
Method: UI · Date: 2026-10-22
Output acceptance: PASS for this tiny deterministic task only
Next test: Run a representative file-producing task and inspect its final corrected artifact before claiming production readiness.
Claude → Muse / Happy · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Grok Bot → Muse / Happy · D: Documented; conditions untested
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Happy in Muse; shared-record and native-app routes are separate
The shared-record route is documented and newer public notes report acknowledged podcast handoffs; the underlying exact receipt pair was not inspected in this run.
Method: S · Date: 2026-10-22
Output acceptance: Not independently accepted here
Next test: Recover the current task, exact artifact and Happy acknowledgment; verify actual pickup, not just a commit ID.
Local Qwen → Muse / Happy · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Happy in Muse; shared-record and native-app routes are separate
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Muse / Happy · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Perplexity → Muse / Happy · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Gemini → Muse / Happy · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Cursor → Muse / Happy · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Muse / Happy → Muse / Happy · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Happy in Muse; shared-record and native-app routes are separate
Muse reported a child invocation and result, but the child receipt was not independently inspected and its expected answer was supplied. No promotion from self-report.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Hermes → Muse / Happy · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
Codex → Muse / Happy · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Happy in Muse; shared-record and native-app routes are separate
A shared-record write by this sender does not establish Happy picked up the task.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Use a For Happy task on the existing record; verify Happy’s written acknowledgment of its exact revision and corrected return.
ChatGPT → Hermes · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Claude → Hermes · U: Unresolved; prerequisite named
Sender: Claude Desktop chat (fresh UI test); configured Buzz seats (relay records)
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Grok Bot → Hermes · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Local Qwen → Hermes · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Hermes · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Perplexity → Hermes · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Gemini → Hermes · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Cursor → Hermes · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Muse / Happy → Hermes · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
Hermes → Hermes · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Installed Mac CLI bridge; no live gateway test in this run
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Codex → Hermes · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Installed Mac CLI bridge; no live gateway test in this run
The CLI launcher exists but this sender has not invoked an authenticated working bridge.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Inspect the current non-secret CLI configuration and perform a bounded call through the existing approved bridge.
ChatGPT → Codex · U: Unresolved; prerequisite named
Sender: ChatGPT Work on the connected Mac (fresh tests); Travel Dot (historical tests)
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Claude → Codex · D: Documented; conditions untested
Sender: Configured Claude Buzz seat
Receiver: Configured Codex Buzz seat
Configured Buzz seats are documented; a fresh directed handoff and accepted correction between these exact seats was not recovered.
Method: R · Date: 2026-10-15
Output acceptance: NOT TESTED
Next test: Resolve both seat identities and a live relay before issuing one tagged task.
Grok Bot → Codex · U: Unresolved; prerequisite named
Sender: Named Tanner and Trenton desks in Grok Bot
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Local Qwen → Codex · X: Unsupported in this setup
Sender: Local MLX text worker; not Qwen Code
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
The inspected local MLX worker returns text and saves drafts; it has no outbound agent-dispatch step. This restriction is to the installed worker, not Qwen Code.
Method: Direct dispatch · Date: 2026-10-22
Output acceptance: Not applicable
Next test: Have an authorized conductor initiate the handoff, or separately configure and test a tool-enabled runtime.
Kimi Work → Codex · U: Unresolved; prerequisite named
Sender: Signed-in Kimi Work Mac app; not Kimi Code CLI
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Perplexity → Codex · U: Unresolved; prerequisite named
Sender: Max web research account; not the separately inspected Computer desktop app
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Gemini → Codex · U: Unresolved; prerequisite named
Sender: Signed-in Gemini web app; not Gemini CLI
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified. The sending app’s outbound tool/trigger capability for this destination also remains unverified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Cursor → Codex · U: Unresolved; prerequisite named
Sender: Mac IDE agent; not Cursor Cloud Agent
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Muse / Happy → Codex · U: Unresolved; prerequisite named
Sender: Happy in Muse; shared-record and native-app routes are separate
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Hermes → Codex · U: Unresolved; prerequisite named
Sender: Installed Mac CLI bridge; no live gateway test in this run
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
No exact configured Codex Buzz checker and live relay were verified.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Resolve that checker seat and relay; the separately blocked GitHub environment is not this Buzz route.
Codex → Codex · U: Unresolved; prerequisite named
Sender: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
Receiver: Configured Buzz checker seat; not this ChatGPT Work session or the GitHub bot
A product replying within the same conversation does not prove delegation to another independently addressed worker.
Method: Unestablished · Date: No observed run
Output acceptance: NOT TESTED
Next test: Identify distinct sender and receiver workers in this product and inspect the actual invocation, return and correction.
Earlier baseline (October 15, 2026): the original delegation map
Who can send work to whom?
Columns send. Rows receive. Checked receiving routes appear first.
ChatGPTOpenAI mark
ClaudeAnthropic mark
Grok BotxAI docs mark
Qwen
Kimi
Perplexity
Gemini
Cursor
Muse / Happy
HermesGreen dots show observed routes, with the method code. Amber marks a documented route that still needs its conditions checked. A red × applies only to the named unsupported route. Gray ? means we have not established that pair. Read the method codes or use the text version.
Icon key: seven labels use their official product icons. ChatGPT and Codex use OpenAI’s provider mark; Claude uses Anthropic’s provider mark; Grok Bot uses the provider icon from its official documentation. The product names beside them identify the actual tools. These editorial references do not imply endorsement. Gemini and its icon are trademarks of Google LLC.
More routes are documented: Grok Bot → Cursor Cloud Agent; Claude Code, Claude Desktop, Codex or Cursor → Perplexity Computer. These need their own configured connection and test. See the documented extensions.
Yes, agents can delegate. The route decides which ones.
Travel Dot, my ChatGPT-based strategy and receiving-review agent, reached Gemini through my Mac browser. Named Grok Bot desks passed work to each other and reached local Qwen through a local worker. A shared task record let Travel Dot hand work to Muse, my Meta-based daily coordinator whom I call Happy, and get a written response. Those are different connections with different limits.
I want to give one lead agent the goal and let it manage the approved steps. To make that useful, I need to know the actual sending app, receiving worker, permission, and return path. A model name alone leaves most of that unanswered.
The table covers ChatGPT, Claude, Grok Bot, Qwen, Kimi, Perplexity, Gemini and Cursor, plus Muse, Hermes and Codex from my working setup. It is a dated connection map, not a ranking. The gray cells matter: being on my roster does not prove that a worker can receive an assignment from every other worker.
What the letters mean
- B · Browser
- An authorized agent operates the receiving app through a reachable, signed-in browser and brings back the output.
- N · Native message
- One named worker uses the platform’s supported message route to assign another named worker.
- S · Shared task record
- A worker writes a bounded assignment where the receiver is authorized to read it. The receiver must pick it up and acknowledge it.
- L · Local worker
- A conductor with approved access calls a worker running on the selected computer, then collects its result.
- R · Configured relay
- Known worker identities exchange handoffs through an installed relay. Our example is Buzz.
- M · MCP tool
- Model Context Protocol is a way for an app to call connected tools. Some tools launch another agent; others only search or retrieve data. The extensions below make that distinction.
- I · Product integration
- A supported connection launches work in another product, such as Grok Bot starting a Cursor Cloud Agent.
- E · External executor
- A coding app starts a separately installed and authenticated agent process.
- A2A · Remote agent protocol
- A compatible client sends tasks to a configured remote agent endpoint using its published agent card.
T records an observed route. It does not certify the worker’s final output. D records documentation plus conditions. It does not claim a fresh successful run. The Grok Bot → Qwen cell includes a handoff to another Grok desk before local execution; the exact transport of that first hop was not established.
Direction also matters. When Gemini returns a file to Travel Dot, that completes the return leg of Travel Dot’s assignment. It does not establish that Gemini can start a new task for Travel Dot. Likewise, most diagonal cells stay unknown: one product label may contain many accounts or workers.
Runtime labels in the October 15 baseline
These historical labels apply to the earlier baseline. The current grid identifies the sender and receiver runtime in each route record; Work, Desktop, GitHub Actions and Buzz evidence remain distinct.
A product name tells you the platform. A personal name tells you which worker I assigned. Trenton is the content editor agent within Grok Bot. Tanner is the executive-assistant agent within Grok Bot. They are separate desks on that product, with different jobs. Travel Dot is the named ChatGPT-based lead agent in this case. Muse, also called Happy, is the Meta-based daily coordinator.
An AI agent is a worker with a task, context and tools. The model supplies part of the reasoning. The surrounding app supplies the actions it can take. Our guide to changing models explains why switching the model does not automatically move account access or authority.
In the October 15 baseline, ChatGPT meant Travel Dot in my tool-enabled setup. The browser and shared-record routes shown here were available to that named instance. This is not a feature promise for every ChatGPT account, plan, or app.
Qwen is the local worker called “Quinn” in some earlier tasks. Those records tie the name to the local Qwen worker. This map uses that verified identity. A different agent called Quinn would need its own app, endpoint, and test.
Open the full runtime label key
- ChatGPT · Travel Dot · tool-enabled setup
- Travel Dot is my ChatGPT-based strategy and receiving-review agent. This named instance has the authorized computer and shared-record routes used in this case. These tools are specific to this setup; a standard ChatGPT account should not be assumed to have them.
- Claude · Configured Buzz seats
- Claude workers connected to our existing Buzz relay. This label does not mean every Claude web, Desktop or Code session.
- Grok Bot · Named desks · Local execution
- The named Grok Bot desks in my setup include Tanner, the executive-assistant agent, and Trenton, the content editor agent. Local work also requires the selected Mac and its Local execution connection.
- Qwen · Earlier “Quinn” · local MLX
- The local Qwen worker on my Mac. Earlier task records used Quinn for this worker and later corrected the spelling to Qwen. That historical alias does not identify every possible later worker called Quinn.
- Kimi · Kimi Work · WebBridge jobs
- Historical evidence identifies a Kimi Work local conversation and a scheduled Kimi worker using WebBridge and the shared task record. It does not establish a Kimi Code CLI setup or a named-agent handoff and return.
- Perplexity · Max web account
- A Perplexity Max web account is established in historical checks. A checked delegation endpoint for that account is not established here. The separately documented Computer MCP integration appears below.
- Gemini · Web app · signed-in Mac browser
- The Gemini web conversation reached through my authorized Mac browser. It is the receiving surface used in the audit case.
- Cursor · IDE agent · Mac
- The Cursor agent running in the editor on my Mac. Cursor Cloud Agents are a separate surface, covered below rather than silently merged into this row.
- Muse / Happy · Meta coordinator · shared record
- Muse, which I call Happy, is my Meta-based daily-coordination agent. He is reached through the agreed shared task record. The documented setup has no direct Mac shell for running local Qwen.
- Hermes · CLI bridge · Mac
- The command-line bridge installed on the Mac for calling local Qwen. Its installation and current gateway availability are separate checks.
- Codex · Configured Buzz checker seat
- The Codex worker in our configured Buzz relay. This label does not stand for every Codex cloud, desktop or CLI installation.
October 15 baseline in plain text
This is the plain-text record of the October 15 baseline, preserved for comparison. The current evidence grid above contains later observations and names each tested runtime. Do not use this older list to infer that an updated route remains untested.
- ChatGPT → Gemini: T-B. Travel Dot, my ChatGPT-based lead agent, commissioned work through the authorized Mac browser and recovered the original exports. The original audit failed review; a correction was sent. Revised Gemini exports were not verified as accepted. October 14, 2026.
- ChatGPT → Muse / Happy: T-S. A shared-record task packet received a matching written acknowledgment and factual corrections. This proves that handoff and return, not completion of every assigned task. October 13, 2026.
- Muse / Happy → ChatGPT: T-S. Happy, my Muse coordinator on Meta, sent a bounded correction and channel-confirmation request. Travel Dot, my ChatGPT-based lead agent, answered on the shared record, and Happy returned a matching acknowledgment. This establishes an initiating request in this direction, not only a reply. October 13, 2026.
- Grok Bot → Grok Bot: D-N. Named-desk native messaging is documented. Tanner, the executive-assistant agent in Grok Bot, and Trenton, the content editor agent in Grok Bot, collaborated in a historical run, but the exact native send-and-return receipt was not recovered. This diagonal means separate configured desks. Documentation checked October 15, 2026.
- Grok Bot → Qwen: T-L. The historical chain was Tanner, the executive-assistant agent in Grok Bot, to Trenton, the content editor agent in Grok Bot, to local Qwen. The exact first-hop transport was not established. Local execution returned a staged draft; independent final acceptance was not established. September 27, 2026.
- Cursor → Qwen: T-L. A Cursor-led job received a local-Qwen first pass and overrode mistakes before preparing its briefing. This is historical local-worker return and conductor review, not a current availability guarantee. August 26, 2026.
- Hermes → Qwen: D-L. The documented Mac CLI bridge can call local Qwen. A prior checkpoint reported the gateway stopped; this is not a claim of current autonomous availability. Public setup checked October 15, 2026; gateway checkpoint October 13.
- Claude → Codex: D-R. The public implementation describes configured Claude and Codex participants in Buzz. Both identities and the live relay must work; a fresh pairwise accepted-task test is not established here. Public setup checked October 15, 2026.
- Codex → Claude: D-R. The public implementation describes configured Codex and Claude participants in Buzz. Both identities and the live relay must work; a fresh pairwise accepted-task test is not established here. Public setup checked October 15, 2026.
- Claude → Claude: D-R. Separate configured Claude seats are described in the same Buzz relay. This is a conditional route between seats, not evidence that two Claude instances are independent reviewers. Public setup checked October 15, 2026.
- Grok Bot → Muse / Happy: D-S. The public implementation describes a named Grok desk writing a bounded request for Happy on the shared task record, with written receiver acknowledgment required. Public setup checked October 15, 2026.
- Muse / Happy → Qwen: X-L. Direct local execution is unsupported in the documented Muse setup because he has no shell on the Mac. A separately authorized conductor would be a different, indirect route. Public setup checked October 15, 2026.
What our checked routes actually established
Travel Dot (ChatGPT lead agent) ↔ Happy / Muse (Meta coordinator), October 13: Happy sent a correction and asked Travel Dot to confirm a reliable channel. Travel Dot answered and sent a bounded task packet; Happy returned a matching acknowledgment. This supports both directed shared-record cells. It did not establish completion of every task in the packet.
Grok Bot → Grok Bot → local Qwen, September 27: Tanner, the executive-assistant agent in Grok Bot, handed orchestration to Trenton, the content editor agent in Grok Bot. Trenton invoked the local Qwen worker. The record reported a staged draft. Independent final acceptance was not established. The local Qwen operating guide explains the Mac access used by this family of routes.
Cursor → local Qwen, August 26: a Cursor-led job received a Qwen first pass, rejected several recommendations, and used conductor judgment before preparing the briefing. This supports the historical local-worker return. It does not establish a fresh test today or an independently checked final briefing.
Claude and Codex in Buzz: the configured seats described here use our existing relay. That supports the conditional relay cells, not a fresh end-to-end acceptance test for each pair. Grok Bot’s own desk messaging is a separate route.
Hermes → local Qwen: our Hermes local bridge guide describes this connection. An October 13 checkpoint recorded the gateway stopped. A documented or installed bridge still needs a live access test.
Muse → local Qwen directly: the red × is narrow. The documented Muse setup has no Mac shell, so he cannot directly operate that local worker. A request passed to an authorized conductor would be a different route and needs its own task and return checks.
The historical receipts support these descriptions. Their private account and task details stay out of this public guide. The public guides explain the mechanisms; they do not certify that every connection is online now.
Documented connections you can set up separately
Official documentation describes additional routes. I have kept them out of the green cells because documentation is different from a checked run in the accounts above. These are useful starting points when you want to extend a setup.
- Grok Bot → Cursor Cloud Agent, D-I. The official Grok Bot getting-started guide shows a bot starting a Cloud Agent through the Cursor connection. The same guide documents bot-to-bot messaging. A Cursor cloud job is a separate receiving surface from the Mac IDE agent in the matrix.
- Claude Code, Claude Desktop, Codex or Cursor → Perplexity Computer, D-M. The official Perplexity Computer MCP setup describes delegating multi-step tasks and receiving structured results. It uses Perplexity OAuth and account credits. Keep the returned thread ID to continue the same job and check its status. This does not prove that my Perplexity research seat already has that connection.
- Claude Code, Claude Desktop or Cursor → Perplexity API tools, D-M. The official Perplexity MCP repository documents search and research tools. Calling those tools is different from assigning a persistent Perplexity Computer worker. State which receiving service you mean.
- Gemini Apps → an authorized custom MCP app, D-M. Google’s Gemini custom-app setup guide currently lists US adults with a personal Google account, English, and Keep Activity enabled. Setup starts on the web, with use on web or mobile; write actions require manual confirmation. Check the account and specific server. Generic MCP support alone does not prove that Gemini can delegate to any brand in this grid.
- Qwen Code → Claude Code or Codex, D-E. The official Qwen Code subagent guide documents external executors using separately installed and authenticated Claude Code or Codex. Qwen Code is a coding app. It is a different runtime from my local MLX worker, so this evidence does not turn the Qwen column green.
- Gemini CLI → a compatible remote agent, D-A2A. The Gemini CLI remote-agent guide describes a configured remote subagent using an agent card and authentication. This applies to the CLI, not the Gemini web conversation used in the audit.
- A compatible editor → Kimi Code CLI, documented client route. The Kimi Code editor guide describes Agent Client Protocol support. That lets a client work with the coding runtime. It does not establish a receiving route into my Kimi Work conversation.
Keep API, consumer chat, command-line agent, desktop editor and cloud worker labels separate. Also check what an MCP server exposes. A server that offers file tools does not automatically expose a thinking agent that can own a job.
The Gemini case: the route worked, then the review caught defects
On October 14, I wanted a 20-page public-source audit for business owner Anthony Hilb. Travel Dot used the existing Gemini conversation through an authorized browser session on my connected Mac. It retained responsibility for getting the files back and checking them.
Approved brief→Mac browser
Gemini web task→Original files
Receiving review→Correction
Same task
The browser’s automated download wait timed out, but the native download had succeeded. The receiving worker opened the actual PDF viewer, used its download control and verified the saved files. Before starting another job after a timeout, check whether the expected output already exists.
The original package contained a 20-page PDF, a workbook with five tabs, and a CSV with 46 evidence rows. Those counts describe the recovered originals, not an accepted corrected package. The receiving review recorded file fingerprints so the producer and reviewer could refer to the same bytes.
What the receiving review found
All 20 original PDF pages were rendered and inspected. The reviewer found no blank pages or stray tool-citation tokens and counted 56 unique clickable HTTPS links. It fetched 33 of those URLs; the other 23 stayed unknown, mostly because access was blocked. One exact emergency-services URL returned a 404.
A factual issue concerned award badges. The tree-service homepage displayed 2024 and 2025 badge media, which contradicted the report’s missing-badge claim. The fix needed to describe what the page displayed without treating the badge itself as independent proof of an award win.
The report also had title-and-badge collisions on pages 11 and 19 and roadmap labels that were too small on page 18. Custom reconstructions did not substitute for the source photography the review required. The original audit failed receiving review.
What remains unproved by that run
Travel Dot sent one correction in the same Gemini conversation. At about 10:26 UTC, Gemini reported that it had compiled a revised PDF and was fixing tables, and described a revised 48-row workbook. Those were producer progress reports. At the verified checkpoint, the revised Gemini exports had not been retrieved and accepted.
The selected Mac connection went offline, and a later browser-policy failure blocked retrieval. Restored file access did not establish restored browser control. A later local repair of the audit package is a separate output; it cannot serve as proof that Gemini’s revised export was recovered or accepted.
The October 15 baseline records the browser handoff as observed; the current evidence grid labels it historical. The original audit’s acceptance result remains fail. Both facts belong in the record. Our quality and reliability guide explains why a correction has to reach the actual final file before the owner accepts it.
This run involved no new subscription purchase or paid API activation. Total cost, token count and end-to-end duration were not established, so this case is not a cost benchmark. Nor does it prove that local browser work continues when the Mac is closed or asleep.
Test one handoff before you rely on it
Use this procedure when you want to add a route or when an existing connection has changed. Bring the exact sender and receiver, approved source material, a reachable account or endpoint, one task owner, and a place to return the result. Start with public material and a low-risk task.
- Name the two surfaces. Write “Cursor IDE on this Mac → local Qwen worker” or “Claude Desktop → Perplexity Computer MCP.” Include the account or worker identity in the private task record. Keep credentials out of the brief.
- Set the task and its limits. State the goal, allowed sources, output format, permission limits and acceptance check. For an audit, link the current method used to review it before asking for a polished report.
- Send a small test with a unique reference. Ask the receiver to return that reference with the requested output. Use the actual transport you plan to rely on.
- Check the return path. Open the output from the receiving side. A request sent, a progress message, and a downloaded artifact are three different checkpoints.
- Make one factual correction. Ask for a revision in the same task. Check that the correction appears in every affected final file, not just in the chat reply.
- Record pass, fail or unknown. Save the exact artifact version, the route, the date, unresolved checks and the next owner. Route pass and output acceptance are separate fields.
If access fails, repair or reconnect the approved route and test it again. If the receiving app cannot take the task, choose another authorized route and label it honestly. Sharing a file does not wake a worker; the workflow needs a message, trigger or agreed read step.
A brief another worker can use
Task: check these three public pages against the linked method. Return a short findings file and source list with reference HANDOFF-TEST-01. Flag anything you cannot verify. Keep the work in this task. I will send one correction; return the revised file and say which lines changed. The task owner accepts the final version after opening it.
The completed test should leave a task record that the next authorized worker can find: request, receipt, output, correction, checked version, acceptance decision and next step. It gives you something much more useful than a claim that two AI brands “work together.”
Start with the outcome owner
I want one lead worker to keep the goal, choose the reachable specialist, and check what comes back. The useful question is: which specific worker can it reach today, through which route, with whose permission, and what will count as done?
Use How the Agents Run the Company for that operating model. For help putting it into practice, see the AI Builder Program. To use the methods yourself, start with the maintained agent skill packs.
I’m hiring two more AI builders who can travel and run agent teams like this, so if that sounds like you, read the hiring page and apply.
Sources and review date for the October 15 baseline
The October 15 baseline was reviewed October 15, 2026; current route evidence carries its own October 22 dates in the evidence section above. Historical run dates remain attached to the observed routes. Provider features, eligible accounts, permissions and connection status can change.
- The existing communication guide, reviewed October 13, supplied the named seats, Buzz relay and shared-record setup retained in this expanded map.
- Our local Qwen setup: Cursor, Grok Bot, local execution and Muse’s scoped limitation.
- Our Hermes bridge setup: the Mac command-line connection to local Qwen.
- Official Grok Bot guide: bot messages and the Cursor Cloud Agent connection.
- Perplexity Computer MCP documentation: supported clients, authentication, credits and task return handling.
- Perplexity API MCP implementation: search and completion tools, distinct from Computer.
- Gemini custom-app documentation: current custom MCP requirements.
- Qwen Code subagent documentation: external Claude Code and Codex executors.
- Gemini CLI remote-agent documentation: a separate A2A-capable runtime.
- Kimi Code editor documentation: ACP integration, separate from Kimi Work.
This page is a reference and worked case. It records the limits of the evidence; it does not certify every pair of AI products or every account on a platform.
How I divide the work and keep the record
These roles, shared places and working rules sit behind the connection map. The dated examples show how I set up this team. Human owners and decisions appear above the grid. Ads stay with the ads function; this guide does not create a second Social Amplification Engine.
Keep your AI team’s work clear so people can find and check the result. This map shows who does each kind of job and where its notes belong. Start with the task, then choose its owner and record.
The role directory below explains who handles each job. Use the directed connection grid above to see who can send work to whom.
This is my dated implementation map. For the current model-agnostic method, read How the Agents Run the Company, especially Where the Work Lives and How Work Moves. The named tools and roles below are examples, not prerequisites. For unowned work, use The Agent Job Board; for my daily workflow, read How I Talk to One Agent All Day. The shared-memory guide supplies the companion architecture.
Implementation reviewed 13 October 2026. The guide’s fleet map covers accounts, local workers and pilots with dated evidence. Home Dot’s proposed roster role needs a verified account and return test. This page keeps the named implementation examples.
Claude builds. Codex checks. Grok works the same rails from outside the live room. Cursor is the desk I sit in with them. Travel Dot is my strategy and reasoning desk; its assigned work returns to the same task record. Kimi grinds long coding and public harvests. Local Qwen drafts on the Mac under Cursor. Happy / Muse coordinates daily work, owns the existing mail routine and assigned Meta execution. Each routine needs its own observed-run evidence. Tanner is the Grok Bot EA desk where I talk about the Dennis Attention pile. Hermes bridges non-Grok runtimes to local Qwen — not a thirteenth desk. Routine verified work, messages and publication proceed within recorded authority; humans decide consequential matters. Holds, client consent and platform gates remain. They coordinate on four surfaces: GitHub remembers, Basecamp has the client, Buzz is the live handoff, and scheduled tasks run when nobody is there. If it only happened in a chat window, it did not happen.
Want the Grok Bot view? See How I use Grok Bot as one ops desk for the named specialist sidebar, paid-seat routing, setup checklist, and current Grok Bot receipts.
Goal: hand a stranger, or their agent, a recipe they can copy: which model sits in which chair, where the work is written down, and what counts as done.
Content: a dated implementation map (Claude, Codex, Grok, Cursor, dot accounts, Kimi, Local Qwen, Happy / Muse, Hermes and human owners), four surfaces unchanged (GitHub, Basecamp, Buzz, scheduled tasks), a ten-step setup, and one week of the Social Amplification Engine as the worked example.
Targeting: operators already running more than one model who want a SOP, not a vendor pitch.
Who sits in which chair
Name the job, then pick the model. Configured Buzz identities (Engineer, Claude Travel, Fizz, Honey, Pollen) are labels for jobs, not a product you have to copy. Your builder, writer, and checker can be named anything. The rule that matters is this: the agent that checks the work is not the same model that did the work.
| Chair | What it is for | What it is not |
|---|---|---|
| Claude | Long builds, drafts, site edits, the writer and engineer seats in the live room. | A second Claude is not a second opinion. Four Claudes agreeing is one opinion with three echoes. |
| Codex | The checker. Research, diffs, “did we actually prove that.” On my board that seat is Pollen. | Not the only writer. Not a merge or spend authority. |
| Grok | Same GitHub and Basecamp rails, including this Cursor desk and Grok Bot scheduled jobs. | Not in Buzz. There is no published adapter that lets the Grok CLI speak that room’s protocol. When that adapter ships, Grok gets a seat. Until then I will not tell you it is in the room. |
| Cursor | The human-watched IDE. Claude or Grok can sit here. I can see the diff before it ships. | Not a fourth surface. Work still has to land in GitHub. |
| Travel Dot | Primary strategy and reasoning desk; architecture, priorities and acceptance for assigned work. | A named role, not another account count. Source, actual account, tools and checked return need proof for each task. |
| Tanner | Grok Bot executive-assistant and publish desk; routes named Grok handoffs and releases accepted artifacts through the existing protected static lane. The durable claim is in the repository; the board points to it. | A desk within Grok Bot, not another subscription. Dispatch is not acceptance; publication preserves target, permission, preimage and rollback gates. |
| Trenton | Grok Bot writing desk, LinkedIn and X; owns this implementation page and its content acceptance. | A desk within the same roster. Its review scope does not grant authority over another task, runtime or account. |
| dot accounts | Travel Dot owns strategy and assigned acceptance. Home Dot is proposed for delivery and private registry maintenance, after account binding and its read-update-return test. The second paid account may take bounded production or review work. | Account, memory, tools and return routes require separate proof. Home Dot is not yet matched to a paid seat. Provider memory does not replace the task record. |
| Mail cop | Muse owns the configured 15-minute inbox routine: skip, farm, or Dennis Attention. His first run was observed on 27 September 2026. The mail service is designed for round-the-clock coverage through the configured 15-minute Muse routine. Inspect actual run receipts and gaps before reporting coverage. Codex is paused backup, used only after a verified Muse outage or an exact-thread handoff; Grok and Cursor are not overlapping mail routers. Keep one router and quiet runs when empty. Tanner, my Grok Bot EA desk, is where I talk about that pile; it does not route. The method is how I manage 1,000 emails a day. | Not Codex (the paused backup), not Cursor, not Hermes, not a Grok Bot desk. Cursor and Codex farm homework only. A phone desk is where I talk about the pile, not the cafeteria monitor. |
| Kimi | The grinder. Long coding and public harvests. A different model grades the output. The math is on Kimi K3 vs Claude. | Not mail. Not client PII. Not publish, send, or voice. |
| Local Qwen | $0-API Mac worker. Drafts only (GCT / factory / MAA first passes). Cursor stays the conductor. Playbook: How I Use Local Qwen (Cursor Stays the Conductor). Routing: Cursor and Local Qwen Are Not the Same Qwen. | Not a Grok Bot desk. Not publish, send, or spend. Not a substitute for Cursor judgment. |
| Muse | Daily coordinator and chief of staff, with assigned Meta execution. Owns Facebook, Instagram, WhatsApp, and Threads. Also holds the Mail cop chair: the existing configured inbox routine, with current cadence checked in dated receipts. Trenton still owns LinkedIn and X. Hub: How We Coordinate Meta Muse With Our Multi-Agent Fleet. | Not a Grok Bot peer. Not a Buzz seat. The repo task remains the durable record. Drive agent-now.md is its fixed pointer, not a second claim. Tanner sends a one-to-one SendToAgent to the named Grok desk. Routine asks to Happy / Muse use a For Happy repo note with the exact artifact, ask, owner and deadline; Happy returns a written acknowledgment on that record. GitHub PR comments retain the same task’s review and result. A pointer or taxi dispatch alone is not receiver acceptance. No agent receipts on public posts. |
| Hermes | Cheap bridge for non-Grok runtimes → local Qwen on loopback. Not a thirteenth desk. Never Opus (or OpenRouter) as the default for routine bridge traffic. Hub: How I Use Hermes Agent (the Cheap Bridge, Not a Desk). | Not a roster desk. Not mail. Not a Buzz seat. Not a replacement for Cursor conductors or Grok SendToAgent. |
May the best idea win. The newest model does not win by default. The idea with a receipt wins.
The one question
Before you or your agent writes anything, anywhere, ask one thing:
Who has to find this, when, and what do they need to do with it?
That question sorts everything, because each of the four places has exactly one thing it can do that none of the others can. Pick the wrong one and you do not get a small mess. You get a specific, predictable failure.
GitHub carries the durable record in this setup
An agent three months from now can open a GitHub repo and reconstruct what happened, who did it, and what it touched. It can read the diff. It can see the date. It can see what the last agent said it did not check.
I use GitHub for the versioned record and keep working chat separate. Another team can use an accessible document, issue tracker or repository. What matters is that the next authorized worker can find the current request, decisions, artifact revision, evidence and next action.
So GitHub carries the record: what ran, what it read, what changed, what passed, what was not checked, and what is blocked and on whom. Repo-writing agents leave the same run-note template after substantive work. Read-only private desks use their permitted return route and do not write this repository. That is how a stranger’s agent can pick up work my agent started. It is the same loop I described in how skills propagate.
The public methods live in the Local Service Spotlight skills repo. The team ledger is a private repo (Local-Service-Spotlight/agent-runtime) — that is also where the function-owned agent job board lives. Do not treat a private URL as the recipe. If a stranger cannot open it, it is not the public SOP.
Save each record in the system that owns it. In the team ledger, add only a link or summary that the intended readers are allowed to see; keep private content and secrets in their approved stores.
Basecamp is the only one with the client in the room
Start every Basecamp comment with one or two plain-English sentences that say what happened, what comes next and who needs to act. Put the detail after that opener.
That single fact sets the whole standard for it. Everything you put in Basecamp is read by a human who is paying you, has not read your repo, and did not follow your reasoning.
So Basecamp carries decisions and client-visible statements. It does not carry thinking out loud. It does not carry a claim you cannot back with a receipt. And it does not carry a link that works for you and returns a permission error for them — which happens more often than anyone admits, because you are logged in and they are not.
One hard rule my agents have, learned the expensive way: never reply to a Basecamp notification email. Email replies drop the routing token, the comment never lands on the thread, and you get a bounce that reads like a system error rather than “your client never saw this.” Post in Basecamp. Then verify the comment is there by opening it, not by looking at your sent folder.
Buzz is the only one where two different models are in the same room
Buzz runs agents as real processes that connect to a relay and sit in channels, like a team chat where some of the members are software. What makes it different from every other chat tool is that the agents do not all have to be the same model. Mine has Claude on three seats and OpenAI’s Codex on the fourth, in the same conversation, at the same moment, with me able to watch and interrupt.
Nothing else I use does that. GitHub is asynchronous. Basecamp moves at human speed. Buzz is the handoff — “I am done, you are up, here is the link” — across models that otherwise cannot see each other at all.
So use it for exactly that, and nothing else. Not status. Not thinking out loud. Not encouragement. If it is worth writing down, it goes in the repo. If it exists only in a Buzz channel, it did not happen.
Scheduled tasks are the only one that runs when nobody is there
The fourth surface is the clock. A scheduled task fires at six in the morning with no human present, does the work, and writes its receipt.
The trap here is subtle and I have watched smart people fall into it. A schedule is not an outcome. “It is scheduled” and “it ran” and “I saw the result” are three different states, and the gap between them is where a month of silently failing jobs hides. My agents are not allowed to report one as the other.
Do not invent a second clock for a new idea. Fold the checkpoint into a clock you already have. We learned that the loud way on Social Amplification: the weekly heartbeat is the existing MAA (Metrics, Analysis, Action: results, meaning, and next steps) run, not a second SAE timer.
The copyable recipe
- Search before you mint a URL. One concept, one public page. Skins and case studies link up. They do not fork a second master.
- Write GCT in three lines before the draft. If you skip it, you get a generic article that could sit on anyone’s site.
- Claim the work on a visible board so a second agent does not start a second copy. On our team that board lives in the private GitHub Team Operations Ledger (
Local-Service-Spotlight/agent-runtime) — files likestatus/JOBS.mdandstatus/NOW.md. It is not Basecamp, not Buzz, and not Obsidian as master (Obsidian can be a reading UI over a checkout). Rows are function-owned so any teammate’s agent can claim. The public explainer is The Agent Job Board. Yours can be a GitHub issue. The point is visible ownership, not our filename. A file claim does not by itself prove atomic exclusion across separate checkouts. See Claims and Collisions for the tested claim mechanism and write-boundary checks needed when workers can collide. - Pick the chair by the job. Builder and writer may share a model. The checker should not.
- Do not paste the inbox into a chat. Muse owns the configured 15-minute inbox routine (quiet when empty). The mail service is designed for round-the-clock coverage through the configured 15-minute Muse routine. Inspect actual run receipts and gaps before reporting coverage. Codex is paused backup, used only after a verified Muse outage or an exact-thread handoff; Grok and Cursor are not overlapping mail routers. Cursor and Codex farm the homework — they are not mail routers (Codex is only the paused backup), and neither is Hermes. You only see Dennis Attention. Muse owns the existing follow-up route. Each task carries its current deadline and next check; keep one chase owner and inspect actual runs.
- Do the work where a human can see the diff when the job can break a site or a client sentence. That is why Cursor exists in this picture.
- Write the receipt in the repo before you tell anyone it is done. Template, every time: what was asked, what you found, what you changed, what you got wrong, what is blocked, the next click.
- Client-visible decisions go in the client tool. Never Gmail-reply to a Basecamp notification. Changing the From line does not fix the routing.
- Use the live room when workers must hand off now. Post the task link and the bounded next action. The receiving worker confirms access and accepts the handoff; the task record remains authoritative.
- Attach the job to an existing clock if it has to run again. “We should schedule that” is not a receipt.
- Public pages follow the article guidelines until the checklist is green. First person on a personal site. WordPress author is the person, not admin. Lead visual is article-specific, above the fold, not a generic framework card. Entity links: people to their site, our concepts to the definitive page, 3–6 word anchors, no “click here.”
If you want the architecture under this recipe — three rooms and a credential safe, one authority per record class — read How Our AI Agents Share Memory and Coordinate Work. If you want a dated worked example of standing up that memory, read Give Your AI Team One Shared Brain. Those pages are not this page. This page is who sits where, and in which room.
A week of this, in public
The worked example is the agentic Social Amplification Engine. Amplify reputation, proof, and trust that already exist. Do not manufacture authority. Screen with GCT before you amplify. The commercial pointer is Local Service Spotlight’s GCT qualify page. The course that teaches the six phases to humans stays at its own URL. We did not mint /sae-2/.
What the agents actually did, split by chair:
- Codex built the evidence gates so UNKNOWN is not zero and nobody invents a 0–100 score. A public self-report cannot mint verified evidence.
- Claude wrote the four-surfaces article you are reading the first version of, and the Buzz house rules so agents do not burn tokens thanking each other.
- Grok in Cursor published the operating hub, filled the screen skill, and is the desk enhancing this page so it also answers “who does what.”
- Grok Bot opened a standards pull request on the public skills repo. A stamp pass truncated a skill file to one byte. Cursor restored it. That is the point of a second model: it catches the first.
- Recorded authority governs send, publish, spend and merge; routine authorized work proceeds and consequential decisions escalate. A “qualified pending review” badge is a candidate. It is not a client, not a roster row, and not permission to run ads.
Content still moves Produce → Process → Post → Promote. Paid math in Promote is Dollar a Day. The weekly heartbeat is Metrics → Analysis → Action. Factory and ads plug into those functions. They do not fork a second engine.
The build record for that week is How We Built the Agentic SAE. Read it after this page, not instead of it.
The rule that keeps the bill down
Here is the thing nobody warns you about when you put several agents in one room. They will talk to each other. Not usefully — politely. “Great point.” “On it.” “Let me know if you need anything else.” Each of those is a full model turn that you paid for and that moved no work forward.
When I opened my own Buzz configuration and actually read it instead of assuming, here is what I found. One agent was set to answer only me. The other two were set to answer that agent. So one message from me produced three turns: the first agent answered me, and then the other two each answered the first agent. Two out of three turns were an agent replying to an agent with no work in hand.
That is not the model behaving badly. That is a default nobody chose. The concurrency setting was also sitting at ten on every agent, with no ceiling at all on how long a single turn could run.
The fix is one line of policy and four settings:
- Messages need a job. Within the user-authorized workflow, agents may exchange bounded assignments, necessary questions, handoff acceptance and completion receipts. An agent posting nearby is not a reason to answer. Skip acknowledgments that move no work forward.
- Every message must advance the task: an assignment, deliverable, decision, handoff acceptance, blocker with a named owner, or necessary question. If it carries none of those, say nothing.
- Post links, not contents. A wall of pasted output in a chat room is unreadable by the next agent and costs everyone who loads the thread.
- Use recorded authority and granted tools. Routine verified sends and publication proceed within scope. New spend and consequential decisions require the reserved decision; holds, client consent and platform approval gates remain.
I keep those rules in one file and point every agent’s instructions at the file rather than pasting the rules into each agent. Paste them four times and your next edit reaches one of them. That is the same reason we keep one concept on one page instead of four slightly different copies.
A second Claude is not a second opinion
When I set this up, all four of my Buzz agents were Claude. They are excellent. They also tend to be wrong in the same direction, because they are the same model reading the same context.
So the researcher seat — the one whose whole job is checking assumptions — now runs on Codex instead. The agent that checks the work is deliberately not the model that did the work.
Grok is not in that room yet, and I want to be precise about why rather than vague. There is no adapter published that lets the Grok command-line tool speak the protocol Buzz uses. That is not a setting I have wrong. The piece does not exist. So my Grok desk hands off the way any outside contributor does — through the repo and through Basecamp.
What broke, and why I am telling you
I tightened those Buzz settings and reported it done. It was not done. I had set two timeout values the wrong way round — the idle timer above the maximum turn length — and the platform rejects that combination outright. My main engineering agent failed every single start for seventeen minutes and would have stayed down indefinitely, because the only symptom is an agent that quietly does not come up. Three more agents had the same broken setting waiting for them and looked fine only because nobody had started them yet.
I found it because I went and read the log instead of trusting my own change. The real lesson is not “check your work,” which everybody says and nobody operationalises. It is this: the check has to test the property you care about, not the thing you just did. My original check confirmed I had written the values I intended to write. It never asked whether an agent could start.
So the fix is not that I now remember the rule. The tool refuses to save a configuration that breaks it, and it will tell you why. A rule you have to remember is a rule you will eventually forget. Make the wrong value impossible to save and you never have to be careful again.
I write these up in public on purpose. If you only ever see the wins, you learn nothing you can use. Your first hundred are supposed to be rough — that is true of agent setups too.
If you are setting this up tomorrow
You do not need four surfaces on day one. Most people need two: somewhere the work is recorded, and somewhere the client is. Add the others when you feel the specific pain they solve.
- Pick your record first. A private GitHub repo, one note per job, one template. Not a chat history. Not your memory. Agents never use Dennis’s inbox to message each other; keep agent traffic on the existing task and handoff route.
- Make the client surface separate from the working surface. The thing your client reads should never be where your agents think out loud.
- Only add a live agent room when you have two different models to put in it. If everything you run is the same model, a shared room mostly buys you agents agreeing with each other at your expense.
- Set bounded message rules before starting workers. Allow authorized assignments, useful questions, handoff acceptance and results. Suppress idle agent-to-agent chatter.
- Write down what each surface is not. That sentence is worth more than the description of what it is, and it is the sentence everyone skips.
- Publish the recipe on a personal-brand URL in first person, then put a short company pointer that links up. Do not write the master twice. Follow the article guidelines until every box is closed. If you use Cursor for the desk, how we use Cursor for marketing is the companion, not a second coordination master.
If you want the shape of the whole system rather than just this piece of it, start at new agents start here, then install the skill packs so your agents run the same methods mine do. If you would rather see it working before you build anything, watch one of my desks do real work and read what it wrote down afterwards.
Questions people actually ask
Is this the architecture spec?
No. The spec is set up cross-agent shared memory. This page is the roster and the routing rule in plain language. The waiting room for unowned work is The Agent Job Board — master copy in the private GitHub ledger, not Basecamp or Obsidian.
Do I need Buzz on day one?
No. Add a live cross-model room when you have two different models that must hand off in the same minute. Until then, GitHub plus the client tool is enough.
Can Grok sit in the live room?
Not today, on my stack. No published ACP adapter. It still writes receipts and Basecamp the same way every other out-of-band desk does.
Should Grok Bot run my inbox?
No — Muse owns the existing configured inbox routine; quiet when empty, with current cadence checked in dated receipts. Codex is the paused backup. I still talk to Grok Bot — Tanner, my EA desk — about the Dennis Attention pile so I never open Gmail. Named desks stay. Cursor and Codex farm homework only. That split is on the 1,000-emails page.
Who is the one agent I talk to?
The Grok Bot coordinator, like a named teammate with persistent desks. Muse owns the inbox; Tanner is the EA desk. Cursor is the workshop, and those laptop chats do not appear on Cursor iOS. Local Qwen drafts under Cursor when the job is a cheap first pass — see How I Use Local Qwen. Cursor and Codex farm homework; they do not poll mail. The day-in-the-life is how I talk to one agent all day.
Is Muse a Buzz seat or a Grok Bot desk?
No. Happy / Muse is the daily coordinator with assigned Meta work. He owns Facebook, Instagram, WhatsApp, and Threads, and he holds the Mail cop chair: the existing configured inbox routine, with current cadence checked in dated receipts. Trenton still owns LinkedIn and X. Muse is not a Buzz seat. The repo task remains the durable record. Drive agent-now.md is its fixed pointer, not a second claim. Tanner sends a one-to-one SendToAgent to the named Grok desk. Routine asks to Happy / Muse use a For Happy repo note with the exact artifact, ask, owner and deadline; Happy returns a written acknowledgment on that record. GitHub PR comments retain the same task’s review and result. A pointer or taxi dispatch alone is not receiver acceptance. Details: How We Coordinate Meta Muse With Our Multi-Agent Fleet.
Is Hermes a thirteenth desk?
No. Hermes is the cheap bridge for non-Grok runtimes into local Qwen on loopback. It is not a roster desk, not mail, and not a reason to burn Opus on routine handoffs. Grok-to-Grok task delivery uses 1:1 SendToAgent; GitHub PR comments record review and results. Details: How I Use Hermes Agent (the Cheap Bridge, Not a Desk).
Does a public qualify page let agents onboard a client?
No. A public inventory is a self-report. Independent review, accepted scope, and an Ops roster decision come first. Default execution is stage-only. That rule is on the operating hub.
Where should a company-site version live?
As a short pointer that links up, in third person, with the WordPress author set to a named person, not admin. The Local Service Spotlight pointer is how agents coordinate.
The one line to keep
Nothing becomes true because it was said. Not in a chat room, not in a client thread, not in a meeting. It becomes true when it lands in the system that owns it, with a receipt someone else can open.
Every one of these four surfaces is just a different way of pointing at that. Get that straight and the complexity stops mattering, because the question stops being “which tool” and becomes “who needs to find this, and when.”
And if your agent tells you a job is done, ask it for the link. A run with no receipt did not happen.