Harness handoff

Today at work I was thinking about agentic harnesses and the future of handing off sessions between machines.

There are a few YC¹ companies building their own agentic harnesses right now, and one thing they seem to be converging on is the idea of having your sessions accessible from anywhere. Essentially, being able to prompt from your pocket, pick up where you left off, and have your agent continue working regardless of which device you're using.

The existing solutions from OpenAI's Codex² and Anthropic's Claude Code³ already offer some of this functionality. You can connect to a session running on your computer from your phone, typically through some form of remote connection or QR code. This works pretty well if you're stepping out for lunch and want to check on your agent or give it more instructions.

You'd ideally want to move that session into the cloud and continue from exactly where you left off. Both providers already offer ways to run agents in the cloud⁴, but it's not as seamless. WHY?

Reproducing a development environment isn't particularly new. We already have tools for cloning repositories, reproducing dependencies, and even snapshotting entire environments.

But reproducing the environment is only half the problem. You also need to preserve the agent's ongoing session.

Right now, the common approach is essentially to ask the agent to produce a handoff. It summarizes what it has been doing, what it has learned, and what needs to happen next. You then feed that context into another session and hope it can pick up where the previous one stopped.

This works, but you're effectively spending tokens to reconstruct state that already existed. And because you're relying on a summary, there's no guarantee that everything relevant survives the transfer.

Instead of having the agent reconstruct its context through another prompt, could we capture the actual execution state of the harness? Potentially by snapshotting a slice of its memory and restoring it in another environment? But perhaps the interesting question is how much of the session can be preserved directly rather than reconstructed through language.

If we could make that state portable, session handoffs could become much closer to suspending and resuming a process than starting a new conversation with a summary of the previous one.

You start a task on your computer, continue interacting with the agent from your phone, close your laptop, and the agent keeps working somewhere else. When you return, you're back in the same session, with the same environment and context.

The agent loop is plain Rust⁶ compiled to WebAssembly⁷. Two build steps make it pausable: an instrumentation pass adds a check to every loop, so the host can interrupt the program anywhere, and Binaryen's Asyncify pass⁸ lets the call stack be unwound into memory and rebuilt later. A small host runs the result on wasmtime⁹.

WebAssembly is what makes this cheap. Every pointer in the program is an offset into one block of linear memory, and after Asyncify the call stack lives there too. To pause, the host unwinds the stack and writes out only the 4 KiB pages that changed since startup, plus a few globals. That one file is the whole paused program.

The toy demo runs a two-million-iteration loop that never yields. Every heapwork step is a fresh OS process: it restores the snapshot, runs for a few milliseconds, gets interrupted mid-loop, saves, and exits. The next process continues at the same iteration. When the agent calls llm(), the process saves the paused call and exits; a later process supplies the reply and the call simply returns.

Because a session is a single file, copying it forks the agent: two sessions with the same past that diverge from there. And a run sliced across many processes ends with a transcript byte-identical to one that was never interrupted.

The coding-agent demo keeps a real Anthropic conversation¹⁰ and its pending tool call in WebAssembly memory. It hands a pending test command from my Mac (ARM64) to an emulated Linux x86-64 machine and back, and the next turn picks up the previous conversation. The transfer itself makes zero model requests.