Skillsync solves a frustration every developer who uses AI coding agents has felt: you spend hours building context with one agent, then you cannot take that work anywhere else. Your session, with all its reasoning, tool calls, and decisions, stays locked inside the tool where it started. Skillsync makes AI chat sessions portable, so you can move a session between Claude Code, Codex, Cursor, OpenCode, Amp, and Pi instead of starting over. In this guide, you will learn what Skillsync is, how it works, what it costs, and whether it deserves a place in your workflow.
Table of Contents
- What Is Skillsync?
- How Skillsync Works
- Skillsync in Action: Five Workflows That Matter
- Skillsync Pricing and Plans
- Skillsync vs Alternatives: Mosaic, Magents, and Manual Copying
- Who Should Use Skillsync, and Who Should Skip It
- Limitations and Honest Caveats
- How to Get Started With Skillsync
- Frequently Asked Questions About Skillsync
- The Verdict
What Is Skillsync?
Skillsync is a tool from a Y Combinator Winter 2026 startup that turns AI chat sessions into portable files you own. It launched publicly on Hacker News in the week of October 20, 2026, and its pitch is simple: the session is the unit of work, and right now it is being thrown away every time you switch tools.
Think about how you actually work with coding agents. You open Claude Code and spend an hour investigating a bug. The agent reads dozens of files, runs tests, tries a fix, discovers it breaks something else, and adjusts. That whole trail — the questions you asked, the reasoning the model followed, the commands it ran, and the results it saw — is valuable. It is the difference between a teammate who has been in the room for the whole discussion and a stranger walking in cold.
Today, that trail is trapped. Every agent stores sessions in its own private format, and none of them move. If you want to continue the same task in Cursor, you recap from memory, paste a summary, or just start again. It removes that friction by converting sessions into a shared, portable form that different agents can read and continue.

The Lock-In Problem Skillsync Solves
Lock-in in coding agents is invisible until it costs you something. The team behind it puts it well: you do not notice you are trapped in one agent until you try to leave, and by then you have months of sessions stuck in a format only that tool can read. The lock-in is not a subscription or a file format you chose. It is the accumulated context of your work, and it grows more valuable the longer you stay.
This matters more now than it did a year ago because most developers no longer use one agent. You might plan in a browser chat, build in Claude Code, review in Cursor, and automate in Codex. Each switch currently costs you context. It treats that cost as the problem to solve, not as an accepted price of using several tools.
The founders come to this problem with relevant history. Before this startup, they built an open-source payment orchestrator that let merchants route across many payment processors instead of getting locked into one, a project that gathered more than 30,000 GitHub stars. The pattern is the same: incompatible systems, one translation layer, and the user keeping control.
What Actually Moves With a Skillsync Session?
A Skillsync session is not just a chat transcript. According to the launch announcement, it carries the messages, the reasoning, and the tool calls — the full working record of a task. That distinction matters. A plain transcript tells the next agent what was said. A session with tool calls tells it what was actually done: which files were read, which commands ran, and what came back.
It also covers skills and memory, not only sessions. Skills and memory are stored as portable, human-readable markdown that you own, and they are exposed to any agent over MCP, the Model Context Protocol. In practice, that means a skill you wrote once — a code-review checklist, a deployment routine, a house style for commit messages — can be available in every agent you use, rather than being rebuilt in each one.
How Skillsync Works
It works by translating between the private session formats of different agents. Its core is txcript, an open-source engine written in Rust. When you move a session, txcript converts it into a portable form, and the receiving agent reads that form and continues the work. You do not need to understand the translation to benefit from it, but knowing roughly how it works helps you judge its limits.

