Runtimes

Choose the runtime you already use. AgentGit can import its saved conversation, while restoration depends on the runtime’s capabilities. Start with Get Started for the install and first-session workflow; use agit doctor to inspect support on your machine.

Import and resume support

Runtime	CLI identifier	Import	Resume or restore
Claude Code	claude-code	Supported	Native resume
Codex	codex	Supported	Native resume
OpenCode	opencode	Supported	Native resume
OpenClaw	openclaw	Supported	Native restore and local launch; requires OpenClaw 2026.9.4
Hermes	hermes	Supported	Native restore and CLI resume
WorkBuddy	workbuddy	Supported	Native restore and CLI resume; does not register a task in the desktop app
Cursor	cursor	Supported	Import-only; AgentGit does not restore sessions into Cursor
Claude Desktop, Code tab	claude-desktop	Through the Claude Code adapter	Export and application handoff; completion must be checked in the app

Cursor’s available transcript is a projection of its internal storage, so AgentGit can read it but does not write a replacement session into Cursor. Claude Desktop Code-tab conversations share Claude Code’s on-disk format; this does not imply support for every kind of Desktop conversation. Desktop handoff uses a claude://resume URL and finishes in the application, where agit cannot verify the outcome.

Remote control runtimes

Follow Remote Control to connect your device, bind a folder, and start a session in the browser. The web workspace can start and drive Claude Code, Codex, and OpenCode with a current AgentGit daemon. Import support for another runtime does not imply remote control support for it. OpenClaw, Hermes, and WorkBuddy do not have AgentGit remote-control drivers; use their local workflows below.

The machine running the RC daemon must have the chosen runtime installed and signed in. Check claude --version, codex --version, or opencode --version in that same terminal. If the command is missing, add its installation directory to PATH, then restart the peer daemon with agit rc local stop and agit rc local start --detach on CLI 0.2.0. Reload the workspace to read the machine’s updated capability report.

“Not found” means the daemon did not find the executable. “Not reported” means the machine’s report did not include that runtime; update AgentGit and restart the daemon. A detected executable can still need runtime login or a compatible API configuration before it can answer a prompt.

OpenCode uses its native ACP connection for text prompts, streamed replies, single-request tool approvals, interruption, and native session resume. Its remote permission mode requires approvals; native slash commands, mid-turn steering, nested agents, interactive question tools, and session-wide permission grants are not exposed. Sessions with native permission overrides cannot be resumed remotely; start a new RC session to require approvals. OpenCode’s provider configuration and authentication remain on the machine.

Start or import in your runtime

For a new conversation in an existing AgentGit repository, select one of claude-code, codex, opencode, openclaw, hermes, or workbuddy with --as:

agit new alice/my-project -b next-task --as codex

Replace the repository and branch with your own. In the launched agent, check agit status before the first save. Working startup hooks register the runtime transcript on the new branch. If there is no adopted link for that exact conversation, identify its native runtime session ID and run:

agit import SESSION_ID --into alice/my-project@next-task --independent
agit commit alice/my-project@next-task
agit log alice/my-project@next-task

Replace SESSION_ID with the runtime’s conversation ID. If you cannot identify it, exit the runtime and use the picker below with a new branch name; continue with the branch the picker creates. Verify saved turns before leaving work behind, especially when hooks are unavailable.

To adopt an existing conversation, choose one of these paths from its project directory. For a conversation that is no longer running, use the interactive picker in your terminal. Select the conversation and repository, then enter a new branch name and choose the intended lineage to complete the import:

agit import

If you already know the runtime session ID and intend an independent import, import it directly instead:

agit import SESSION_ID --into alice/my-project@existing-task --independent

Add --from openclaw, --from hermes, or --from workbuddy to select the source runtime explicitly when importing one of those conversations.

If the picker reports that a closed conversation is still active, follow the wait and refresh guidance.

Replace SESSION_ID with that conversation’s runtime ID. By default, either path saves the conversation so far and links future settlement to that runtime session; there is no need to run both. Import does not launch a replacement conversation. For a conversation based on earlier saved work, review import lineage and select --onto instead of assuming independence.

Choose a default runtime

When new has no --as option, it uses runtime.default, falling back to Claude Code if that setting is absent. An earlier new --as codex applies only to that launch; it does not change the default for later conversations.

To choose Codex as your global default:

agit config runtime.default codex

Use claude-code, opencode, openclaw, hermes, or workbuddy instead for those runtimes. Keep --as on a command when you want that launch to use a specific runtime regardless of the global setting.

What setup installs

agit setup
agit setup --runtime codex

Run either the first command for the available integrations or the second for just Codex. Re-running setup updates its managed sections without replacing unrelated configuration.

Runtime	Lifecycle integration	Skill	MCP registration
Claude Code	SessionStart and Stop in ~/.claude/settings.json	~/.claude/skills/agit/SKILL.md	claude mcp add agit
Codex	SessionStart and Stop in $CODEX_HOME/hooks.json when the installed Codex supports hooks	$CODEX_HOME/skills/agit/SKILL.md	[mcp_servers.agit] in $CODEX_HOME/config.toml
OpenCode	Agent/manual settlement	~/.config/opencode/skills/agit/SKILL.md	mcp.agit in ~/.config/opencode/opencode.json
Cursor	Agent/manual settlement	~/.cursor/skills/agit/SKILL.md	mcpServers.agit in ~/.cursor/mcp.json
OpenClaw	Lifecycle plugin in $OPENCLAW_STATE_DIR/extensions/agit, enabled in openclaw.json	$OPENCLAW_STATE_DIR/skills/agit/SKILL.md	Uses the plugin and skill; no stdio MCP registration
Hermes	on_session_start and on_session_end in $HERMES_HOME/config.yaml	$HERMES_HOME/skills/agit/SKILL.md	mcp_servers.agit in the same config; requires Hermes MCP dependencies
WorkBuddy	SessionStart and Stop in <WorkBuddy root>/settings.json	<WorkBuddy root>/skills/agit/SKILL.md	mcpServers.agit in the root’s existing .mcp.json, mcp.json, or .codebuddy.json; defaults to .mcp.json

