Hermes Handoff — One Front-Door to Your Gated Models

AGI Summit 2026 Hackathon — frontier models are gated behind specific harnesses and subscriptions. Pick the ONE you already pay for; Hermes hands it any task. Cotal underneath.
🥇 1st place — Cotal sponsor track · AGI Summit 2026 2 connectors built by us 2 PRs upstream to Cotal 11 benchmark runs · 9 studies 57/58 hermetic tasks passed no API credits needed github.com/Wally-Ahmed ↗ ⬇ download the project
▶ Narrated walkthrough gives you the 2-minute guided tour · or click any component and simulate a task yourself
The product — tools/hermes-handoff
$ hermes-handoff init
the model you want is locked to a specific harness and its subscription. The wizard wires Hermes to the one you pay for: any task, your own login, no API credits.
1 · DETECT
installed harnesses + auth state
2 · PICK ONE
the model your sub unlocks
3 · WIRE
Hermes planner ⇆ your worker
4 · HANDOFF
any task — not just code
model gatingClaude Opus 4.8 → only via Claude Code + Max
model gatinggpt-5.6-sol → only via Codex + ChatGPT
model gatingGemini 3.1 Pro (High) → only via Antigravity + Google
Under the hood — and scale-out mode: the same wiring runs a full mesh with all three harnesses at once
You (or a judge)
cotal send ask planner "TASK … DONE-WHEN: test.py prints PASS"
Persistent planner
Hermes (Nous Research)
plans & delegates · never executes · state lives on the mesh
The baseline we benchmark against
MCP subagents — many models, one loop
one harness calls different models mid-loop · the contrast to Cotal's harness-per-model setup (run 3)
⇆  Cotal mesh — NATS · presence · anycast claims · reply correlation  ⇆
worker · builder
Claude Code
Claude Max subscription · official connector
OURS
worker2 · builder
Codex CLI
ChatGPT subscription · our connector
OURS
worker3 · builder
Antigravity CLI
Google account · our connector
connector statusofficial Cotal connector — full worker, works out of the box
connector statusofficial = pull-only experiment: the mesh can't wake itours: autonomous worker — PR'd upstream to Cotal
connector statusofficial = noneours: autonomous worker, live-tested — PR'd upstream to Cotal
1 · ASK
task + DONE-WHEN → planner
2 · PLAN
decompose, pick a worker
3 · HANDOFF
delegate over the mesh
4 · EXECUTE
build in place, own auth
5 · VERIFY
run the task's own test
6 · REPORT
verified result on #general
— press ▶ to watch a task travel the mesh —

Inspector

Click any node or flow step above to see what it is, how it authenticates, and what we built for it.

Inside our connectors — the shim (push-by-respawn)