The Txcript Engine: Translation, Not Magic
Every coding agent keeps its own record of a session. Claude Code, Codex, Cursor, OpenCode, Amp, and Pi do not store that record the same way. Txcript sits between them and converts one agent’s session into a representation another agent can use. The launch materials describe sessions and translation as running locally on your machine, which keeps the conversion step under your control rather than sending your work through a third-party server for processing.
There is a real trade-off here that honest coverage should name. Translating a session into markdown and asking a new agent to read it is not identical to resuming the session natively in its original tool. The new agent has to read the translated record, which costs context, and it may interpret some steps differently from the original agent. Its value is that this cost is usually far smaller than the cost of re-explaining everything from scratch — but it is not zero, and power users moving very long sessions should expect some overhead.
Markdown You Own: Why the Format Matters
It stores sessions, skills, and memory as plain markdown files. That choice is deliberate, and it is the feature that separates it from a simple export button. A proprietary export still leaves you dependent on the exporter. Markdown is readable by humans, searchable with ordinary tools, version-controllable with Git, and openable in any editor if the tool itself ever disappeared.
Ownership also changes how sessions age. A session stored as markdown becomes a durable record of how a problem was solved, not a disposable log. Teams can search old sessions, spot repeated patterns, and hand a solved problem to a colleague as a starting point rather than a story. The launch announcement makes exactly this argument: once sessions are portable, they stop being disposable logs and become something you can build on.
MCP: How Agents Find and Reuse Your Sessions
It exposes sessions, skills, and memory over MCP, the open protocol that lets AI tools offer capabilities to each other. In plain terms, MCP is the plug that lets an agent ask the tool for a session or a skill and receive it in a usable form, instead of you copying and pasting text between windows.
This is also what makes selective retrieval possible. An agent does not need to swallow your entire session history. It can search for the relevant session or skill and pull in only what it needs for the task at hand. That selectivity matters as sessions grow, because context is a limited resource in every model, and dumping everything into every prompt is wasteful.
Local-First, With Sharing as an Explicit Choice
It runs sessions and translation locally on your machine. The one thing that leaves your machine, according to the launch announcement, is what you explicitly share into a team workspace. That design choice matters for developers working with private codebases, unreleased products, or client code under NDA.
Local-first does not mean risk-free, and you should still treat shared sessions with care. A session can contain file paths, code snippets, internal service names, and configuration details. Before you share a session with a team workspace, skim it the way you would skim a document before sending it outside your company. The tool gives you control; it does not remove your responsibility for what you share.
Skillsync in Action: Five Workflows That Matter
Features only matter if they change real work. These are the five workflows the team highlights, and each one maps to a situation developers actually hit.

