Direct answer

Move Work from Grok to Claude

To move work from Grok to Claude, move the state, not the chat scroll. Connect both Grok and Claude to the same Zambo endpoint, https://zambo.dev/mcp, save the work state in Grok (the goal, the decisions made so far, the current files, and the open items), then open that state in Claude and continue from it. Every saved step carries a verifiable receipt, so the move itself is checkable afterward. The rest of this page walks the move for a fast take that now needs a careful, client ready version, step by step, including what copy and paste loses and how to hand the moved work to a client when it is done.

See a finished record first: the worked example handover at zambo.dev/handover/bd7e5325-33fd-4c5e-b029-76b781fa2f51 shows the goal, steps, outputs, and receipts in one link, and this accepted example shows the closed state. Check any receipt free at the public verifier.

Updated October 20, 2026.

Why people move from Grok to Claude mid-work

People move from Grok to Claude when the fast take needs to become a careful one. Grok catches the live conversation and the quick angle; Claude is where the long, precise version gets written: the analysis a client can rely on, the document that will be quoted, the reasoning that has to survive a second reader. The move only pays off if Claude receives what Grok actually found, not a flattened version of it.

It is also the move people make when a Grok thread runs out of road. The session has the research, the arguments, and three settled decisions buried in it, and the next step is too important to start from a paste. Claude with the full saved state can pick the work up at the exact point Grok stopped, including the open items Grok never resolved.

Consultants and freelancers live on this move. The public signal is gathered in Grok, often in front of the client, and the paid thinking is delivered from Claude. A checkable move between the two is what lets the client see the line from the raw signal to the finished advice without sitting through either session.

The pattern underneath all three reasons is the same, and it is the pattern behind the wider family of moves covered on move a chat from one AI to another. The first tool was right for the first step and the second tool is right for the next one. Nothing went wrong. Work simply outgrows a single session, and the question is never whether to move. The question is whether the work arrives whole.

What copy and paste loses

The manual move looks simple: scroll the Grok chat, copy the good parts, paste them into Claude, and write a short brief on top. It loses four things every time. First, it loses decisions. A long session settles dozens of small choices, and a paste keeps the final wording while dropping why that wording won and what was rejected, so Claude cheerfully reopens questions you already closed. Second, it loses files in their true state. You paste the version you remember, not the latest version, and the difference surfaces days later. Third, it loses open items. The things Grok flagged as unresolved rarely survive a summary, because summaries are written to sound finished. Fourth, it loses proof. A paste is just text you assert is accurate. Nobody, including you next week, can check whether it matches what the Grok session actually produced.

Screenshots are worse, not better. A screenshot of a Grok answer cannot be opened, searched, edited, or continued by Claude. It freezes one screen, usually the last one, and leaves the goal, the earlier decisions, and the files outside the frame. People screenshot because it feels like evidence. It is the opposite: it is the one form of the work that the receiving tool can do the least with, and the one form nobody can verify. The method below replaces both habits with a saved state that cross-AI memory can carry between tools.

The Zambo method, step by step

Step 1: Connect both tools to one endpoint. Add https://zambo.dev/mcp as the MCP endpoint in both Grok and Claude. It is one URL and no key, and it is the same endpoint in both places, which is the whole point: the state you save from Grok is readable in Claude because both tools talk to the same Zambo account. Zambo is the verifiable work layer for AI, with 153 tools in total and 35 on the default surface. Do this once, before the work starts if you can, and every later move between these two tools becomes a save and an open instead of a rescue.

Step 2: In Grok, save the work state before you leave. Ask Grok to save four things through Zambo: the goal in one or two plain sentences, every decision that is settled with the reason it was settled, the current files or outputs exactly as they stand, and the open items listed as open. Be explicit that unsaved reasoning is not part of the state. If a choice matters, it goes in the decisions list in words. This save is a tool call like any other, so it produces a verifiable receipt: a record of the saved result that anyone can check free at https://zambo.dev/verify/ with no signup.

Step 3: Check the save like a skeptic. Read the saved state back before you close Grok. You are looking for the three classic gaps: a decision recorded without its reason, a file saved in an older version, and an open item written to sound resolved. Fix the state now, while Grok still holds the session. This two minute check is the difference between a move and a rumor, and it mirrors the discipline on AI session handoff: end the session in a state the next session can trust.

Step 4: Open the state in Claude and brief from it. In Claude, open the saved state through the same Zambo endpoint and give one instruction: continue from this state, do not restart it. Name the next step directly. For this pair, that step is usually careful finishing work: precise long writing, close reasoning, and a document that survives a second reader. A good first prompt in Claude reads like this: here is the goal, here are the decisions already made and why, here are the current files, and here are the open items. Continue at the first open item, keep every settled decision, and flag anything in this state you cannot read or that conflicts.

Step 5: Work in Claude, saving as you go. Each step you run through Zambo in Claude adds its own receipt to the same chain of work, so the final record shows the full path: started in Grok, moved at a specific saved state, continued in Claude. When the job later moves again, or goes to a client, nothing needs to be reconstructed. The move is a step in the record, not a gap in it.

What carries and what does not

Carries: the goal as saved, in the words you approved. The decisions list, with reasons, so Claude does not relitigate settled questions. The current files and outputs, in the version saved at the moment of the move. The open items, listed as open, so the next step starts at the real frontier of the work. And the receipts for each saved step, which let anyone check that the saved results were not changed after the fact.

