Continue a task in a different agent without re-explaining
What carries over when you move a task from Claude Code to Codex through CoreSpeed, memory, connections and policy, and what does not, the conversation itself.
You can continue a task in a different agent because the state that matters lives in your organization, not in the client. Memory holds the facts and decisions, the app connections are already there, and the same approval policy applies. The conversation itself does not move. The new agent recalls memory at session start and goes on from there.
Every task, decision and memory text in this post is a fictional example. The tool names are real.
memory__remember: lead with the Pro plan. The draft is in Notion, Pricing v3.
memory__search_memory. Opening Pricing v3 in Notion.What carries over, and what does not?
The honest list first. CoreSpeed equips the agent you run; it does not run the agent, and it does not copy a conversation from one client to another.
| State | Carries over | How |
|---|---|---|
| Preferences, decisions, named relationships | yes | memory, private or shared, recalled by search |
| App connections | yes | grants belong to the org; private ones follow your sign-in |
| Approval policy | yes | the gate sits in front of the tools for every client |
| Spend caps and the ledger | yes | the org wallet, and per-key caps |
| A running media job | yes | any agent in the org collects it with media__get_result |
| The conversation transcript | no | memory holds facts, not transcripts |
| CLAUDE.md and AGENTS.md rules | no | per repo or per machine, per client; keep rules there |
| A held approval card | no | the card expires about thirty seconds after the agent stops waiting |
How does the hand-off work in practice?
Say you spent the afternoon in Claude Code on a pricing page rewrite. Before you stop, the agent saves what it decided:
memory__remember with "Pricing page rewrite: lead with the Pro plan, keep the Free plan in a second column, copy reviewed 2026-10-07. Draft is in the Notion page titled Pricing v3." Scope is private by default. Ask for scope: "shared" if a teammate's agent should see it too.
The next morning you open Codex instead:
codex mcp add corespeed --url https://api.corespeed.io/mcp
codex mcp login corespeedOn every MCP initialize, the server sends instructions that tell the agent to search memory with two or three short queries at the start of a non-trivial task, plus a short index of your pinned memories. Your first message is "Continue the pricing page rewrite." The agent calls memory__search_memory for "pricing page" and "Pro plan", finds yesterday's decision, opens the Notion draft through the same shared connection, and continues.
Retrieval is hybrid: exact and relaxed lexical matching, entity aliases and vector similarity fused into one ranking, all behind memory__search_memory. A memory of 1,200 characters or fewer comes back whole; a longer one comes back as the passage that matched, with truncated: true and its full_length. The top hit is always returned. Pass the id to memory__get_memory for the whole text.
What should you save before you switch?
Save the kind of thing you would otherwise have to type again: a preference, a product decision, a named relationship, an operating constraint. One memory per fact, in one or two sentences. memory__ingest extracts durable memories from recent messages when the session has produced several.
Pin the memory the next session must see first. Pinning means surface this at the start of every session, in the index the server sends on initialize.
When a decision changes, do not save a correction next to the old memory; both will be retrieved. Where memory maintenance is rolled out, memory__archive_memory retires the old one and superseded_by names its replacement. Nothing is deleted, and memory__restore_memory brings it back. The memory docs cover scope, links and maintenance.
What stays the same on the other side?
Connections: the Notion, GitHub or Linear connection you or your org made is reached the same way from Codex as from Claude Code, because the grant belongs to the organization. The agent receives tools, never tokens. tools/list is caller-specific, so the same sign-in sees the same tools in either client.
Approvals: Smart Approval is a gate in front of the tools, so your organization's policy judges Codex's writes exactly as it judged Claude Code's. Reads are never gated in either.
Budget and trail: both clients draw from the same organization wallet and land in the same ledger, and Dashboard → Activity shows the calls from each client with its surface.
What are the honest limits?
The conversation is not transferred. Memory holds what you chose to keep, in the agent's words, and the new agent may still need the task restated in one sentence. Memory is context, not policy: it informs the agent and enforces nothing.
Instruction files do not move. CLAUDE.md and AGENTS.md live per repository and per client. The practical split is rules in the file, facts in memory.
Visibility follows identity. Your private memories follow your sign-in or your sk-cs- key into any client. An agent principal with an sk-csa- key sees shared memories only. The MCP docs describe the setup for each client.
FAQ
Does the new agent see yesterday's chat? No. It sees the memories that were saved and the pinned index the server sends on initialize. Save the decisions before you switch.
Do I have to reconnect Notion or GitHub in the new client? No. Connections belong to the organization. Sign in to CoreSpeed from the new client and the same tools appear.
Does memory cost credits? No. Memory operations cost 0 credits per call. Storage quotas and rate limits protect the shared service.
Can a teammate continue my task in their own agent? Yes, if the memories are scope: "shared" and the connections are shared. Private memories and private connections stay with you.