Keep a Task List Between Claude Code Sessions

To keep a task list between Claude Code sessions, store the work outside the chat in a durable system that every new session can read and update. Keep the goal, current state, decisions, dependencies and proof together so the next session can continue without reconstructing the project from memory.

A chat transcript is useful evidence, but it is a poor task list. It mixes discussion with decisions, grows without structure and belongs to one session. A durable task record should survive when the model changes, the context window closes or another agent takes over.

What the task list needs to remember

Each task should answer six questions:

What outcome is wanted? Describe the change a person should be able to observe.
What is in and out of scope? Stop a new session from expanding the job by accident.
What state is the work in? Use a small set such as backlog, ready, in progress, waiting for review and done.
Who owns it now? A person or agent should be visibly responsible for the next action.
What has already been decided? Record accepted choices so the next session does not reopen them.
What proves completion? Link the pull request, document, test output or published page.

The task list should hold these facts directly. Do not make the next Claude Code session search several transcripts to work out which sentence was the final decision.

A simple file-based method

You can do this without another product. Put a short project file in the repository, such as AGENT_WORK.md, and make every session read it before starting.

For each task, record:

The desired outcome.
The current owner and status.
Constraints and decisions.
The next concrete action.
Links to the branch, commit or pull request.
The checks that must pass before the task is done.

At the end of a session, update the file before closing the terminal. At the beginning of the next session, ask Claude Code to read the file and confirm the next action. This works well for one person and one repository.

The tradeoff is maintenance. A file has no live claim, inbox or automatic history. Two agents can edit it at once, and a finished pull request does not update the task unless someone remembers to do it.

Use a shared board when several agents are involved

Once Claude Code, Codex or other agents work in parallel, give them one shared task system instead of separate memory files. The board should let an agent claim a task, write progress back to it, attach evidence and ask a person for a decision without changing the task's meaning.

The important part is not the visual columns. The important part is that every agent reads and updates the same record. A new session should be able to answer “What is ready, what is already taken and what needs a person?” before touching the repository.

The ecco board is built for that loop. Claude Code and other MCP agents connect to the same board, claim one task at a time and leave the decisions and proof on the task. Connect Claude Code to an ecco board, then ask it what is ready before giving it new instructions.

For a broader comparison with keeping work inside one assistant, see the ecco board versus Claude and ChatGPT on their own.

A handoff prompt for the next session

Whether you use a file or a board, start the next session with a bounded instruction:

Read the current project instructions and task record first.
Summarize the outcome, accepted decisions, current evidence and next action.
Do not reopen settled decisions or start work already owned by another agent.
Then continue the highest-priority ready task.

This prompt works because the durable record contains the facts. The prompt itself does not have to carry the whole project.

Frequently asked questions

Does Claude Code remember tasks between sessions automatically?

Do not rely on a new session reconstructing the complete task state automatically. Put the current outcome, decisions and next action in a repository file or shared board that the session is instructed to read.

Is a Markdown task file enough?

It is often enough for one person and one agent working sequentially. Use a shared board when several agents need exclusive ownership, a common status view, decision requests or evidence that stays attached to each task.

What should I save from the previous session?

Save the outcome, scope, accepted decisions, unresolved questions, current branch or artifact, checks already run and the exact next action. Avoid copying the whole transcript when a short structured record says what matters.

Can Claude Code and Codex share the same task list?

Yes. They can read the same repository file, but a board they can both update over MCP adds ownership and conflict protection. The durable record should belong to the project, not to either agent.

The rule to keep

Sessions are temporary; project state is not. Put the work somewhere every future agent can read, keep decisions beside the task they affect and require proof before “done.”