Loom · the super harness
Any harness picks up any session.
Each agent app keeps its sessions to itself: its own transcript, its own tools, its own resume button. Loom moves the session down into the operating system, so Claude, Codex, pi, Antigravity and OpenClaw all work from one ledger the OS owns. Any of them can see what the others are doing, live, and eventually take over where another one stopped.
P0 ingest · liveP1 presence · built and testedP2 takeover · next
- Claude Code
- Claude Desktop
- Codex CLI
- Codex Desktop
- pi
- Antigravity
- OpenClaw (ingested)
Why
Every harness is good at something. None of them should own your work.
Claude plans and reviews well. Codex grinds through long mechanical refactors. Gemini reads huge contexts. OpenClaw runs long, scheduled, channel-facing work. Today, choosing one means abandoning the context you built in another. Loom removes the choice: the work lives in the OS, and the apps are interchangeable views of it.
The portable session
A thread is an OS object: an append-only event ledger, the worktree it changes, and a lease that says who is driving.
One adapter per harness
A shuttle carries a thread into or out of one harness. It reads that harness's native format and writes the canonical schema, and later the reverse.
The handoff packet
When a harness takes over, it gets a compiled baton, not a raw transcript: goal, plan, decisions, what was tried and failed, and the state of the world.
Architecture
A mesh with no hub.
Pairing five harnesses directly takes twenty translators, and each one breaks whenever either side changes its format. Loom pairs them through one canonical schema instead. A pair works if both shuttles pass the same round-trip test, so five certifications cover every pairing.
- Loom never runs on a harness. It doesn't spawn Claude Code, Codex, pi or OpenClaw to do its own work. Uninstall any one of them and Loom keeps working for the rest.
- The schema is ours. It borrows vocabulary where it fits, but no vendor's format is the canonical one.
- Read-only first. Ingest tails each harness's own session files and lifecycle hooks. Nothing in a harness's store is modified to make Loom work.
What moves
Record effects, not tool calls.
Claude's Edit, Codex's apply_patch and pi's edit are different tools with the same result. The ledger records the result: "this file changed by this diff", "this command ran and exited 1, with this output". Effects mean the same thing in every harness, so they survive a handoff intact.
| Layer of a session | What it holds | Moves between harnesses? |
|---|---|---|
| Intent | Goal, plan, decisions, open questions, and what was tried and failed | fully the most valuable layer |
| World | Worktree, diff, running processes, terminals, test state | by construction because the OS owns it, not the app |
| Transcript | Messages and tool calls | translated foreign tool calls become text summaries |
| Model internals | KV cache, thinking signatures, encrypted reasoning | never dropped on purpose; the baton replaces them |
Presence · P1
Every harness is a lens on every thread.
Loom's MCP server and lifecycle hooks are registered into each harness's own configuration on every rebuild, without touching anything else there. From inside any of them, an agent can list live threads across all five, read one, search all of them, and watch one as it happens.
- loom_list threads across harnesses, with who is mid-turn right now.
- loom_read and loom_search over every harness's history.
- loom_watch long-polls a thread, so one harness follows another live. In testing, Codex followed a Claude session turn by turn.
- loom_post leaves a note for the driver. Notes are stored now and delivered into the driver's next turn in P2.
tool loom_list() claude-code release-gate review ● mid-turn codex sim tool in rust idle pi flaky test triage idle tool loom_watch(thread, cursor) ✓ turn started ✓ file-change modules/desktop/bar.nix +12 −3 ✓ command nix build .#checks exit 1 ✓ turn ended tool loom_post(thread, note) → "the check fails on the lock, not your diff"
Demo data. Tool names as shipped.
Safety
A super harness makes injection worse, unless it's designed in.
A thread that browsed the web carries untrusted text. Handing it to a harness with more authority would launder that text into a privileged context. Loom is built to stop that.
Untrusted text stays quoted.
Everything that neither you nor a model wrote (web pages, tool output, relayed chat) is marked untrusted and quoted as data when another harness reads it. It is never promoted to an instruction.
Chat-facing agents can't read everything.
OpenClaw's agents answer chat channels. A tool that reads every transcript on the machine would hand any prompt injection there your whole history, so OpenClaw sessions are ingested and linked but never given Loom's MCP server.
Leases prevent two writers.
A thread has exactly one driver and any number of watchers. Only the driver writes to the worktree. Handing off means transferring the lease at a turn boundary.
The ledger stays on the machine.
Full transcripts, including client work, never sync to shared memory. Shared memory holds curated knowledge, never transcripts.
Roadmap
Every phase lands for all five at once.
No phase finishes with a favored pair. The mesh is the goal, so each step ships for every harness or not at all.
Schema and timeline
Canonical schema, the ledger, read-only ingest for all five, and one searchable timeline.
livePresence
MCP server and turn hooks in every harness. Any harness watches any thread live.
built · testedTakeover
Leases, the baton compiler, native sessions written into each app, and a "continue in…" hotkey.
nextHot attach
The same running agent driven from several UIs where a harness allows it, and your phone as a lens.
plannedAutonomy
Relay policies that pass the lease at phase boundaries, and a cross-vendor shadow reviewer.
plannedWhat it makes possible
Ideas that only work when the OS owns the session.
"Continue in…"
One keystroke on any agent window offers Continue in Codex · Claude · pi · Antigravity. The next app opens on the same thread, in its own sidebar, with a baton.
Fork the world, not the chat
A filesystem snapshot at every turn boundary means any harness can start from any turn of any other, with the files as they were then. Time travel and A/B across models.
Negative knowledge
Batons carry what was tried and failed, and why: the thing every handoff loses today. The full history stays one loom_read away.
Relay mode
Plan in Claude, implement in Codex, hand back to Claude to review, with the lease passed automatically at each phase boundary.
Shadow reviewer
A watcher from a different lab runs alongside a live thread on a cheap model and posts critiques: "you already tried this at turn 6."
One timeline
Before any handoff works, ingest alone answers "where did I solve this, in Codex or in Claude?" across every harness.
Independence from any one vendor's harness.
Loom is written in Rust, stores its ledger in SQLite, and is declared in NixOS like the rest of ALINA, so it lands on a teammate's laptop the same way it runs here. Its source is private for now.