How Grok resumes Claude Code sessions

What xAI actually announced

Grok Build 0.2.96, dated July 10 in xAI's changelog, added a welcome-screen shortcut for one-click resume of a recent Claude Code session. The key is Ctrl+U. Version 0.2.100, dated July 13, widened the session picker to resume recent Claude Code, Codex, and Cursor sessions.

That is the user-facing feature: Grok finds recent work from another coding agent and continues it as a Grok session. The CLI reference backs it with grok import [targets...], described as importing sessions from Claude Code. xAI's Claude Code plugin makes the bridge explicit, importing the current Claude transcript and handing back a native Grok session ID.

You will see this described as pasting a Claude Code session ID into Grok. No primary source checked for this guide documents a bare paste command or a session-ID-only syntax. What they document is Ctrl+U, the session picker, grok import targets, and transcript import through the plugin. Use those four and stop hunting for a command that may not exist.

The three verified ways to continue

The welcome screen is the shortest path. Start grok in the repository you want to continue in, then press Ctrl+U. If the most recent candidate is not the one you want, open the session picker instead: xAI says it surfaces recent Claude Code, Codex, and Cursor sessions alongside native Grok work.

cd /path/to/the/same/repository
grok
# On the welcome screen, press Ctrl+U

The second path is the command-line importer, which accepts one or more targets. xAI's own bridge source passes an absolute Claude JSONL path, so a transcript file is a supported concrete form of target rather than a guess.

grok import /absolute/path/to/claude-session.jsonl

The third path starts inside Claude Code, through xAI's grok-build-plugin-cc repository. Its /grok-build:import command resolves the active Claude transcript, imports it, and prints the resulting Grok session ID with a grok -r command ready to paste. An optional --source argument names a specific JSONL transcript instead.

/plugin marketplace add xai-org/grok-build-plugin-cc
/plugin install grok-build@xai-grok-build
/reload-plugins
/grok-build:import

/grok-build:import --source ~/.claude/projects/<project>/<session>.jsonl

What carries over, and what does not

The strongest claim the plugin supports is this: it imports the Claude transcript into a Grok session. Grok gets the recorded conversation as handoff context, and you get a new Grok session identity resumable with grok -r <id>. The plugin source prints both the ID and the resume hint on success.

The repository is not part of that payload. When both tools work in the same checkout, files Claude modified are already on disk, so nobody notices. On a second machine they are not, and the import will not tell you. Clone or synchronize the repository and reproduce uncommitted changes yourself. Transcript context and filesystem state are two separate inputs that happen to meet in the new session.

xAI publishes no field-by-field compatibility contract for imported Claude JSONL in any source checked here. Nothing states whether every tool call, tool result, attachment, todo item, hidden instruction, permission decision, or intermediate state survives in the same form, and nothing states a transcript-size limit. The gaps do not make the feature unusable. They decide how much of the imported context you should treat as evidence.

A safe handoff checklist

Start a cross-agent resume with reconciliation, not edits. The transcript can be complete enough for continuity and still lag the working tree, which is exactly what happens when Claude ran a command or wrote a file just before the handoff. Git and a focused test give you a state boundary. The agent's recap gives you a story.

git status --short
git diff --stat
# Then run the focused project-specific test command

If the handoff is only for a second opinion, tell Grok not to edit anything. If Grok owns the next implementation phase, restate the allowed files and the verification command. Permissions and approvals belong to the new Grok session. Nothing you approved in Claude carries across.

Why cross-agent session portability matters

Until recently a conversation was trapped inside whichever vendor's interface produced it. Transcript import separates the recorded reasoning from the model that continues it. Switch models for a hard debugging pass, recover work when one provider hits a usage limit, or hand a plan to a second agent to attack, all without retyping the history.

Claude Code's local JSONL is becoming the practical interchange format, because OpenAI and xAI both publish import bridges from Claude sessions. That is convergence, not a standard. Each importer decides for itself how to read Claude events and how to store them, and either side can change its transcript schema without telling the other.

The durable part of a software task is still the repository, the issue, the plan, the tests, and the commit history. A transcript is supporting context. Keep the decisions that matter in source-controlled documents or the issue tracker rather than betting that any agent session stays portable forever.

Where the feature fits in a multi-agent workflow

A handoff pays off when the new agent needs the history rather than the latest diff: continuing a multi-hour investigation after a provider limit, moving from requirements exploration into an independent implementation pass, or carrying the rejected approaches across so Grok does not walk into them again.

For small tasks a fresh prompt plus git diff is cleaner. An imported session drags along old assumptions, dead ends, and whatever sensitive output got printed on the way. Use the lightest context the new worker can succeed with. Portability is an option, not an obligation.

The feature also makes agent switching more honest. You can hold what the transcript claims against what the repository proves, then assign ownership out loud. That beats quietly starting a new agent and hoping it inferred every prior constraint from the changed files.

Limits to plan around

The release notes are short, and short release notes promise little. Nothing there commits to perfect replay of every Claude event, a stable import schema, remote workspace transfer, or a maximum transcript size. The plugin verifies a source JSONL path and creates a Grok session. That is an implementation, not a compatibility specification.

Discovery is narrower than import. Ctrl+U is documented for a recent Claude session and the picker for recent external sessions. When the session you want is older, or simply does not appear, fall back to an explicit JSONL path through grok import or the plugin's --source option.

A resumed conversation also proves nothing about whether its claims are still true. Dependencies, files, branches, and external services all moved on after that transcript was written. Ground the first Grok turn in current repository evidence and live documentation whenever the task turns on facts that change.

Questions people ask

Keep reading