showagent

Switch coding agents. Bring the conversation.
Find a local session and carry its user and assistant messages into another agent's native session format.
Codex · Claude Code · Gemini CLI · OpenCode · jcode · Pi

showagent walkthrough using sample sessions and simulated agent output

Sample sessions; simulated CLI output. The handoff uses the real showagent binary; the target CLI is a labeled demo stub. See compatibility evidence for what has been tested.

Started debugging in Codex and want Claude's take? Find the old session, preview the handoff, then create a new Claude Code session in the same workspace. Your original session stays intact. Conversion carries transferable user and assistant messages; tool calls/results, approval state, attachments, and other agent runtime state are not carried over.

Install

On Linux or macOS, install the latest GitHub release. The script checks the archive against that release's SHA256SUMS and normally installs in ~/.local/bin:

curl -fsSL https://raw.githubusercontent.com/aytzey/showagent/main/scripts/install.sh | sh

If that directory is not on your PATH, run ~/.local/bin/showagent directly or add the directory to your shell's PATH.

On Windows, download and extract the windows_amd64.zip archive from the latest release, then run .\showagent.exe in PowerShell from the extracted directory. Windows support is experimental; see platform and native-resume evidence.

Homebrew and Go installation remain available under other installation options. Distribution details explain version differences between channels.

Quick start

You need an existing local session, the target agent's CLI on PATH, and its normal sign-in/setup completed. Keep the original workspace available.

showagent

1. Press / and search for the workspace or a phrase in the session's first or latest user prompt. Press enter to finish searching, then select the session you want to continue.
2. Press o until the target is claude (or another installed agent).
3. Press x to review the workspace, message scope, and state that will be dropped. Press x again to write and select the new session.
4. Press enter to open that new session in the target CLI.

Prefer commands? The Codex → Claude handoff guide walks through selecting an explicit session ID, previewing, converting, and resuming it. It also explains the reverse direction and what conversion preserves.

Star showagent to keep it handy for your next agent switch.

Why

Each coding agent keeps its own local session store. showagent reads the supported stores and brings their sessions into one terminal picker:

• Find a past session — group by workspace and fuzzy-search agent, session ID, paths, and first/latest user prompts. This is not full-transcript search.
• Resume or branch — reopen a session in its own CLI, or copy its transferable conversation into a new native session to try another direction.
• Switch agents — preview what will carry over, then write a new session for the target agent. File-backed copies are private and written atomically; OpenCode imports go through its own CLI. Originals are preserved.
• Bring web chats into your coding workflow — import a public ChatGPT or Claude share link, a transcript file, or pasted text into a native local session. You can also add imported text to the context of an exact Codex session without starting a model turn.
• Keep your history local — no hosted service, telemetry, or showagent account. The optional updater uses the network; an MCP client may send requested transcript content to its model provider. See the privacy FAQ.

Supported agents

Notes:

• The table describes implemented adapters, not a claim that every provider version and conversion direction has passed a real CLI test. See the compatibility record.
• OpenCode stores sessions in a SQLite database, so every OpenCode operation (discover, export, import, delete) goes through your own opencode CLI — showagent never writes into the database directly. OpenCode and jcode only appear when their CLI is installed.
• The picker only offers hand-off targets whose CLI is on PATH. Scripted conversion to file-backed agents can still prepare a session before their CLI is installed; OpenCode always requires its CLI because imports go through OpenCode itself.
• jcode is a niche, experimental agent CLI. Its support is auto-hidden: if no jcode binary is on PATH, showagent never shows it.
• Pi sessions are versioned JSONL trees. showagent follows Pi's active leaf through parentId links, so abandoned branches are not previewed or moved into another agent. Converted sessions use Pi's native v3 format; the compatibility record distinguishes file conversion from native loader and model-continuation checks.
• A project-local Pi sessionDir is visible when showagent is launched from that project. Like Pi itself, showagent cannot discover arbitrary custom session roots belonging to other projects unless one is selected globally with PI_CODING_AGENT_SESSION_DIR.
• Platforms: Linux and macOS (amd64 + arm64). Windows (amd64) builds are released but experimental: resume runs the agent as a child process instead of replacing showagent.

Other installation options

# Homebrew (Linux/macOS)
brew install aytzey/tap/showagent

# Go 1.25.13+
go install github.com/aytzey/showagent/cmd/showagent@latest

Homebrew, GitHub releases, Go module versions, and MCP bundles can update on different schedules. Go's @latest follows module version resolution, which can differ from GitHub's latest release; check showagent --version and showagent --help after installing. See distribution details for channel-specific features and update instructions.

