Self-hosted infrastructure for a fleet of long-lived AI agents. Each agent runs in its own sandboxed container with a persistent workspace, internet access, and a pluggable driver.

Yes. Single-VM deploy on plain Docker with your own keys and data. No vendor lock-in, no per-seat SaaS tax, nothing leaves your stack.

Which agent engines (drivers) are supported?

One identical API across swappable brains: Vanilla, Opencode, Codex, and Claude Code. The driver is part of an agent's config and can be swapped anytime.

How do you keep my data and agents secure?

Every agent runs in a hardened container: read-only root filesystem, dropped capabilities, network egress filtering, and CPU/memory limits. LLM keys are stored server-side, encrypted, and never sent to the browser.

Can I watch what an agent is doing?

Yes. Every task streams over Server-Sent Events (assistant messages, tool calls, results, file changes, a live token meter), and reconnects resume where they left off.

Accounts are provisioned by admins; you self-host the stack. Use Get started, or sign in if you already have an account.

Portable AI Coding Agent Sessions: Build or Buy Guide

Portable AI coding agent sessions are becoming a platform problem, not a convenience feature. Engineers now start work in one agent, hit a usage limit, switch machines, hand a task to a teammate, or move from a laptop to a cloud worker. The hard part is not exporting chat. The hard part is preserving enough state for the next agent or human to continue the work safely.

The short answer: treat the session as a development artifact. A useful handoff needs the transcript, tool calls, repo and worktree state, instructions, MCP or tool configuration, permissions context, and a short human checkpoint. Without those pieces, the receiving agent may know what was said but not what changed, what was approved, or what still needs verification.

Related reading: AI coding agent workflow governance.

What Portable AI Coding Agent Sessions Actually Include

A session trace is the conversation plus tool calls, tool results, metadata, images, token usage, and summaries the source tool records. That is only one layer.

The working state is the branch, worktree, diff, generated files, logs, test output, and local services. Git should carry as much of this as possible because Git is still the most reliable cross-tool handoff mechanism engineering teams have.

The control context is the set of rules that shaped the work: AGENTS.md, CLAUDE.md, Cursor rules, skills, MCP servers, permissions, approvals, and local policy. If this does not move, the next agent may continue with different authority than the first one had.

The handoff brief is the readable summary: current goal, decisions made, rejected paths, done and not done items, known risks, verified facts, and the next safe command. It is the part a reviewer can absorb in two minutes.

Why Platform Teams Care

Mixed agent fleets are increasingly normal. A team may use Claude Code in a terminal, Codex CLI locally, Cursor in the IDE, and a cloud agent for longer-running jobs. Engineers switch for model strengths, usage limits, local versus cloud execution, security boundaries, teammate review, or simple preference.

Native products are moving in this direction. Claude Code supports multiple surfaces, including terminal, IDEs, desktop, web, mobile, Slack, and GitHub, with session movement through Remote Control, claude --teleport, and /desktop. OpenAI describes Codex CLI as a local coding agent distinct from IDE, desktop, and cloud surfaces. Cursor markets a multi-surface system spanning desktop, CLI, cloud agents, Slack and GitHub workflows, PR review, and parallel agents.

Those surfaces help inside each product. They do not create an official common native session format across Claude Code, Codex, Cursor, OpenCode, and similar tools. That gap is where platform teams have to decide whether to rely on adapters, capture history, or build their own session layer.

The Three Handoff Models

Full Import

Full import tries to convert one agent's session into another agent's native format. Skillsync and txcript are aimed at this problem across tools such as Claude Code, Codex, Cursor, and OpenCode. Their approach is useful because the source session stays intact while a new native target session is written.

The limitation is structural. txcript's own caveat is the right expectation: what survives conversion depends on what the source records and what the destination can represent. Project files still move separately, and unsupported fields can be lost. Use full import as a bridge, not as a guaranteed record.

Rolling Summary

A rolling summary gives the next agent the current state, important decisions, open files, attempted fixes, and remaining work. It is cheaper and often clearer than a full transcript. It also avoids dragging hundreds of messages and long tool outputs into a new context window.

The risk is omission. A detail that looks minor during summarization may be the detail the next agent needs. For serious work, generate summaries at natural pauses and let the engineer review them before handoff.

Decision Ledger

A decision ledger records choices, rejected options, approvals, and verification results. It does not try to preserve everything. It preserves the reasoning that would be painful to rediscover.

This is especially useful for audit, code review, and team handoff. Pair it with Git state and a checkpoint card so reviewers can see what changed and why without reading the entire session.

Related reading: coding agent session history.

Where Adjacent Tools Fit

MCP and Agent Skills help with portability, but they do not solve active-session portability. MCP standardizes tool and data access. Skills package reusable procedures and resources. Neither guarantees that a half-finished session moves across agents with transcript, tool results, permissions, and working state intact.

SpecStory shows another useful pattern: capture sessions into local Markdown, then sync them for search and sharing when needed. That is valuable when the problem is history, review, or onboarding rather than native continuation.

HumanLayer points toward a broader control-plane model, where sessions, artifacts, and worktrees become team collaboration objects. That matters when approvals and branch state are as important as the chat record.

Security Changes the Build vs Buy Decision

Session logs are sensitive development artifacts. They can contain source code, secrets in command output, customer identifiers, private issue text, internal URLs, diffs, approval decisions, and tool results. Treating them like harmless chat exports is how teams end up with shadow records outside normal retention and access controls.

If audit requirements are strict, build an internal exporter, index, and decision ledger. Keep logs in approved storage, scan for secrets, tie entries to Git state, and define retention. This is slower, but it gives the platform team control over provenance and policy.

If the goal is experimentation, use a converter such as txcript on low-risk repositories and measure which fields survive. If the goal is readable history, use a SpecStory-like capture flow. If the goal is team orchestration, approvals, and worktree control, evaluate a HumanLayer-style control plane.

A Practical Handoff Card

Require a checkpoint card even when a native export exists. It should include:

Task goal and current status
Branch, worktree, and files changed
Commands run and test results
Decisions made and alternatives rejected
Known risks and assumptions
Tools, MCP servers, and permissions used
The next safe action

This small habit protects teams from the false comfort of a long transcript. A transcript is evidence. A checkpoint is direction.

The Recommendation

Move code through Git first. Preserve session evidence separately. Add checkpoint cards at pause points. Test cross-agent converters against the fields your team actually needs. Secure logs like engineering records, not chat history.

Portable AI coding agent sessions are useful when they make work auditable and resumable. They are weak when they merely move a long conversation from one tool to another while leaving the code, permissions, and decisions behind.