Make Your AI Agent Replaceable

Adam Schoenfeld shared a screenshot of an AI usage limit and explained that he now switched to Codex when that happened. It made me look at my own setup: could another agent use the work I had already built?

My files were local and backed by GitHub. My project briefs recorded status, next actions, and a running log. Even Claude’s project memory was stored in plain Markdown files. I already had much of what a second agent would need.

What I lacked was a clear way in. Some projects had instructions for Claude, but there was no shared starting point for another agent. I had not installed Codex yet.

The work was to connect those pieces: give the next agent the same rules, point it to the existing notes, and show it how to reach my tools.

Save what the next agent will need

A folder full of files does not explain itself. The next agent needs to know which files matter, what I have decided, and where the work stopped.

The plan built on the records I already kept. The briefs held the work’s status; the memory files held useful background. Shared instructions would tell the next agent where to read them. Together, the setup needs:

• Project instructions: what the folders contain, how to run and check the work, and which actions need my approval.
• Project notes: decisions, useful background, and failed attempts worth remembering.
• A tooling map: how I reach each service, including which connections need their own setup.
• A handoff note: what is done, what was checked, what remains, and which branch holds the work.

The notes do not all have to move. A memory file can be plain text and still be hard to find because it sits in one tool’s folder. An explicit path in the shared instructions gives the next agent a place to start.

Let both agents read the same rules

My Claude Code setup uses CLAUDE.md for project instructions. Codex uses AGENTS.md. Two copies would give me two places to make every correction, and a chance to forget one.

I connected the names with a symlink, a pointer from one file to another. In my project folder on macOS, with CLAUDE.md already present and no AGENTS.md, I ran:

ln -s CLAUDE.md AGENTS.md

Now an edit to CLAUDE.md is also what Codex reads through AGENTS.md. The pointer keeps the rules together. It does not move a conversation or set up an account.

I keep approval rules in that file too. Sending email, spending money, and changing the instructions themselves need my say-so. Sharing the rules is only useful if the next agent follows them.

Give the second agent a real task

Claude proposed a simple first check: open Codex in the working folder and ask it to read the shared instructions.

“Read AGENTS.md and tell me the working agreements.”

The answer should show that it found the approval rules, project notes, and handoff convention. Then give it one small task and check the result. Repeating rules is one test; following them while working is another.

The choice of agent follows from that task. I wanted one that could work with my existing local files and tools. An agent that takes a separate copy of a repository and returns a pull request may be useful for other work, but it would not have the same access to my unfinished local work.

The prospect of losing a familiar agent brought Flowers for Algernon to mind: remembering an ability you can no longer use. The more hopeful reference, for a fellow My Hero Academia fan, was “Plus Ultra.” I wanted a way to keep going.

“But I can’t do it” → “Go beyond.”

Check what you still have to reconnect

Much of my tool access already ran through command-line tools and scripts. The second agent could use those too, with the right access. Other parts of the handoff needed separate attention:

• Chats: a handoff note carries the useful state, not the full conversation.
• Connected accounts: the second agent may need its own logins and permissions.
• Scheduled jobs: tasks running inside one app need to be set up in the other if I want to move them.
• Judgment: the same instructions do not make two models behave alike. I still review the work.

If you want to try this, choose one project. Write down enough for a fresh agent to finish one small task, then let it try. What it misses will show you what to add.

If you have found a better way to make that handoff, I would like to hear it.

Working with several agents brought another problem: each new worktree unpacked a large screenshot archive. Here is how sparse checkout kept those copies smaller.