Archives are also available for linux/darwin amd64 + arm64 and windows amd64 (experimental) on the releases page.

More commands

showagent                  # open the interactive picker
showagent list             # plain table of every session
showagent list --json      # the same, machine-readable
showagent transcript latest --max-turns 50 --json
                           # bounded, secret-redacted context for local handoff
showagent resume latest    # reopen the most recent session, any agent
showagent convert SOURCE_SESSION_ID --to claude --dry-run
                           # preview exactly what a hand-off would carry/drop
showagent import --url CHAT_SHARE_URL --to codex --cwd ./my-project
                           # create a native coding-agent session from a public web chat
showagent import --file conversation.txt --into codex:EXACT_SESSION_ID
                           # add text to an existing Codex session's context
showagent info latest      # exact resume command + storage location
showagent mcp              # serve session history to MCP-capable agents (stdio)
showagent mcp --read-only  # same search/transcript tools, without tools that write copies
showagent mcp --allow-secrets
                           # explicitly allow verbatim secret-like transcript values
showagent update           # update a standalone install (Homebrew: brew upgrade aytzey/tap/showagent)
showagent --help           # full CLI help

Replace SOURCE_SESSION_ID with the ID you selected from showagent list. The transcript command is not present in older builds such as v0.11.0; check distribution details if your help output differs. See web conversation import for accepted transcript formats, security boundaries, and the difference between creating a session and adding context to an existing one.

Keybindings

Scripting

showagent list --json emits an array sorted newest-first — the field names are a stable contract:

[
  {
    "id": "1f7c9a2e-4b31-4c8e-9d02-8a5e3f6b1c44",
    "provider": "codex",
    "workspace": "/home/you/code/api-server",
    "updated": "2026-07-08T19:51:25Z",
    "first_message": "Add rate limiting to POST /v1/charges",
    "last_message": "the redis TTL test is flaky - mock the clock"
  }
]

showagent resume <id|latest> [--yolo] resumes without the picker, so a shell alias can reopen your last session in one keystroke.

showagent transcript <id|latest> [--max-turns N] [--json] exports the most recent turns for local tools that need a bounded context handoff. Output is always secret-redacted, marked as untrusted history, and capped at 500 turns.

showagent convert <id|latest> --to <provider> --dry-run prints the hand-off before writing anything: source session, target provider, workspace, scope, transferable turn count, last user ask, and the agent-specific state that will be dropped. Remove --dry-run to write the converted session, then showagent prints the resume recipe for the new row.

showagent import --url <public-share-url> --to <provider> --cwd <directory> creates a new native session from a ChatGPT or Claude web share. Use --file or --stdin for copied transcripts, and preview with --dry-run. Existing Codex sessions accept --into codex:<exact-id>; imported messages become model context but may not appear as normal chat bubbles. Other existing-session targets stay disabled until their CLIs provide a safe same-ID append contract.

showagent info <id|latest> [--yolo] prints the exact resume command, working directory, and storage location for a session.

Exit codes: 0 success, 1 error (including "no sessions found"), 2 usage. When stdout is not a terminal, plain showagent prints the list table, so pipes just work.

Use it from inside your agent (MCP)

showagent mcp runs a stdio MCP server, so an MCP client can find sessions from the supported local agents, read their recent transcript turns, and request a new native session in another agent. For example, ask it to find a Codex session whose first or latest prompt mentions rate limiting, then read that session for context. Search matches workspace and first/last user-message text; it does not search every message in the transcript.

The server returns a resume command for you to run. It does not launch an interactive agent or continue a model conversation by itself.

# Claude Code
claude mcp add showagent -- showagent mcp

# Codex (~/.codex/config.toml)
[mcp_servers.showagent]
command = "showagent"
args = ["mcp"]

An MCP client can send returned transcript text to its model provider. Common secret-like values are therefore redacted by default, and every transcript is marked as untrusted historical data rather than instructions. If verbatim values are required, the user must explicitly start the server as showagent mcp --allow-secrets; an MCP tool call cannot bypass redaction. For clients that should never write session copies, register showagent mcp --read-only; that mode omits branch_session and convert_session entirely.

Tools:

The default MCP surface is deliberately non-destructive: there is no delete tool, and it never launches or resumes an interactive agent. OpenCode storage operations still go through the local opencode CLI because its sessions live in SQLite. Deleting sessions stays exclusive to the TUI, where it takes two key presses with a human watching. Branch and convert only add new sessions — originals are never modified — and --read-only removes even those additive tools.

