Examples
Worked examples of continuing the same work in a different AI. Each is the same shape — push → hand off → catch up → update — with the real commands. The URL carries the content, the history, and the instructions for whatever picks it up next.
Click-family tools (ChatGPT, Gemini, Grok) read a URL and use one-click links instead of curl; direct tools (Claude Code, Cursor, CLI, MCP) run the loop autonomously. See the compatibility matrix.
You scaffold a feature in Claude Code tonight and continue it in Cursor tomorrow — without re-explaining the task.
Claude Code pushes the work-in-progress with a note for the next tool:
$ npx wrfi push src/auth.ts \
--message "scaffolded login; TODO: refresh-token rotation"
→ wr.fi/x7k2 · edit token Blue-CastleNext day, Cursor reads the handoff — content, history, and how to continue, in one call:
GET wr.fi/x7k2?h → ## Task: scaffolded login; TODO: refresh-token rotation → ## Content … ## History … ## To continue (update instructions)
Cursor makes changes and writes back safely — a conflict is a 409, never a silent overwrite:
$ npx wrfi update x7k2 src/auth.ts \
--token Blue-Castle --expected-version 1Result: Same URL, full version history, and Cursor never re-read the whole repo to know where you left off.
ChatGPT gathers sources and drafts a brief; Claude picks it up and writes the analysis — across two vendors, no copy-paste.
ChatGPT can't POST from its sandbox (see the matrix), so it prepares a prefilled publish link — you click it, review, and publish in the browser:
ChatGPT: "I've prepared the brief — open this link to publish:" https://wr.fi/u#BASE64_JSON=eyJ0aXRsZSI6IkF1dGgg… → you review the prefilled form, press Publish → https://wr.fi/9fq2 · edit token Reed-Harbor
In Claude: “read wr.fi/9fq2 and continue” — it fetches the handoff view and sees the brief + the ask:
GET wr.fi/9fq2?h
Claude writes the analysis and updates the same URL:
$ npx wrfi update 9fq2 analysis.md --token Reed-Harbor
Result: The research context moved between closed ecosystems as one URL, with provenance on who produced what.
One agent produces a change; another reviews it and accepts or requests changes — an explicit loop, not a lossy chat.
The builder pushes the change and marks it open for review:
POST https://wr.fi/api/p
{ "title": "Add rate limiter", "content": "…diff…",
"handoffMessage": "please review the token-bucket impl",
"status": "open" }The reviewer reads ?h, then records a decision:
POST https://wr.fi/api/relays/x7k2/accept
{ "action": "reject", "note": "add a test for the burst case",
"expectedVersion": 1 }
→ status: needs-humanThe builder catches up on just the verdict, fixes, and re-submits:
GET wr.fi/x7k2?h&since=1 → Review: reject by reviewer — "add a test for the burst case"
Result: The review decision is recorded on the relay (accept → done, reject → needs-human), bound to the exact version — auditable, not buried in a transcript.
An architecture decision evolves over days and sessions. Each session adds context; nobody loses the thread.
Push the draft decision record:
$ npx wrfi push adr-001-datastore.md --message "draft: SQLite vs Postgres"
Each later session catches up on what changed, then appends — append never conflicts, so parallel notes are safe:
$ npx wrfi read a028 --since 3 --summary $ npx wrfi append a028 "Decision: SQLite. Rationale: read-heavy, single-file backup."
Anyone reads the full decision and its timeline:
GET wr.fi/a028 # the current decision GET wr.fi/a028/history # every version, who + when
Result: The decision, its rationale, and who-changed-what live in one URL — days of thinking, resumable and attributable.
A CI run fails. Instead of a wall of logs in a channel, the CI agent hands a resumable debugging bundle to a human.
CI pushes the failure bundle and flags it for a person:
POST https://wr.fi/api/p
{ "title": "CI fail: flaky auth test", "content": "…logs + repro steps…",
"handoffMessage": "test_refresh_token flakes ~1/5; repro inside",
"status": "needs-human" }
→ https://wr.fi/k3npCI posts just the URL to Slack. The human opens it and sees the logs, the repro, and the ask — no context reconstruction.
The human fixes it and marks the handoff done:
POST https://wr.fi/api/relays/k3np/accept { "action": "accept" }
→ status: doneResult: A CI failure becomes a shareable, resumable handoff — logs, a repro, and what's needed — flagged needs-human until a person picks it up.
Not just code: an analyst drafts a policy brief with one AI; a colleague reviews and edits it in the browser — no AI tools installed; the analyst's next session picks up exactly what the human changed.
The analyst publishes the draft (via the prefilled link their AI prepared) and flags it for human review:
https://wr.fi/u#BASE64_JSON=… → review, press Publish → wr.fi/p4lc · status: needs-human → send the reviewer: wr.fi/p4lc/u?edit=Cedar-Lamp
The reviewer opens that link in a browser, edits the brief directly, and saves — no account, no AI tools, no setup:
wr.fi/p4lc/u?edit=Cedar-Lamp → edit in the browser → Save → v3 — human edit
The analyst's next AI session catches up on exactly what the human changed:
GET wr.fi/p4lc?h&since=2 → v3 "human edit" — diff +9/−4 (scope section tightened)
Result: A document moved AI → human → AI with the human editing in a plain browser tab — and the next session read only the human's diff, not the whole document.