1. Switching Agents When You Hit a Usage Limit
Every paid coding agent has limits, and hitting one mid-task is miserable. You are deep into a refactor, the agent stops, and your options are waiting, paying more, or starting over somewhere else. With it, you can move the session to another agent and keep going. The new agent picks up the investigation, the failed attempts, and the current plan, rather than asking you to brief it from zero.
This is probably the single most persuasive workflow here, because it turns a billing annoyance into a solved problem. It also subtly changes your negotiating position with agent vendors: if your sessions are portable, you are no longer hostage to one provider’s limits or pricing on any given day.
2. Thinking in the Browser, Building in the Terminal
Many developers think through a problem in a browser chat first. The browser is good for exploration: you can ask open questions, compare approaches, and sketch a plan without touching your codebase. But when it is time to build, you want a coding agent with access to your files.
It lets you hand the whole browser thread to Claude Code or Codex to build from. The agent that does the implementation starts with the reasoning that led to the plan, not just the plan itself. That means fewer “why did we choose this approach?” loops and fewer repeated mistakes the planning conversation had already ruled out.
3. Sharing Research Sessions Across a Team
Teams waste enormous effort repeating each other’s investigations. One engineer spends a day tracing a production issue; another hits the same issue a month later and starts from scratch. Its team workspaces let everyone upload their sessions, so teammates — and their agents — can build on each other’s work instead of repeating it.
The practical effect is a shared memory for engineering work. A new hire can pick up a session left by a departing colleague and continue it. A reviewer can read the session behind a pull request, not just the final diff. A support engineer can hand a debugging session to the developer who owns the service. None of this requires a new meeting or a written handover document.
4. Handing Work to a Non-Technical Teammate
The launch announcement highlights a use case that is easy to miss: letting a non-technical teammate pick up where an engineer left off. Because a session is stored as readable markdown, it is not only machine-portable — it is human-readable. A product manager can read what was decided and why, then continue the conversation with an agent of their own, without needing the engineer to translate.
This only works if sessions are written clearly, which is not automatic. Agents produce messy, verbose records. But a readable record is a far better starting point than a private session file that only one tool can open, and it narrows the gap between technical and non-technical collaborators.
5. Spotting Patterns in How You Work
When sessions accumulate in one portable place, you can see patterns that are invisible when each session dies inside its own tool. Which kinds of tasks repeatedly stall? Which prompts lead to clean first attempts? Which debugging paths waste the most time? A portable session library turns those questions from guesswork into something you can actually inspect.
For individual developers, this is a quiet productivity win. For teams, it is the beginning of a playbook: the sessions that worked become templates, skills, and shared knowledge, rather than folklore that lives in one person’s head.
Skillsync Pricing and Plans
It is available as a Mac app, a command-line interface, and an MCP server. The open-source CLI is free, which means you can try the core session-portability idea without paying anything. That matters for an early-stage tool: the free tier lets you test whether translated sessions actually work for your tasks before you commit money or change your workflow.
The paid Pro tier is reported at $20 per seat per month, with a 5-day trial. Pro adds instant recall, shared team workspaces, and a skill library — the features that matter most once you move from personal use to team use. Pricing for young startups changes often, so check the current price on the official site before you buy; the figure here reflects launch-period reporting, not a permanent promise.
For US buyers, the pricing shape is familiar: a free open-source entry point, then a per-seat team plan at a price comparable to a single developer tool subscription. The honest question is not whether $20 per seat is cheap in isolation, but whether portable sessions save you more than one wasted hour a month. For most developers who regularly switch agents or hit usage limits, that bar is low.