Does not carry: the hidden reasoning of the Grok session, which was never written down and cannot be moved. Anything you meant to save and did not, including files open only in your editor or notes kept in another app. Settings, plugins, custom instructions, and habits specific to Grok, which do not exist inside Claude and should be restated in your first prompt there. And the exact tone of a long chat, which drifts in any move, so name the audience and the format again in Claude.

The honest rule is simple: if it was saved, it carries, and if it was not saved, it does not. That rule is stricter than a paste, which pretends everything carried, and it is why the moved work holds up. A related pattern, worked end to end for one pair, is on continue a ChatGPT conversation in Claude.

The same move, by situation

Move work from Grok to Claude for clients: save the state at the point the client last approved, so Claude continues from the approved version, not from your private latest draft. The receipts let the client check later that the finished work descends from what they approved.

Move work from Grok to Claude for freelancers: you are both ends of the move, so the risk is pure memory loss between sessions. Saving the state takes minutes and replaces the end of day summary you would otherwise write to yourself and half trust.

Move work from Grok to Claude for teams: the saved state is the team object. One person saves from Grok, another opens in Claude, and the receipts settle whose version moved and when, without a meeting about it.

Move work from Grok to Claude for small business: the owner often starts work in one tool and an employee or contractor finishes it in the other. A saved state means the business keeps the record of the job even when the person who started it is away.

Move work from Grok to Claude for agencies: across a roster, moves happen daily and quietly. Making each move a saved, receipted step turns a source of client disputes (which version, which brief, which approval) into a record the account team can open.

The best way, in one line: connect both tools once, save the state at every natural stopping point, and treat the move itself as a step in the work that deserves its own receipt.

How to hand the moved work to a client afterward

When the job finishes in Claude, do not send a fresh summary email and undo the whole discipline. Send a Zambo handover: one link carrying the goal, the steps in order, the outputs, any open items, and a verifiable receipt for each step, including the step where the work moved from Grok to Claude. The client opens the link in a browser with no account, checks any receipt free at zambo.dev/verify, and accepts the job or flags one named step. You cannot accept your own handover, and neither can the agent that did the work, which is what makes the acceptance on the record worth showing next to the invoice. The move stops being a weak point in the story of the job and becomes one of its best documented steps.

What it costs

Public handovers are free to send and free for the client to open, and checking a receipt is always free. For $0.99, a Day Pass covers 24 hours of full access through the Zambo MCP at https://zambo.dev/mcp: on a day when a job has to move from Grok to Claude and still land with a client, that is the price of doing the move properly once. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402.

Honest limits

Three edges, stated plainly. First, a verifiable receipt proves the saved result was not changed after the fact; it does not prove the result was right, and Claude can still continue the work badly from a perfectly saved state. Second, the state only contains what you saved: Zambo memory holds facts you explicitly save, it does not import your Grok chats, and work done entirely outside connected tools has no receipt. Third, each tool connects to MCP in its own way and on its own plan terms, so allow a few minutes for the first connection in each. AER-1, the receipt format underneath, is an IETF Internet-Draft (draft-zambo-aer1-24), not a finalized standard.

Frequently asked questions

What is the best way to move work from Grok to Claude?

The best way to move work from Grok to Claude is to move the state, not the scroll. Connect both Grok and Claude to the same Zambo endpoint at https://zambo.dev/mcp, save the work state in Grok (the goal, the decisions, the files, and the open items), then open that state in Claude and continue. Each saved step carries a verifiable receipt, so the move itself is checkable afterward instead of resting on a summary you typed from memory.

Can I move work from Grok to Claude for a team?

Yes. For a team, the saved state is the shared object: one person saves the goal, decisions, files, and open items from Grok, and a teammate opens the same state in Claude under the same Zambo account. Nobody re-briefs anybody in a chat message, and nobody works from a stale paste. The receipts on each step let the team check what state the work was in when it moved, which settles most handover arguments before they start.

How do I move work from Grok to Claude without screenshots?

Skip the screenshots entirely. Screenshots capture pixels, not state: they cannot be opened, searched, or continued. Instead, save the work state from Grok through Zambo: the goal in words, each decision with its reason, the current files or outputs, and the open items. Open that state in Claude and the work continues as text and files Claude can actually use. The receipt on the saved state proves it was not changed after the fact, which no screenshot can show.

What does not carry over when I move work from Grok to Claude?

Four things do not carry. The hidden reasoning of the Grok session does not travel, only the decisions you saved. Files or outputs you never saved stay behind. Settings, plugins, and habits specific to Grok do not apply inside Claude. And tone set by a long chat drifts, so restate the audience and the format in your first Claude prompt. What carries is what you saved on purpose: goal, decisions, files, open items, and the receipts for each saved step.

How do I hand the moved work to a client afterward, and what does it cost?

Finish the job in Claude, then send it as a Zambo handover: one link carrying the goal, the steps, the outputs, and the receipts, including the step where the work moved from Grok. The client opens the link with no account and accepts or flags it, and you cannot accept your own handover. Public handovers are free to send and open. A Day Pass is $0.99 for 24 hours of full access through the MCP, framed here as the cost of solving this move properly once.