Handoffs

A handoff happens when work continues outside the agent session that originally started it.

This may be a new conversation with the same coding agent, a different coding agent, or simply a return to the project later.

Istok keeps the useful state of the work with the project so the next session does not have to reconstruct everything from chat history.

Work outlives a conversation

Coding-agent sessions are temporary.

A task may not be.

Consider a feature that takes several hours to implement. During the work, the agent may discover constraints, make decisions, record progress, run checks, or encounter blockers.

If all of that exists only in the conversation, starting a new session means that important context may need to be explained again.

With Istok, durable work state remains attached to the project and task.

What can be carried forward

A later session can inspect information such as:

• the task and its goal;
• acceptance criteria;
• recorded progress;
• decisions and blockers;
• task dependencies;
• relevant project context;
• previous runs;
• validation results.

Repository context can also be retrieved again for the current state of the codebase.

Together, this gives the next agent a useful starting point without requiring the entire previous conversation.

Continuing in a new session

Suppose you ask an agent to implement a feature but stop the session before the work is complete.

Later, you start a fresh session in the same repository.

Instead of reproducing the previous conversation, you can simply ask the agent to continue:

Continue the unfinished authentication work.

An agent configured to use Istok can inspect the project, find the relevant task, review its state, and continue from there.

Conceptually:

Session A
   │
   ├── task
   ├── progress
   ├── context
   ├── run
   └── validation
         │
         ▼
       Istok
         │
         ▼
Session B

The conversation changes. The durable project state does not.

Moving between agents

The same model works when the next session uses a different coding agent.

For example:

Codex
   ↓
Istok project state
   ↓
Claude Code

or:

Claude Code
   ↓
Istok project state
   ↓
Cursor

The agents do not need to share conversation history with each other.

They share the project state exposed through Istok.

Fresh context for new work

A handoff does not mean blindly replaying an old context window.

Previous task state and execution history remain available, while the next attempt can retrieve context relevant to the repository as it exists now.

This is important because the codebase may have changed between attempts.

The durable history explains what happened before. Fresh retrieval helps the agent understand what it is working with now.

Previous attempts remain useful

If an earlier attempt was interrupted or unsuccessful, it still provides useful information.

Its progress, execution history, and validation results can help the next agent avoid repeating work or understand why an approach failed.

A new attempt can then continue the same task without erasing what happened before.

You do not need to prepare a handoff manually

When Istok is used throughout the workflow, the useful handoff state is created as the agent works.

You do not need to write a separate handoff document after every session.

The agent should keep meaningful task progress, decisions, blockers, and validation in Istok so that later work can inspect them directly.

This keeps the durable state close to the work instead of scattering it across temporary notes.

The result

Istok does not make agent sessions permanent.

It makes the work independent of them.

A conversation can end, a different agent can take over, or the project can sit untouched for a while. The task, its context, execution history, and validation remain available when work resumes.