How it compares

claude-squad manages parallel live agents with tmux and git worktrees. ccmanager also manages live agent sessions and worktrees, without requiring tmux. Agent Sessions offers a macOS GUI for browsing agent history. hstry provides a shared history database, search, and native-format conversion.

showagent focuses on finding and continuing the sessions already on your machine: a terminal picker that reads existing stores, previews a handoff, and writes a new session for another supported agent. It can sit alongside the tools you use to run live tasks. Start with the handoff guide and check the tested compatibility scope for your workflow.

Compound engineering

Press C on a session and pick an agent. showagent resumes the session there and starts it on a compound-engineering pass: review what was solved, then record the durable learnings as markdown.

Learnings are pooled per project but shared across agents: each workspace gets a directory under ~/.showagent/learnings/<project>/ (override with SHOWAGENT_LEARNINGS_DIR) that every agent reads and writes. Picking an agent that did not create the session converts its transferable user and assistant messages first; provider-private tool and runtime state is not copied.

showagent setup installs the companion compound-engineering plugin into the Codex, Claude Code, and Pi CLIs found on the machine. For Pi it also installs the pi-subagents and pi-ask-user companion packages. The command is idempotent and only installs what is missing.

FAQ

Is my session data sent anywhere? showagent itself does not upload session content and has no telemetry or account. An MCP client may send get_transcript results to that client's model provider, so MCP transcripts redact common secrets by default; keep that boundary in mind before registering the server. Web import fetches only the public ChatGPT or Claude share URL you explicitly provide; it does not use browser cookies, private-chat URLs, or arbitrary hosts. The optional release updater and startup update check also use HTTP (disable the update check with SHOWAGENT_NO_UPDATE_CHECK=1). showagent setup invokes the installed Codex/Claude/Pi CLIs, which may download the requested plugin. Message previews also redact password-like strings and API keys before rendering (covered by tests in internal/session/session_test.go). Release archives ship with a SHA256SUMS file, and releases after v0.7.0 also carry GitHub build provenance — verify with gh attestation verify <file> --repo aytzey/showagent.

How does conversion work? Conversion extracts the user and assistant turns from the source transcript and writes a brand-new session in the target agent's native format (for OpenCode, via opencode import), so the target's own resume command picks it up. Code blocks, newlines, and indentation are preserved. The original session is never modified, and files are private (0600) and written atomically — a crash cannot leave a half-written session in another tool's store.

Trust is explicit: in the TUI, the first x shows the hand-off preview and the second x writes it. In scripts, use showagent convert ... --dry-run for the same preview. Conversion intentionally does not copy tool-call internals, approval history, encrypted reasoning blobs, or provider attachments: those are private to the source agent and would not replay correctly anyway. Branching uses the same safe user/assistant-turn projection; it does not byte-clone provider-private runtime metadata. t / --scope trims the scope to the latest N turns before converting.

What does delete actually do? Codex sessions are deleted through codex delete --force; OpenCode through opencode session delete (which cascades inside its database). Claude Code removes the JSONL plus its matching index entry, jcode removes the JSON plus backup/journal sidecars, and Gemini and Pi remove their session files. Delete always takes two presses, and moving the cursor disarms it.

Windows? Binaries are released, but resume uses a child process instead of replacing showagent. Windows remains experimental; the compatibility record lists the checks actually run.

A session is missing from the list. Run showagent list with no sessions found and it prints exactly which directories were scanned and which env vars override them. r rescans in-place after you start a new conversation.

Adding a provider

A provider implements the interface in internal/session/provider.go, including discovery, resume arguments, transcript extraction, and conversion. gemini.go (file-based store) and opencode.go (CLI-based store) are the two templates. Register it in the registry slice and the TUI picks up badges, filter keys, and convert targets automatically. Add a matching env override so its tests stay hermetic. Issues and PRs welcome.

Building

git clone https://github.com/aytzey/showagent.git
cd showagent
go test ./...
go build -o showagent ./cmd/showagent

The minimum supported toolchain is Go 1.25.13; CI also runs race tests, golangci-lint, govulncheck, and every published cross-compile target.

The illustrated demo uses vhs, fabricated fixtures, and simulated agent output; it is not a native-resume test. Recording and isolation instructions are in demo/README.md.

Security issues and sensitive-data exposure should be reported privately; see SECURITY.md. Contributions are covered by CONTRIBUTING.md.

License

MIT. Built with Bubble Tea, Bubbles, and Lip Gloss.