Skillsync vs Alternatives: Mosaic, Magents, and Manual Copying
It is not the only project chasing session portability. The category heated up in the same week it launched, which is itself a signal: developers are feeling this pain widely enough that several teams are building answers at once. Here is how the options compare.
Mosaic: Team-First Shared Memory
Mosaic, another Y Combinator startup from the Summer 2026 batch, launched shared memory that syncs Claude Code, Codex, and Cursor sessions into one shared store. The company says about 2,000 people installed its software, with 37 organizations actively syncing at launch. Mosaic’s emphasis is team synchronization: everyone on the team sees the same shared session store.
The difference from it is one of emphasis. It starts from individual portability — your session, your machine, your markdown files — and adds team workspaces on top. Mosaic starts from the team store. If your main problem is “my team keeps redoing each other’s work,” Mosaic’s framing may appeal. If your main problem is “I personally keep losing context when I switch tools,” its local-first, file-owning approach is the more direct answer. Both are very young, so treat adoption figures as company-reported, not independently verified.
Magents: The Open-Source Handoff Tool
Magents is an open-source project that hands a live session from one agent to another — Claude Code, Codex, Copilot CLI, Cursor, Gemini CLI, Grok, and OpenCode are supported. It offers four moves: reading another session, sending a message into a specific chat, handing off a compacted session into another live session, and spawning independent work that reports back through a small mailbox.
Magents is a strong option if you want a free, hackable tool and you are comfortable with command-line setup. Its design also includes a safety rule worth borrowing mentally for any session-sharing tool: transcripts from other agents are treated as inert, untrusted history — data to read, not instructions to follow blindly. That guard matters, because a session you import could contain prompt-injection text or mistaken instructions from an earlier, confused agent.
Where it differs is polish and scope. It adds a Mac app, a skill library, instant recall, and team workspaces around the same core idea, plus the open-source txcript engine underneath. Magents gives you the handoff mechanism; it aims to give you the whole workflow. Which one fits depends on whether you want a tool to assemble yourself or a product to install.
Manual Copying: The Method You Already Use
The honest baseline is what most developers do today: copy a summary into a new chat, or paste a transcript and ask the new agent to catch up. It costs nothing and works for short tasks. It fails on long ones, because summaries lose the failed attempts and tool results that explain why the current plan is the plan. It also fails silently: the new agent sounds confident while missing context you forgot to include.
Its case is that manual copying is a tax you pay on every switch, and the tax grows with session length. If you switch agents rarely and your sessions are short, the manual method may be fine. If you switch often, or your sessions run for hours, a translation layer pays for itself quickly.
| Option | Best for | Price signal | Watch out for |
|---|---|---|---|
| Skillsync | Moving sessions and skills across agents, solo or team | Free CLI; Pro reported at $20/seat/month | Young product; translated sessions cost some context |
| Mosaic | Team-wide shared session memory | Not confirmed at launch coverage | Team-first; company-reported adoption only |
| Magents | Free, open-source live handoffs | Free | Command-line setup; you assemble the workflow |
| Manual copying | Short, one-off switches | Free | Loses tool results and failed attempts; scales badly |
Who Should Use Skillsync, and Who Should Skip It
It fits best if you regularly use more than one coding agent. That is its core audience: developers who plan in one place, build in another, and review in a third. It also fits teams that want a shared record of investigations, and solo developers who hit usage limits and want to continue a session elsewhere without losing the thread.
It is also worth a look if you care about owning your work product. Sessions stored as markdown you control are an asset in a way that sessions locked in a vendor’s format are not. If you have ever lost a useful investigation because you cancelled a subscription or a tool changed its storage, that argument will land.
Skip it for now if you use exactly one agent and never hit its limits. Portability solves a problem you do not have, and adding a translation layer to a workflow that already works is pure overhead. The same applies if all your sessions are short: a five-minute task does not need a portable record. Finally, if you work on Windows or Linux only, check platform availability carefully — the launch announcement highlights a Mac app alongside the CLI and MCP server, so confirm the Mac app is not the only polished path before you commit.

