How do you continue unfinished AI work in a new session?

To pick up unfinished work in a new session, or in a different AI, the state of the work has to live outside the chat. Before you close, ask the AI to write down what’s left and the next step, what was done and why, and how anything that changed now works. When the next session starts, ask it to read all of that before it touches anything.

Why the thread gets lost

An example. On Tuesday you start migrating a project’s database to a new version with an AI. Two hours in, you find that one extension isn’t compatible, you rule out upgrading it because it breaks another part of the app, and you decide to export that data separately. At seven you stop halfway.

On Thursday you open a new session, or a different AI altogether because the first one hit its limit, and type “let’s carry on with the migration”. It doesn’t know which extension it was or why you didn’t upgrade it, and it suggests exactly what you already tried. Half an hour later you’re back where you were on Tuesday at five.

The problem isn’t that the model has a bad memory. It’s that everything that mattered lived inside one conversation: each chat starts with its own context, and whatever wasn’t saved elsewhere doesn’t carry over. Some tools let you resume your last conversation, but only inside that same tool, and a long conversation isn’t a great starting point anyway: what matters gets buried under failed attempts.

What a good handoff contains

Anyone who has tried asking for an end-of-session summary ends up with a similar list:

• The goal, in one sentence. Not “the migration” but “move the database to the new version without losing the extension’s data”.
• What’s done, and how it was checked.
• What’s left.
• Decisions and why, including what was ruled out. “We’re not upgrading the extension because it breaks the reports” saves running the same test twice.
• One concrete next step. “Continue” isn’t a step; “export the extension’s table and check the row count matches” is.
• Open questions.

Keep what was verified apart from what is only assumed. If the last session concluded “it’s probably a permissions issue” without checking, that hunch shouldn’t reach the next one dressed up as a fact.

A handoff is three things, not one document

The usual fix is a handoff file the AI rewrites at the end of each session. It works, but it falls short in three ways: rewriting it throws away what was there before, it mixes what’s left with what happened, and it lives in a repository or on a clipboard that not all your AIs can read.

It works better split by what each thing is:

1. What’s left goes in an issue. A task with a status (open, in progress, in testing, done) and, in its description, the goal, what’s pending and the next step. It gets updated, so it always says where you are now.
2. What happened goes in a log. One line per action: what was done, the result and why it was decided that way. It isn’t rewritten, it only grows, so Tuesday’s reasoning is still there three months from now.
3. How things work goes in a note. If the migration changes how the project is deployed, the deployment note gets updated. That’s what will still be true once the task is closed.

The next session, whichever AI runs it, reads the issue to know what’s next, the latest log lines to know what was tried, and the note to know how things are set up.

Before you close the session

You don’t have to write it yourself: ask the AI while it still has the full context. For example:

Before we stop: update this task’s issue with what’s still pending and one concrete next step. Add a line to its log with what we did today, what we tried that didn’t work, and why. If anything about how the system works has changed, update the note. Keep what we’ve verified apart from what we’re only assuming.

Do it before the conversation gets too long, not once it has already started to drift, and read what it wrote. Two minutes of review beat half an hour of rebuilding.

When the next session starts

How you start matters as much as how you finish. An AI that acts before reading the handoff repeats mistakes. Something like:

We’re picking up the issue “Migrate the database”. Read all of it, read the latest lines of its log and the linked note, and tell me in three sentences where we left off and what the next step is. Don’t change anything yet.

If its summary doesn’t match what you remember, fix it before going on. And check that the state is still true: someone may have changed something between sessions.

How md-doc handles it

You can do all of this with files and discipline; md-doc makes it easier, not mandatory. What it adds is that all three pieces live in one place any connected AI can read and write:

• Issues have the statuses open, in_progress, test and done, and the AI finds and updates them over MCP with issues_search, issues_get and issues_update. The server’s rules tell it to set in_progress when it starts and test when it finishes, and not to mark anything done it hasn’t verified.
• In logs the AI can only add lines with log_append: it can’t edit or delete earlier ones, and a log can’t be deleted. At the start of a session, log_get returns the latest lines.
• Notes hold the current state in Markdown, and link to each other and to issues and logs with chips such as $[issue:7:Migrate the database].

Because all your AIs connect to the same MCP server, it doesn’t matter which one carries on: what Claude left on Tuesday, ChatGPT or a local model reads on Thursday. And if a teammate is the one picking it up, you can share the issue folder and the log folder with their account once they accept your friend invitation.

If what you need isn’t to pick up where you left off, but for several AIs to work on the same thing at once, read Connect multiple AI assistants.

One place for all your AIs

When work moves to another session, another AI or another person, its context shouldn’t stay behind in the chat where it started. If what’s left, what happened and how things work sit in one place all your AIs can reach, resuming stops being rebuilding: the next session starts where the last one ended.