Codex Thread Handoff Skill

Since I’ve been working with AI agentic tools, and especially since I’ve been working on the various incarnations of my own agent harness, there is something that is very clear to me.

One of the most powerful things you can give an AI is the power of reflection.

Not in the mystical sense. I don’t mean introspection or consciousness or anything like that. I mean the boring useful version: the ability to inspect and work with the app it is living in.

That is why tools matter. That is why skills matter. The assistant becomes much more useful when it can look at the world around it and act on that world directly.

And recently I noticed a funny new version of that in Codex, now it can manage its own threads!

The App As A Tool

In the Codex app the LLM has tools to create threads, list them, and work with them in a myriad of ways. But the important part is not the list of operations. The important part is that the agent can use those operations from inside the conversation.

You can ask it to create a new thread. It does.

You can ask it to send context to another thread. It does.

The most interesting thing this unlocks is that you can ask it to continue somewhere else, and it can actually move the work there.

Handoffs

This becomes immediately useful for handoffs.

I first saw the idea of a handoff skill from the famous Matt Pocock’s skills repo. The basic version is very simple: when a conversation is getting too long, or when the next step deserves a clean context, ask the agent to write a compact handoff containing what the next session should focus on, what already happened and a few other details.

That original skill writes that to a temporary Markdown file. And that is already useful. Much better than scrolling through a giant conversation and trying to manually copy the right bits.

But in Codex we can give the skill a better ending.

If I ask for a normal handoff, it can still write the temp file.

But if I ask to continue in a new Codex thread, it can skip the file and create the new thread directly, using the handoff as the initial prompt.

That is a tiny change, but it changes the feel of the workflow completely.

You can grab the full skill from the Gist Codex handoff skill (thread-aware continuation), but as always, I recommend reading it, learning from it, and cooking one for yourself.

The Nice Bit

The nice bit is not only that it saves copy-paste, although it does. The nice bit is that the handoff becomes a visible action, not just a document in some obscure path.

I can be in one conversation, realize that the next step belongs somewhere cleaner, and ask Codex to hand it off. Then I see the new thread appear in the sidebar. The new thread indicates that it was created from another thread, which is also surprisingly useful. You can trace where the work came from instead of ending up with a bunch of disconnected conversations that all look like they started from nowhere.

And yes, there is a little magic moment when the thread appears in the UI.

Small Tools, Big Leverage

This is why I keep caring about the harness around the model much more than the model itself.

The AI did not suddenly become smarter because it can create a thread. But it gained a new surface to act on. It can inspect and shape the place where the work is happening.

That is what I want from these tools. Powerful tools and reflection to let the assistant work with the environment it is already inside.