CODEX_HOME defaults to ~/.codex. Each skill directory also contains command references. Setup adds a short AgentGit block to the project’s AGENTS.md unless you select only particular components, such as agit setup --skill or agit setup --mcp.

OPENCLAW_STATE_DIR defaults to ~/.openclaw, and HERMES_HOME defaults to ~/.hermes. The WorkBuddy root uses WORKBUDDY_CONFIG_DIR, then CODEBUDDY_CONFIG_DIR, then ~/.workbuddy-ai. Run setup and later AgentGit commands with the same profile environment as the runtime so they read and write the same stores.

Codex hook support is checked against the installed runtime. Read setup’s output: hooks may be unavailable, or configured while the runtime’s hooks feature is disabled. Explicit Codex setup reports unavailable hook support as an incomplete setup. Use the installed skill and agit commit when hooks cannot run. Hooks do not adopt unmanaged conversations automatically; choose a repository and import them first.

After integration changes, reload the runtime as needed. Ask the agent to run agit status and save a milestone, then verify it with agit log.

OpenClaw

Install and configure OpenClaw’s model access first, then run:

agit setup --runtime openclaw --hooks --skill
agit new alice/my-project -b claw-task --as openclaw

AgentGit’s launch and restoration helpers require OpenClaw 2026.9.4 and reject other versions. Setup requires JSON in openclaw.json; it reports an error if the file uses JSON5 syntax it cannot parse. The lifecycle plugin receives conversation context and adds AgentGit session instructions so completed work can be captured. Reload OpenClaw after setup.

Hermes

Install Hermes and configure its provider, then run:

agit setup --runtime hermes --hooks --skill --mcp
agit new alice/my-project -b hermes-task --as hermes

Setup uses the Python environment beside the installed hermes executable. Hermes asks you to trust AgentGit’s hook commands when it first loads them. MCP setup requires Hermes’ optional MCP dependencies; if they are absent, install them in that Hermes environment or use --hooks --skill without --mcp. The lifecycle hooks settle at session end. Run agit commit with your branch target when you need a checkpoint during the conversation.

WorkBuddy

Configure WorkBuddy’s model access, then run:

agit setup --runtime workbuddy --hooks --skill --mcp
agit new alice/my-project -b buddy-task --as workbuddy

AgentGit prefers workbuddy-cli on PATH, then the bundled CLI in /Applications/WorkBuddy AI.app with Node.js, then codebuddy on PATH. For the bundled CLI and codebuddy, it sets CODEBUDDY_CONFIG_DIR to the selected WorkBuddy root. If you provide a workbuddy-cli wrapper, make sure it uses that same root; set WORKBUDDY_CONFIG_DIR and CODEBUDDY_CONFIG_DIR consistently for a custom profile.

Restored sessions continue through the CLI and are saved in native JSONL. AgentGit does not add them to WorkBuddy’s desktop task list. Standalone WorkBuddy subagent sessions are outside this integration.

Where sessions are discovered

agit import reads session candidates from local runtime stores for the project directory:

• Claude Code and Claude Desktop Code tab: ~/.claude/projects/<slug>/*.jsonl
• Codex: $CODEX_HOME/sessions/**/rollout-*.jsonl
• OpenCode: $XDG_DATA_HOME/opencode/opencode.db, defaulting to ~/.local/share/opencode/opencode.db
• Cursor: ~/.cursor/projects/<slug>/agent-transcripts/**.jsonl
• OpenClaw: $OPENCLAW_STATE_DIR/agents/<agent>/agent/openclaw-agent.sqlite
• Hermes: $HERMES_HOME/state.db
• WorkBuddy: <WorkBuddy root>/projects/<slug>/<session-id>.jsonl, including conversations without desktop task metadata

OpenClaw and Hermes use their SQLite stores as the source of truth. Import reads a consistent transcript snapshot; it does not require you to locate or export a JSONL file first.

Discovery lists what exists. Adoption happens when you select a session and a destination branch with agit import.

Switching runtimes

To continue an existing branch under a different supported runtime:

agit resume alice/my-project@first-task --as codex

The same command accepts openclaw, hermes, and workbuddy as targets, subject to the installation requirements above. To export a native-format file without installing or launching a session:

agit export alice/my-project@first-task --format workbuddy -o conversation.jsonl

Use --format openclaw or --format hermes for those native archive formats. An exported file alone does not register a session in a runtime’s database; use resume (or resume --no-launch) to materialize a session locally.

Cross-runtime conversion uses an intermediate representation. Encrypted reasoning cannot be translated between different vendors’ formats, and some tool-call arguments or results may not have an equivalent target representation. AgentGit reports conversion losses before materialization and requests confirmation when needed.

For a VIEW from one native source in a compatible format family, native rewriting preserves the source format rather than converting through the intermediate representation. It retains encrypted reasoning and compact boundaries while changing session identity and workspace references. Use agit export when you want a file instead of launching a runtime. Cross-format and mixed-source VIEWs use the intermediate representation; the original archived records remain intact.

Core concepts explains how subsequent saves distinguish the restored baseline from newly appended work.

Next, save and resume day to day or learn how your agent uses MCP and skills.