Cotal meshpeers push messages —
the worker never polls
300 ms debounce
burst → one batch
the shim · always onMeshAgent inbox (cap 200)
loopback MCP · cotal_* tools
drain → ack → spawn
fresh harness turncodex exec resume <thread>
agy -p --conversation <id> · pTTY
works · replies live
via cotal_* · exits
memory = the threadstate lives server-side —
a killed turn resumes intact
Between turns there is no harness process at all — nothing to wake, nothing to die. The shim is the alarm clock. (A second, unrelated “shim” appears in the #286 deep-dive below — the two-shims table there tells them apart.)

v0.4 (PR #258) — the fix our benchmark provoked, and how we switched it on

Run 8 exposed itkill a worker mid-task —
no task lifecycle · the planner never re-delegates
findings public
→ 24 hours
Cotal ships v0.4work pools: leases · crash redelivery · restart supervision
per the Cotal team, a direct response to these benchmarks
our audit:
built — but switched off
locked one layer downa pool needs an owner endpoint — chat-plane agents
hold zero work-pool grants · nothing upstream consumes it
our response № 1 — stay currentPRs #254/#255 rebased onto v0.4 the same day
versions in lockstep · MESH_FIRST_STEER folded in
№ 2 — adopt it ourselvesour supervisor plays the missing owner role:
enqueue → lease → DM a real builder · never ack early
kill the builder —
the lease surfaces back
the mesh healsredelivery → re-lease (fencing token bumps) → next builder finishes
verified on published @cotal-ai/core 0.13.2
Run 8's silence was the disease; v0.4 is the cure — shipped dormant: the code is in the release, but switched off. Not an oversight — their rollout starts a layer down (service endpoints): no CLI command creates a pool, and agent credentials hold zero work-pool permissions, so it sits out of the agents' reach. We wrote the missing role and drove the machinery for real, outside Cotal's own tests, for the first time — the fix our benchmark inspired, switched on by the same benchmark's authors. Proven live in Run 11: same kill, re-lease ~2s later, second builder commits in 122s.

Still missing after v0.4 — it's all wiring, not engine (what a v0.4.x should ship)

① no ownerpools are endpoint-owned — an agent mesh has none,
so nobody exists to re-lease dead work
close it: a chat-plane pool-owner role (manager- or
planner-hosted) — our supervisor is the working sketch
② no permissionsagent credentials carry zero work-pool grants —
the broker refuses even a willing agent
close it: scoped pool grants minted into
planner / agent creds
③ no switchno CLI verb touches pools · connector-core neither
imports nor re-exports the API
close it: cotal pool verbs + a
delegate-via-pool planner tool
④ no triggerthe restart trigger is deliberately deferred — and the
offline event still dies one subscription short of the planner
close it: subscribe connector-core to presence, wake the
delegator on offline — smallest diff, biggest payoff
corroborated upstream: July 22 — hours after this page went live —
a community user independently filed issue #286: dead agents linger in the
roster with live-looking status "indefinitely, masking that they died" —
the same presence gap this box describes · GitHub's Copilot coding agent
attempted a fix the same evening (PR #288) and paused with zero code shipped
Is another update needed? Yes — but a small one, and none of it is engine work. Run 11 ran the v0.4 core untouched, straight from the published @cotal-ai/core 0.13.2, and it did everything it promised: death → redelivery → fenced re-lease → durable commit. What a stock mesh still lacks is exactly the four items above — an owner, grants, a verb, one event subscription — and our ~110-line supervisor is the existence proof that each is closable. Run 8 found the disease · v0.4 built the cure · Run 11 proved the dose — the remaining update is switching it on by default. v0.14.0 (released July 22) shipped the security campaign — secret custody + multi-space — and closed none of the four gaps; the v0.13.2→v0.14.0 connector diff is version bumps only.

Inside the #286 fix — anatomy of a ghost, and the repair

Two shims — same word, opposite lifecycles
Two unrelated processes on this page are both called “the shim”. The #286 bugs in this section belong to the left column; the push-by-respawn panel above documents the right.
#286 shim · opencode connector
our shim · codex + agy connectors
process tree
manager’s kill ladder
└─ shim ephemeral × SIGKILL lands here
└─ opencode serve persistent
survives the kill · heartbeats “idle” forever — the ghost
shim persistent — owns the mesh identity
└─ harness turn ephemeralcodex exec resume · agy -p
spawned per message · works · exits — nothing left to orphan
who wrote it
Cotal upstreamships inside the opencode connector — the codebase this deep-dive repairs
usbuilt for the codex + agy connectors — upstream PRs #254 + #255
lives
ephemeral wrappera thin launcher babysitting a server that outlives it — the short-lived side of its pair
always-on ownerholds the agent’s mesh identity and connection for the worker’s whole life — the long-lived side of its pair
wraps
a persistent serverone long-lived opencode serve handles every turn
one-shot turnsa fresh harness process per mesh message — codex exec resume / agy -p — that exits when the turn ends
if it dies
orphans the serve — the #286 ghostthe serve keeps heartbeating “idle” · fixed in PR #294: the serve watches the shim pid — gone means publish offline, drain, exit
drops clean — respawn healsthe mesh identity dies with it, nothing survives to keep publishing; a respawned shim resumes the same thread, memory intact
role on this page
the bug we fixedissue #286PR #294
the connectors we contributedPRs #254 + #255
One line to keep: theirs babysits a long-lived server and can die leaving it orphaned; ours IS the long-lived thing — and deliberately re-creates short-lived turns.
① the killmanager SIGKILLs the opencode connector’s shim —
pty-level, nothing catches it
② the orphanthe opencode serve underneath survives —
plugin + heartbeat keep publishing “idle” forever
③ the liegoing idle never cleared activity — the roster shows
finished work as live · CLI renders dead rows like healthy ones
idle clears activityone-arg change at every idle site —
including a session-adoption path nobody had on the map
shim lifeline2s liveness poll on the shim pid → publish offline + exit
stderr guard so the dead pipe can’t kill it first
10-second unref’d watchdog so a wedged broker can’t hold it
honest rowsoffline shows
last seen 40m · was: <activity>
provenred-green ×3 — each test fails with its fix removed
re-run on the REAL opencode binary:
shim killed → offline PUBLISHED → clean exit
① orphaned servemanager kills the opencode connector’s shim hard — the serve under it
survived, heartbeating idle forever
fix: a two-second lifeline on the shim pid —
gone means publish offline, drain, exit
② stale idlegoing idle never cleared activity — finished work
stayed on the roster, incl. a session-adoption path
fix: idle always clears it, everywhere
③ dead-pipe crashwith the shim dead, one stderr log line killed the serve
before the offline publish — node and bun
fix: one-line stderr no-op at lifeline arm
④ wedgeable shutdowncould double-fire; a half-open broker could
hold the drain for minutes
fix: single-flight flag + unref’d ten-second hard exit
⑤ lying rowsoffline rendered like live
fix: last seen <relative> · was: <activity>
+ unknown-guard on bad timestamps
stateevery fix locked by a test that fails without it
twelve files · +687 · gates green
proven on the real opencode binary
And underneath, more waited. A dead-pipe crash — one log line written to the SIGKILLed shim’s pipe kills the serve before it can say goodbye — proven on node and bun; a session-adoption path that strands stale activity; a shutdown a wedged broker could hang. Each is fixed, and each fix is locked in by a test that fails without it — proven end to end on the real opencode binary. Submitted upstream as PR #294.
tools/hermes-handoff/

The product: a zero-dependency wizard CLI. Detects harnesses + auth, you pick one, it wires Hermes as the front door — planner brain via subscription OAuth (hermes login) or any provider key.

Upstream contributions

Both connectors ported to the Cotal monorepo's conventions, built against in-tree connector-core, kept rebased on upstream main (post-v0.4, 0.13.x line), and submitted as pull requests #254 + #255 to Cotal-AI/Cotal — re-audited against upstream HEAD after the 0.13.2 release: zero conflicts, land-ready. And beyond code: our Run-8 failover findings preceded PR #258 (the v0.4 lifecycle) by 24 hours — per the Cotal team, a direct response — and our reclaim supervisor (benchmark/reclaim/) is the first thing outside Cotal's own tests to drive that machinery — proven live in Run 11: the kill that stayed dead in Run 8 heals in 122s, one re-lease, terminal fact committed.

Our open-source MCP servers — github.com/Wally-Ahmed

The subagent backends behind the benchmarks are ours, published standalone: openrouter-subagents — delegate to any OpenRouter model with full unified reasoning control — and gpt-subagents-subscription — expert GPT subagents on the ChatGPT plan you already pay for. Both drop into any MCP-capable agent.

connectors/cotal-connector-codex/

Our Codex mesh connector — Node shim owns one MeshAgent; cotal tools served over local streamable-HTTP MCP; turn chain via codex exec resume.

connectors/cotal-connector-agy/

Our Antigravity connector — pTTY turn loop, conversation resume, MCP-config merge/restore. Live-tested: "AGY WORKER OK" on #general.

benchmark/

12 validated tasks (easy, adversarial, reasoning, grounding), hermetic runners for four harness arms, coordination + throughput + cost studies, full RESULTS.md.

.cotal/agents/

Personas: planner (plan/delegate/never-execute) + three builders with execute-and-verify contracts.

docs/

Cotal wire-contract notes, mesh operations runbook (six spawn failure modes + fixes), and both connector design plans.

Compliance framing

Every harness is the official CLI under its owner's legitimate auth. No token scraping, no reverse-engineering — the mesh only coordinates.

Each study isolates one variable. ‹ › arrows, dots, or arrow keys to move between studies · hover a bar for per-task detail.
Coordination topology

Run 3 — Cotal mesh vs direct MCP subagents

Same goal, two topologies: mesh (planner → handoff → worker executes in place) vs one orchestrator delegating content to an MCP subagent and transcribing its output. Variable isolated: how the work is coordinated.
Cotal mesh
3/3 · 95st1-lru 32s · t2-bugfix 31s · t3-cli 32s
Direct MCP subagent
3/3 · 137st1-lru 46s · t2-bugfix 51s · t3-cli 40s
Mesh wins ~30% at equal quality. Executing in place beats generation-at-a-distance, and the handoff itself costs ≈ nothing: mesh end-to-end ≈ a bare claude -p on the same tasks.
Pool throughput · new

Run 6 — Parallel across 3 workers vs sequential through 1

The same planner receives the same 3 tasks; one arm fans them out to three heterogeneous builders (Claude Code, Codex, Antigravity) concurrently, the other routes all three through a single builder. Variable isolated: the worker pool.
Parallel fan-out (3 workers)
3/3 · 203st1-lru 36s · t3-cli 46s · t2-bugfix 203s — makespan bounded by the slowest worker
Sequential (1 worker)
1/3 · DNF 1504st1-lru 27s ✓ · then the planner dropped the serial queue — t2/t3 never dispatched before the 25-min cap
Fan-out completed 3/3 in 203s; the serial arm didn't finish at all. Two findings in one: the heterogeneous pool works (makespan = slowest worker), and long serial delegation chains are the planner's weak spot — exactly the failure the roadmap's "failover & reclaim" study targets.
One suite · six arms

Runs 1–2 & 4 — one hermetic suite, six harness × model arms

The identical 7-task suite (t1–t7) across every harness × model pairing we could drive — one matrix, two variables isolated: the harness itself (the same Opus 4.8 on Codex vs Claude Code) and whether the harness is the model's home (Gemini native on Antigravity vs through Codex, plus Antigravity's whole roster).
Opus 4.8 · Codex (OpenRouter)
7/7 · 149seasy 44s (15·14·15) · hard 105s (33·37·21·14)
Opus 4.8 · Claude Code (Max)
7/7 · 313seasy 79s (22·28·29) · hard 234s (105·43·55·31)
Gemini 3.1 Pro · native Antigravity
7/7 · 298s24 · 34 · 32 · 88 · 48 · 48 · 24 (t1→t7)
Gemini 3.1 Pro · via Codex
7/7 · 521s14 · 52 · 28 · 76 · 121 · 149 · 81 (t1→t7)
Opus 4.6 Thinking · Antigravity
7/7 · 295s25 · 25 · 23 · 87 · 63 · 43 · 29 (t1→t7)
GPT-OSS 120B · Antigravity
6/7 · 333s39 · 16 · 18 · 151 ✗ t4-interp · 70 · 21 · 18
One suite, six arms, one genuine failure. Same model, two harnesses: a ~2× wall-clock gap at 7/7 both. Same model, native vs foreign home: native wins ~1.75× at equal correctness. The roster shootout is a near-tie — GPT-OSS dropping the interpreter task is the only genuine capability failure in all 43 hermetic tasks.
Subscription reality

Run 5 — Each harness on its OWN subscription

The delegation targets a planner actually chooses between — each harness under its own flat-rate login, running its native subscription model: Antigravity (Gemini 3.1 Pro High, Google), Claude Code (Opus 4.8, Max), Codex (gpt-5.6-sol, ChatGPT). Variable isolated: the full backend+model pairing users actually run.
Antigravity + Gemini 3.1 Pro (Google)
7/7 · 298seasy 90s (24·34·32) · hard 208s (88·48·48·24) — the run-4 native arm, same suite & protocol
Claude Code + Opus 4.8 (Max)
7/7 · 313seasy 79s (22·28·29) · hard 234s (105·43·55·31)
Codex + gpt-5.6-sol (ChatGPT)
7/7 · 444seasy 100s (43·30·27) · hard 344s (135·89·71·49)
The latency story inverts: Antigravity and Claude Code finish neck-and-neck (~5% apart), both ~1.4–1.5× ahead of Codex. End-to-end latency is decided by the backend+model pair — exactly the per-task choice a Cotal planner can make.
Capability dimensions · new

Run 7 — Agentic depth · knowledge · self-verification

Three tasks isolating capabilities, not code generation: find a buried bug with no location hint (t8), write RFC 4648 Base32 from memory with the stdlib codec banned (t9), and treat a failing test as the spec when the prompt is deliberately thin (t10). The three subscription-native stacks, hermetic.
Claude Code + Opus 4.8 (Max)
3/3 · 111st8 buried-bug 37s · t9 RFC-recall 32s · t10 test-as-spec 42s
Codex + gpt-5.6-sol (ChatGPT)
3/3 · 147st8 36s · t9 72s — widest spread is deep recall · t10 39s
Antigravity + Gemini 3.1 Pro
3/3 · 161st8 61s · t9 49s · t10 51s
9/9 — capability is saturated on every dimension we could isolate. Exploration-driven debugging, spec recall without references, verification discipline: all pass everywhere. Worker choice is about latency, quota, and cost — not skill.
Reasoning & grounding · new

Run 9 — Constraint satisfaction · hallucination resistance

Two non-coding dimensions: a constraint scheduler whose checker validates the constraints themselves (any valid answer passes), and a grounding probe — 8 questions about a small local library where 3 reference functions that don't exist. The only right answer for those: DOES_NOT_EXIST.
Antigravity + Gemini 3.1 Pro
2/2 · 49st12 reasoning 28s · t13 grounding 21s · 0 hallucinated traps
Claude Code + Opus 4.8 (Max)
2/2 · 51st12 18s · t13 33s · 0 hallucinated traps
Codex + gpt-5.6-sol (ChatGPT)
2/2 · 63st12 24s · t13 39s · 0 hallucinated traps
6/6 with zero hallucinations — every arm answered DOES_NOT_EXIST on every trap. The mechanism matters: an agentic harness reads or executes the library instead of confabulating. Hallucination resistance is a harness property as much as a model property. First table Antigravity tops.
Economics · new

Run 10 — Cost per verified task

Same tasks, same harness — what does one verified PASS cost? Metered arms priced from measured token counts at list prices (90/10 in/out split); subscription arms ride flat monthly fees. Variable isolated: how the model is paid for.
Codex + Opus 4.8 · metered API
~$0.51 / PASS511k tokens over 7 tasks (runs 1–2)
Codex + Gemini 3.1 Pro · metered API
~$0.14 / PASS333k tokens over 7 tasks (run 4) — 3.6× cheaper than Opus
Any harness on its own subscription
≈ $0 marginalevery suite cleared — the real constraint is quota, not dollars
Subscriptions invert the economics — and that's the product thesis. You already pay the flat fee; the mesh just unlocks it. Field warning: a wedged planner loop burned ~$4 of metered credit overnight producing nothing — orchestrator idle-burn is a first-class cost line.
Resilience · pre-v0.4 baseline STALE — cleared by Run 11 →

Run 8 — Kill the assigned worker mid-task

This failure has since been cleared — Run 11 (next study) replays the identical protocol on Cotal's v0.4 work pools and the mesh heals. Kept as the pre-v0.4 baseline. The original test: the planner gets a task with explicit responsibility language — "monitor progress; if the builder goes offline, re-delegate." We wait until its chosen worker is mid-build, kill that worker, and watch for 15 minutes. Variable isolated: what happens when a worker dies.
Attempt 1 — bystander killed by mistake
✅ 94sassignee untouched, finished normally — and the planner re-ran the test itself before accepting
Attempt 2 — planner killed by mistake
✅ 50sdelegated work survived planner death; warm worker recreated the solution from memory
Attempt 3 — clean: assigned worker killed +100s
✗ DNF · 903splanner never re-delegated — session autopsy: zero messages reached it after the kill
No autonomous reclaim — and the autopsy says why. Cotal has no task lifecycle, so a dying worker emits no event; Hermes is event-driven, so no event means no turn. "Monitor progress" can't execute without a wake source. Resilience belongs to the convention layer: DONE-WHEN + polling, heartbeats, watchdogs. Upstream impact: within 24h of these findings going public, Cotal merged PR #258 — the v0.4 control surface and agent lifecycle: work pools with crash redelivery, restart supervision — per the Cotal team, a direct response to these benchmarks (in core; not yet wired to the chat plane). Superseded: the next slide replays this exact protocol on that machinery — and it heals.
Resilience · v0.4 adopted · new

Run 11 — Same kill, on their fix: the mesh heals

Rematch of Run 8 on the machinery it provoked: the task rides a real Cotal v0.4 work pool (published @cotal-ai/core 0.13.2) with our ~110-line supervisor in the pool-owner's seat (benchmark/reclaim/). Same mesh, same 0.12 chat plane, same kill. Variable isolated: the custody layer.
Lease #1 → workerb · fencing token 1
working in 9sDM'd over the ordinary chat plane — the pool holds the message unacked
workerb killed mid-task
+34sRun 8's exact protocol — but now the unsettled lease is a tripwire
ack_wait redelivery → re-lease → workerc · token 2
~2s after the killno planner, no human, no convention layer — the broker surfaces the death, the owner reassigns
workerc finishes · commit · terminal fact
✅ 122stest.py PASS → COMMITTED won=true → disposition "committed" — durable, queryable state
Run 8, healed — reassignments=1, finisher workerc, 122 seconds. The only new ingredient is the v0.4 work pool our benchmark provoked, switched on by us as its first consumer. Worker death becomes an event (redelivery), the owner re-leases with a bumped fencing token, and the outcome is durable state, not silence. Run 8 retires to pre-v0.4 baseline — and two chat-plane sharp edges hit en route (24-hour cred rot; ask-a-name role-anycast blackhole — both exit 0, both silent) only sharpen the moral: send-and-pray planes need a custody layer.
Roadmap

What we test next

Two dimensions the current studies don't cover — each is a scripted runner away.
Routing policy

Planner armed with run-4/5 latency data routes per-task vs random assignment — does informed routing measurably win?

Long-horizon tasks

Multi-file refactors with dependencies between subtasks — where planner decomposition should matter most.

capstone · head-to-head

Cotal vs our MCP servers — two different layers of delegation

Scored like competitors — every round cites the studies above

This capstone is our own service versus Cotal. The "our MCP servers" column is openrouter-subagents + gpt-subagents-subscriptionnot built for this project: they're our pre-existing open-source products, the subagent-delegation approach we already shipped and ran before the hackathon. An existing competitor to the mesh that we happen to own — scored here round-for-round on the same tasks, judged the same way.

Cotal mesh
our MCP servers · pre-existing OSS
round
Head-to-head —
same 3 tasks
3/3 · 95 sworkers execute in place — the handoff itself costs ≈ nothing (Run 3)
3/3 · 137 sgeneration at a distance — the caller transcribes the answer back (Run 3)
mesh
+30%
Parallel
throughput
3 workers · 3/3 · 203 sheterogeneous fan-out; makespan = the slowest worker (Run 6)
concurrent asksbatch calls + Fusion panels — but every answer re-enters one loop's context budget
mesh
at scale
Failover
& custody
kill → re-lease → committed 122 sv0.4 pools + fencing tokens (Run 11) · the #286 presence gap — our fix submitted upstream as PR #294
dies with its callerno roster, no supervision — retry is the caller's job; nothing standing to go stale either
only the
mesh heals
Model
reach
harness-wrapped models onlyjoining costs a product + a connector — PRs #254/#255 are that price tag, paid by us
the whole catalogmodels with no harness at all · image + video generation · Fusion panel + judge
MCP —
structural
Where the
answer lands
in the worker's workspaceexecuted in place — but in another context; results travel the chat plane
inside the caller's contextzero-loss return — built for expert consults, reviews, audit legs
split
by job
Standing
weight
broker · roster · connectors · credsa real ops surface — the 24-hour cred rotation bit us live en route to Run 11
a local server + a keynothing to spawn, rotate, or supervise between calls
MCP travels
light

The contenders in full

Cotal = a mesh of harnessesConnects agent PRODUCTS — Claude Code, Codex, OpenCode, Antigravity… — as separate peer processes with mesh identity: chat plane (dm / channel / role), spawn + supervision, v0.4 work pools. Structural limit: a model can only join the mesh if a harness wraps it AND a connector exists for that harness — exactly why we wrote connectors #254 (codex) and #255 (agy).
Our MCP servers = models inside the loopopenrouter-subagents, gpt-subagents-api, and gpt-subagents-subscription inject foreign MODELS as tool calls inside ONE harness's agent loop — no separate process, no roster entry, no mesh: delegation happens inside the calling agent's own context. A fourth repo, antigravity-openrouter-subagents, wires the OpenRouter server into Antigravity's global MCP config — the only way agy can use non-Gemini models at all.
The reach only the MCP layer has — models Cotal structurally cannot touchAny model in the full OpenRouter catalog becomes a subagent — including models with NO native harness at all (nothing to write a Cotal connector FOR), and even IMAGE and VIDEO generation models normally used only through dedicated apps and webpages. Through this server they become one tool call inside a coding agent's loop, with unified reasoning-effort control end-to-end — plus Fusion: a parallel panel of models and a judge that synthesizes one answer.
Final score 3–2, one split. Read as competitors, the mesh takes coordination — the head-to-head, the fan-out, and the only failover story on the board — while the MCP layer takes reach and weight, delegating to models a mesh structurally cannot touch. The split round is the design rule that falls out: give execution to the mesh, expertise to the loop. Complementary in the end. The benchmark itself ran on both — MCP subagents powered the foreign-model arms; the mesh powered the delegation and failover studies.
Hermetic by default

Every harness runs stock — exactly as its vendor ships it, nothing extra loaded. No arm gets outside context or added startup cost.

Validated tests

Every task judged only by its own test.py, validated against reference solutions before use.

Integrity tripwire

Runners refuse to start if benchmark templates differ from git — earned the hard way (see incident below).

Equal reasoning everywhere

Every arm at xhigh — the highest setting shared across harnesses when the studies ran. The runner now pins each harness's true ceiling (max) for future runs.

⚠ The measurement war story (why the tripwire exists)

In the first matrix, Antigravity — run without --add-dir — resolved relative paths against its own workspace and wrote its solutions into the benchmark templates themselves. Every later run copied pre-solved templates into its workdirs: a dead-on-arrival arm "passed" tasks in 10 seconds, and a spurious "native harness scores 3/7" headline nearly shipped. We caught it by autopsying impossible timings, restored templates from git, added a template-integrity tripwire to the runner, and re-ran everything hermetically. The invalidated numbers are preserved in the RESULTS appendix — the methodology story is part of the submission.

Full tables, token counts, caveats and repro commands: benchmark/RESULTS.md · Demo script: DEMO.md
Two connectors we built for this project, ported into Cotal's open-source monorepo (Cotal-AI/Cotal, connectors live under extensions/) and submitted as upstream pull requests #254 + #255 — the project gives its infrastructure back. And beyond our own connectors: #294, a five-bug fix to Cotal's opencode connector, closing community issue #286.
PR 1 · extensions/connector-codex

Codex CLI as an autonomous mesh worker

Cotal's only existing Codex integration is an unlisted npm experiment: pull-only, meaning an interactive Codex session can watch the mesh but delegation can never wake it — and it's built on connector-core 0.2.0 while the ecosystem is at 0.13.x. It isn't in the monorepo at all. This PR contributes the missing half: a worker the mesh can drive.
1 · WAKE
mesh message arrives — the shim owns the agent's presence
2 · TURN
first turn codex exec · later exec resume <threadId>
3 · TOOLS
cotal_* served to Codex over local streamable-HTTP MCP
4 · REPORT
replies + channel posts flow back through the shim
What we added

A thin Node shim that owns one MeshAgent and drives the local codex binary headlessly. The Codex thread id is the conversation state — every mesh message resumes the same thread, so the worker remembers its task across turns.

How it stays compliant

It runs whatever auth the operator's own codex login already has — ChatGPT subscription or a configured API provider. No token scraping; the connector never sees credentials, it just invokes the official CLI.

Why it's relevant

It makes ChatGPT-gated models (gpt-5.6-sol) first-class mesh workers — push delegation, not polling. That's the difference between "Codex can look at the mesh" and "the mesh can put Codex to work."

Proven before submitting

Builds in-tree against connector-core (0.13.1, rebased onto the v0.4-era tree), bundle imports clean, live mesh handoffs verified, and it carried the Codex arm through 20+ hermetic benchmark tasks (runs 5, 7, 9) without a dropped turn.

Sharp edges are documented for reviewers: Codex's default approval policy auto-cancels MCP tool calls in headless runs (the shim passes the bypass flag), and codex exec slurps an open stdin pipe (the shim closes it).
PR 2 · extensions/connector-agy

Google Antigravity as an autonomous mesh worker

For Antigravity there was nothing to extend — no connector exists anywhere in the tree. This PR adds the first one, which took reverse-understanding a young CLI: it silently drops its final answer when stdout isn't a terminal, and it only reads MCP servers from one global config file.
1 · WAKE
mesh message arrives · shim merges its MCP entry into agy's global config
2 · TURN
agy -p under a pseudo-TTY — the workaround for the stdout bug
3 · RESUME
conversation id from the agy log · --conversation on every later turn
4 · CLEANUP
MCP entry removed on stop and process exit — leave no trace
What we added

A Node shim that runs each turn as a pseudo-TTY agy -p call, captures the conversation id from the run log, and resumes it — with --add-dir grounding every file write in the task's workdir instead of agy's own scratch space.

Deliberate v1 limits

Everything fails loudly instead of degrading: one agy worker per machine (agy reads a single global MCP config), refusal to start over a stale entry, and a hard error if a resume ever forks a fresh conversation.

Why it's relevant

It unlocks Google-account models — Gemini 3.1 Pro (High), Opus 4.6 Thinking, GPT-OSS 120B — as mesh workers. Run 4 showed the native harness runs Gemini ~1.75× faster than a foreign one; this connector is how the mesh gets that speed.

Proven before submitting

Builds in-tree, imports clean, live-tested end-to-end (spawn → delegation → "AGY WORKER OK" on #general → clean stop), and posted the fastest total on the run-9 reasoning/grounding sweep.

The --add-dir grounding isn't a nicety — running agy without it is what caused the template-contamination incident in the benchmarks tab's war story. The connector ships the lesson.
PR 3 · extensions/connector-opencode · fix

Fixing #286 — dead agents that never went dark

Not our connector this time — a fix to Cotal's own opencode connector. Community issue #286 reported dead agents lingering on the roster, looking alive. The ghost ran deeper than the report: five bugs, five repairs, one commit — submitted upstream as PR #294.
1 · CLEAR
going idle clears stale activity — including the session-adoption path nobody had on the map
2 · LIFELINE
the serve watches its shim every two seconds — shim gone means publish offline, drain, exit
3 · GUARDS
a dead-pipe write can't crash the exit · a wedged broker can't hold it past ten seconds
4 · HONEST
offline rows read as dead — last seen … · was: … — never like live ones
What it fixes

A force-killed shim orphaned the opencode serve underneath — it kept heartbeating the mesh forever while the roster showed work that finished long ago. Every path that manufactured that ghost is closed.

Proven before submitting

12 files, +687/−9, one clean commit on the current 0.14.2 base. Every repair is locked by a test that fails without it, and the whole path re-ran against the real opencode binary: shim killed, offline published, clean exit.

The full anatomy — how the ghost is made, each repair, and the test evidence — is the #286 deep-dive on the project tab.
PR #254 — connector-codex

Open against Cotal-AI/Cotal: TypeScript to the monorepo's standard, one squashed commit, the pull-only relationship addressed head-on (supersede or coexist — maintainers' call).

PR #255 — connector-agy

Open against Cotal-AI/Cotal: TypeScript to the monorepo's standard, one squashed commit, the v1 fail-loud limits documented as design choices with their reasons.

PR #294 — connector-opencode fix

Open against Cotal-AI/Cotal: closes issue #286 — single commit on the v0.14.2 base, every repair test-locked, verified against the real opencode binary.

Standards pass before sending

Ported to strict TS matching sibling connectors (types, typecheck, declaration emit, changesets fixed group), verified against the CI gates (frozen lockfile, pack), and bundle-diffed against the live-tested JS — logic identical.

Why give the connectors away? Because the product (hermes-handoff) is better when the ecosystem ships them — and a benchmark-backed contribution is the strongest possible sponsor pitch.
build b5bd500 · 21:12Z · 32 scenes