How to hand off a task between Claude Code, Codex and Cursor

Why the next agent starts from nothing

Each agent keeps its sessions in its own place, in its own format, and none of them reads the others'. Resuming works only inside the same tool.

What does cross over is what is in the repo. Codex and Cursor read AGENTS.md, and Claude Code reads it through a one-line @AGENTS.md import in CLAUDE.md (see AGENTS.md vs CLAUDE.md). That carries your rules. It does not carry the task you were halfway through.

The free way: a HANDOFF.md

Before you switch, tell the agent: “Write HANDOFF.md for the next agent: the goal, what is done, what is next, what we decided and why, and anything open.” Read it before you leave. The agent wrote it from memory, and that is where it goes wrong.

# Handoff

Goal: what the task is for, in one sentence.
Done: what works now, with the files touched.
Next: the very next step.
Decided: choices made, and the ones rejected with why.
Open: questions, failing tests, anything half done.
Git: branch, last commit, and whether it is pushed.

Then open the other agent in the same folder and say “read HANDOFF.md and carry on from Next”. Three habits make it hold:

• Let git carry the code. Commit or at least stage before you switch. A note that says “done” next to a diff that says otherwise sends the next agent the wrong way.
• Write down what you rejected. The next agent will otherwise try the approach you already ruled out.
• Keep it out of the rules. A handoff is about one task and goes stale in a day. Add HANDOFF.md to .gitignore, and move anything that should hold for every task into AGENTS.md.

Should I compact or hand off?

Compacting keeps you in the same agent and the same session: it shrinks the conversation so you can keep going. A handoff is for when you leave the session, to another agent, a fresh session, or a teammate. If you are switching tools anyway, write the note first. A summary written while the agent still has the whole session in view is better than one written after compaction.

Handing the task to a teammate

The same note works, with one more step: push. A teammate cannot see files you have not committed or commits you have not pushed, so put the branch name in the note and push it, even as a work-in-progress commit. Pasting the note into the pull request description keeps it next to the code.

Tools that do the handoff for you

A few open-source tools read one agent's session and write the note or the prompt for the next. As their own listings describe them, on 12 November 2026:

Codex also has /import, which copies a Claude Code or Cursor setup across once (instructions and project memories). It moves your setup, not the task in flight (see Codex memories).

With Harbor: say handoff, then handoff pick

Harbor has handoffs built in for Claude Code, Codex, Cursor and GitHub Copilot. Type handoff where you stop. The agent writes the note in its reply, so you see it, and Harbor reads the branch, the commit, the uncommitted files and the commits not pushed from git itself. Open any agent in the same repo and type handoff pick, and it carries on from the next step. A handoff belongs to the repo, not the branch.

• Forgot to save one? continue from claude (or codex, cursor, copilot) picks up that agent's last session in this repo on the same machine.
• To a teammate: handoff @dana. Their agent fetches your branch, and asks first if they have uncommitted changes. If you have work they cannot see yet, the agent offers to push it.
• How long: yours waits 72 hours, a teammate's 7 days, and every handoff is deleted after 90 days.

The full list of words is in the Handoffs docs. Harbor is shared memory for AI coding agents, and handoffs run on the hooks it already installs.