Limitations and Honest Caveats
It is a young product from an early-stage startup, and a fair guide should say what is not yet proven. No independent testing of session fidelity has been published: the claim that a translated session preserves the reasoning and tool calls well enough to continue complex work rests on the launch announcement and user reports, not on a benchmark. Try it on a real, messy task of your own before you rely on it for production work.
No adoption figures beyond the launch announcement are available either. Unlike Mosaic, which reported installation numbers at launch, its launch materials do not publish user counts. That is normal for a week-old product, but it means you are adopting early, with the usual early-adopter trade-offs: features may change, rough edges are likely, and support will be a small team.
The context-overhead trade-off deserves repeating. A translated session must be read by the receiving agent, and long sessions will consume a meaningful chunk of its context window. For very long investigations, you may still need to compact or summarize before moving, which brings back some of the manual work it aims to remove. Think of it as reducing the switching cost dramatically, not eliminating it entirely.
Security deserves a final note. Shared sessions can leak more than you intend — internal hostnames, API shapes, customer data in test fixtures, or credentials pasted during debugging. Its local-first design helps, because nothing leaves your machine unless you share it. But the moment you share into a team workspace, that session is a document with a life of its own. Review before sharing, and keep secrets out of agent sessions in the first place.
None of this makes it a bad bet. It makes it an early bet with a clear, real problem behind it. The category — portable agent sessions — is almost certainly here to stay, whether this tool, Mosaic, Magents, or a future standard wins it. Trying the free CLI now costs little and tells you quickly whether the idea works for your tasks.
How to Get Started With Skillsync
Getting started is deliberately low-friction, and the free CLI is the right first step. Install the CLI, point it at a session you have already finished, and try reopening that session in a different agent. A finished session is a safe test: nothing is at stake if the translation is imperfect, and you will learn immediately how much context survives the move.
Next, try the workflow that hurts most in your current routine. If usage limits are your pain, deliberately move a live session when you hit one. If team repetition is your pain, share one investigation session in a team workspace and ask a colleague to continue it. One real test beats ten feature lists.
Then set up the skill side. Take one skill you repeat constantly — a review checklist, a test-writing routine, a documentation format — store it as markdown through the tool, and confirm it is available in each agent you use. If your skills follow you across tools, you have already captured half the product’s value before you ever move a long session.
Finally, decide on Pro only after the free tier has proven itself on your work. The Pro features that justify the reported $20 per seat — instant recall, shared workspaces, and the skill library — matter most to teams. A solo developer who only moves sessions occasionally may never need them.
Frequently Asked Questions About Skillsync
Which agents does Skillsync support?
It names Claude Code, Codex, Cursor, OpenCode, Amp, and Pi at launch. That covers the major terminal and editor agents developers actually use day to day. Support for additional agents may expand, so check the current list if your primary tool is not named here.
How is Skillsync different from just exporting a chat?
An export is a dead document. A Skillsync session is a living, portable record that another agent can continue, including its reasoning and tool calls, and it is stored as markdown you own rather than a proprietary file. Skills and memory travel the same way, over MCP, so the receiving agent can search and retrieve them selectively.
Is Skillsync free?
The open-source CLI is free. The Pro tier, with instant recall, shared workspaces, and a skill library, is reported at $20 per seat per month with a 5-day trial. Check current pricing before buying, as early-stage pricing changes frequently.
Is it safe to share sessions with a team?
Sessions run locally, and only what you explicitly share leaves your machine. Even so, review a session before sharing it: it may contain file paths, code, internal names, or test data you did not intend to distribute. Treat a shared session like any other internal document.
Should I pick Skillsync or Mosaic?
Pick it if your main pain is personal portability across agents and you value owning sessions as markdown files on your machine. Consider Mosaic if your main pain is team-wide shared memory and you want a single shared store from day one. Both are young; try the free option of each on a real task before committing a team.
Will Skillsync replace my coding agent?
No. It does not write code or replace Claude Code, Cursor, or Codex. It sits between the agents you already use and moves the work between them. Think of it as infrastructure for your agent workflow, not another agent.
The Verdict
It arrives at the right moment. Developers now routinely use several AI coding agents, and every one of those agents keeps its sessions to itself. The result is a quiet, growing tax on switching tools — paid in re-explained context, repeated investigations, and lost reasoning. It names that tax and offers a concrete way to stop paying it: sessions as portable markdown you own, translated by an open-source engine, shared only when you choose to share.
It is early, and early means unproven at scale. Session fidelity has not been independently benchmarked, adoption figures are not published, and translated sessions still cost context. But the free CLI makes the experiment cheap, and the problem it solves is real and getting worse as agent use grows. For developers juggling multiple agents, it is worth trying this week. For teams drowning in repeated investigations, it is worth a pilot with one shared workspace and one real project.
The bigger story may outlast any single product. The session is becoming the unit of collaboration in AI-assisted development, and the tools that let sessions move freely will shape how teams work for years. it is one of the first serious attempts to build that layer — and the fact that rivals like Mosaic and open-source Magents appeared in the same week suggests the rest of the industry agrees the layer is needed. Start with the free CLI, test it on a session you care about, and judge it by how much context survives the move. That test, more than any launch announcement, will tell you whether it earns its place in your workflow.
Related reading on Tool Minds AI: Tec-Do Navos Pro, the results-driven AI agent for business work, Google Data Agent Kit, the open-source toolkit for data agents, and Walmart’s AI shopping agents, the consumer side of the agent wave. For the primary sources behind this guide, see the Skillsync launch announcement on Hacker News and the Magents open-source handoff project.
