---
title: 'Codex stops, Claude carries on: handing over a task with no handoff file'
description: An agent that stops notes what it ruled out, and the next one gets that note when it claims the task. Two handoffs from Codex to Claude, word for word.
url: https://hamloy.com/blog/handoffs-between-agents
---

[Blog](https://hamloy.com/blog)

# Codex stops, Claude carries on: handing over a task with no handoff file

An agent that stops notes what it ruled out, and the next one gets that note when it claims the task. Two handoffs from Codex to Claude, word for word.

11 October 2026 · Rahmakyan

When you stop an agent halfway through a task, what it learned usually goes with it. The next agent, maybe Claude on a colleague's computer, starts from zero and walks into the same dead end. In Hamloy, the agent that stops writes down what it did and ruled out, under the task. The next agent to claim the task gets that note in the claim's reply, before it touches the code.

Below are two handoffs from Codex to Claude in Hamloy's own test runs, on a scratch project shared by two people, Sam and Dana. The replies are word for word.

## Codex rules out a package, Claude never tries it

Sam asked Codex to start on "Recipe search ignores accents" and leave it for Claude. The host the app runs on allows only Python's standard library. Codex claimed the task, wrote what it found under it, and let go:

```
• Called hamloy.edit({"key":"B-xlyo@1","add_note":"Started investigation. The previously attempted unidecode dependency cannot be used because the host permits only the Python standard library. Next assistant (Claude on Dana's computer) should implement accent folding with a standard-library approach (likely unicodedata.normalize plus removal of combining marks) …"})
  └ B-xlyo@3 Recipe search ignores accents (creme finds Crème brûlée) (claimed by this session)
      Implement accent-insensitive recipe search using only the Python standard library; unidecode is unavailable.

• Called hamloy.claim({"key":"B-xlyo@3","release":true})
  └ B-xlyo released
```

On Dana's computer, Claude Code was asked to finish "the accent search task". Its first look at the lists found the task, with Codex's one-line summary under it:

```
⏺ hamloy - See the lists (MCP)(find: "accent")
  ⎿ [] B-xlyo@3 Recipe search ignores accents (creme finds Crème brûlée)
        Implement accent-insensitive recipe search using only the Python standard library; unidecode is unavailable.
```

It claimed the task and wrote a `fold()` with `unicodedata`: decompose the letters, drop the accents, case-fold. `unidecode` never came up. Nobody pasted a summary into the chat, and nobody wrote a handoff file.

## The claim says who had the task before

The second task was "Make recipe search faster". Sam's Codex profiled it and found that `unicodedata.normalize` runs for every recipe on every query. It also ruled out the obvious fix, caching `search()`, because recipes are added while the app runs, so a cached result goes stale. Then Sam told it to stop. It wrote that down and let go.

On another computer, Claude Code was asked to "make recipe search faster". Its claim came back with the history attached:

```
⏺ hamloy - Claim an item (MCP)(key: "B-a8v7")
  ⎿ B-a8v7@3 claimed by this session (Noor's claude)
    before you: Sam's codex had it until 3m ago and let it go, noting: "Started investigation only; no code changed. Ruled out functools.lru_cache for search() because RECIPES changes while t…" (in full: list B-a8v7)
```

Claude read `search.py` and said:

```
The notes say the hot spot is `fold()` running on every recipe name for every query.
`fold` is a pure function of its string, so caching it can't go stale even when
`RECIPES` changes. I'll cache `fold` itself rather than `search`.
```

It put `functools.lru_cache(maxsize=1024)` on `fold()`, bounded so odd queries can't grow memory forever. Then it told the person why it didn't cache `search()`: "the earlier note ruled out caching `search()` because `RECIPES` can change while the app runs." Codex's dead end cost Claude nothing.

## What the "before you" line holds

Whenever an agent claims a task another session had, Hamloy adds one line to the reply. It's built from the task's history, so nobody has to write it:

- **who** had it: "Sam's codex", or "your earlier session" after a restart
- **how it ended** : let it go, went quiet, ended its session, or ticked it before someone opened it again
- **their notes**
- **the files they edited** , and the branch, when the [hamloy program](https://hamloy.com/docs/the-program) saw them

Most of the line is there even if the last agent wrote nothing. The note is what makes it worth reading.

In the run above the line quoted the start of Codex's note and said where to read the rest. Since then the claim brings the task's summary and notes themselves, the first time a session claims it, so the next agent reads them without opening the task. The same claim today reads like this:

```
B-a8v7@3 "Make recipe search faster" claimed by this session (Noor's claude)
before you: Sam's codex had it until 3m ago and let it go, noting what it did (below)
if you stop before it's done, even when told to stop now, note what you did and ruled out (edit's add_note) and release it; once it's done, tick it with what you did as its note, in that one call
Summary: unicodedata.normalize runs for every recipe on every query
Its notes:
  Started investigation only; no code changed. Ruled out functools.lru_cache for search() because RECIPES changes while the app runs, so a cached result goes stale.
```

## Getting the leaving agent to write it down

A handoff is only as good as the note. In our first runs, Codex told "stop now" did exactly that: it stopped, said "I stopped without changing anything", and left nothing behind. So every claim's reply now ends with what to do when stopping:

```
if you stop before it's done, even when told to stop now, note what you did and ruled out (edit's add_note) and release it
```

After that change, Codex noted the dead end and released the task, both when it was told to hand over and when it was only told to stop. An agent that lets go without a note is reminded once more, in the release's reply:

```
note: you left no note under it; if you found or ruled anything out, add it (edit's add_note), so whoever takes it next doesn't redo it
```

## Getting the next agent to look first

The claim reply works when the next agent claims the task. But an agent asked to "make recipe search faster" might start reading code before it looks at the list at all. Claude Code and Codex with the hamloy program are reminded when a session starts. An app connected over plain MCP gets only the server's instructions, so their second sentence now says it:

```
Before you start on what the person asks, look for it with the list tool (find: two or three of its words): whoever had it may have noted what they tried and ruled out.
```

We connected Claude Code on Haiku without the program and asked it to "make recipe search faster". With that sentence, it looked the task up first in 3 of 4 runs, against 0 of 2 before. It read the note and stayed off the stale cache. Codex did the same.

## Why not a HANDOFF.md

A handoff file in the repo works when one person runs one agent at a time on one branch. It stops working when the next agent is on another computer, in another worktree, or belongs to someone else. It also only helps if the next agent knows to open it.

The note under the task travels with the task. It reaches whoever picks the task up, on any computer, in any app that speaks MCP, and it arrives in the reply they were going to read anyway.

Read more in [Claims](https://hamloy.com/docs/claims), or about two sessions that shouldn't share a task in [Three Claude Code sessions, no two on the same task](https://hamloy.com/blog/no-two-sessions-on-one-task).