Multiplatform Context Handoff

AI coding tools are getting better at writing code.

But when I started moving work across Claude Code, Codex CLI, Antigravity, and ChatGPT, I kept running into a less glamorous problem:

the implementation might continue, but the working context often does not.

A session can end with useful information scattered across many places:

• what the original goal was
• which repository was the source
• which repository should receive the next task
• what files changed
• which commands passed
• what should not be touched
• what assumptions were made
• which tool-specific logs or transcripts matter
• what the next agent should inspect before editing

This lab note is a record of my attempt to treat that problem not as a memory problem, but as a handoff protocol problem.

What I tested

I tested a workflow for preserving AI coding session context across different environments.

The environments I cared about were:

• ChatGPT for strategy, review, prompt design, and synthesis
• Claude Code for repository-aware implementation
• Codex CLI for code generation, verification, and command-line work
• Antigravity for IDE-style agentic execution
• GitHub and Markdown as the durable source of truth

The experiment was not about finding one perfect AI coding tool.

It was about asking a more operational question:

When work moves from one agent or repository to another, what minimum context should survive?

Why it mattered

In a single short session, context loss is annoying but manageable.

In a longer project, it becomes riskier.

The next agent may not know:

• which repo state is current
• whether a change was already verified
• which files were intentionally left untouched
• whether a previous instruction was a hard constraint or just a suggestion
• whether a generated artifact is safe to commit
• whether a tool’s transcript is complete, partial, or experimental

That is especially important for AI coding workflows because agents are very good at continuing confidently.

Confidence is useful when the context is correct.

It becomes dangerous when the context is incomplete.

Initial hypothesis

My hypothesis was:

AI coding handoff should not be treated as a loose chat summary. It should be treated as a structured operating artifact.

A good handoff artifact should include at least:

• project and repo identity
• source and target paths
• current goal
• completed work
• changed files
• verification results
• known risks
• explicit “do not touch” boundaries
• relevant assistant/session metadata
• next recommended action
• review and safety warnings

This is different from a normal summary.

A summary helps a human understand what happened.

A handoff brief helps the next agent continue without breaking things.

What worked

The biggest improvement came from making the handoff explicit.

Instead of starting the next session with a vague instruction like:

Continue from the previous work.

I could start with a structured brief:

• inspect the current repo state first
• do not assume the previous agent finished correctly
• only modify files within the approved scope
• preserve public/private boundaries
• run the expected verification commands
• report changed files, risks, and assumptions

That small change made the workflow feel less like “asking another AI to continue” and more like passing a task between operators.

It also made review easier.

When the next agent reported back, I could compare the result against the handoff artifact instead of relying only on memory.

What did not fully work

The hard part is that each assistant environment stores session context differently.

Claude Code, Codex CLI, and Antigravity do not expose the same transcript format or the same session metadata.

Some formats are relatively straightforward to parse.

Some are experimental.

Some are not supported yet.

For example:

• Claude Code JSONL sessions are practical to support.
• Codex CLI rollout-*.jsonl sessions are practical to support.
• Antigravity legacy JSONL transcripts can be treated experimentally.
• Antigravity IDE .db and .pb formats are not supported yet.
• Claude.ai web transcripts still require manual import.
• Claude Cowork support is unknown.

This made me more conservative about support claims.

A handoff tool should not pretend to understand every environment just because it can read one artifact from that tool.

Safety lesson

The most important safety lesson was simple:

preserving context also preserves risk.

A handoff artifact can accidentally include:

• local machine paths
• private repo names
• unpublished work context
• internal project details
• API keys or tokens
• customer or company references
• raw AI transcript fragments

This is why redaction can only be treated as best-effort.

Even if a tool attempts to remove sensitive patterns, the final artifact still needs manual review before it is shared, committed, published, or passed to another person or agent.

Local-first is a good default.

But local-first does not remove the need for human review.

Output of the experiment

This experiment led to a small open-source tool:

Universal Context Handoff

It is a local-first CLI and assistant skill for moving AI coding session context between repositories and AI assistant environments.

The tool creates handoff artifacts under .handoffs/ and is designed to preserve enough context for another session or agent to continue more safely.

The public release is intentionally limited and conservative.

It is not a cloud memory system, not a complete redaction guarantee, and not a universal parser for every assistant environment.

What I learned

The main learning is that agentic coding workflows need an operating layer between tools.

That layer does not have to be complicated.

It can start as:

• Markdown
• JSON
• repo metadata
• verified command output
• explicit constraints
• public/private review notes
• a repeatable handoff template

The value is not only automation.

The value is reducing ambiguity when one agent hands work to another.

Reusable principle

For future AI workflow design, I would phrase the principle like this:

Do not only save the output. Save the operating context that makes the output safe to continue.

This applies beyond coding.

It also applies to product planning, research synthesis, content publishing, prompt libraries, and knowledge base operations.

A reusable AI workflow is not just a clever prompt.

It is a system that preserves enough context for the next step to be trustworthy.

Next experiment

The next experiment is to connect three layers:

1. Manual template — Agentic Handoff Brief
2. Copyable prompt — next-agent continuation prompt
3. Tooling — Universal Context Handoff CLI

The question for the next round is:

When does a handoff need a tool, and when is a well-structured brief enough?

That distinction matters.

Not every workflow needs automation.

But every serious agentic workflow needs a clear handoff boundary.