Launch HN: Skillsync (YC W26) – AI chat sessions made portable across agents | Hacker NewsHacker Newsnew | past | comments | ask | show | jobs | submitloginLaunch HN: Skillsync (YC W26) – AI chat sessions made portable across agents15 points by cat-whisperer 1 hour ago | hide | past | favorite | 5 commentsHey HN, we're Nars & Nishant, founders of Skillsync (https://skillsync.com)Skillsync lets you move your AI chats across every coding agent. Most of our work exists as conversations, which are currently scattered across our agents. Though stored locally, these conversations use different formats. This is annoying because you cannot simply switch between agents without starting over. We get locked into a single provider and their agent as we invest in skills and memories over time. Skillsync acts as a universal converter. It moves the entire session, including all the messages, reasoning and tool calls so you can pick up right where you left off.Skillsync collects all your sessions in one place and makes them searchable. It breaks down what each session is carrying, including which loaded skills the agent is actually using, making stale context easy to spot. You can also create shared workspaces to sync sessions across your team. You can build your own closed loop systems. Everything runs locally except when you share to workspaces.The core is an open-source Rust engine called txcript (https://github.com/skillsynchq/txcript). It translates a session from one agent's on-disk format into another's, mapping conversation, reasoning, and tool history. Think ffmpeg or pandoc, but for agent sessions.On top of that engine is a local-first desktop app. Your agent sessions are normally scattered across different tools' folders in formats you'd never read by hand; the app surfaces them in one place with a UI that makes them actually readable, the conversation, the reasoning, and the tool calls, so you can revisit what happened, move a session into another agent, or share it with a teammate.Skills and memory are stored as portable, human-readable markdown you own, and exposed to any agent over MCP for search and selective retrieval.Sessions and translation run locally on your machine. The one thing that leaves is what you explicitly share into a team workspace.It’s been surprising to us to see how locked-in people already are without realizing it. You don't notice you're trapped in one agent or harness until you try to leave, and by then you've got months of sessions stuck in a format only that tool can read. The lock-in is invisible right up until it's expensive.Once sessions are portable, they stop being disposable logs and become something you can actually build on, spotting patterns in how you work, handing a session off to someone else, letting a non-technical teammate pick up where an engineer left off. The session turns out to be the unit of collaboration, and right now it's being thrown away.Before Skillsync, Nars and I built an open-source payment orchestrator that let merchants route across many processors instead of getting locked into one (30k+ GitHub stars). Fighting vendor lock-in by making incompatible systems interoperate was the whole job. We came into YC with a different idea, but the more we lived inside coding agents the more we saw the same problem from the other side: your context is locked into whatever agent you start with, because every agent stores sessions differently and none of it moves.Some of the things we’re seeing people do with Skillsync are:- Moving a session between Claude Code, Codex, and Cursor mid-task, including when you hit a usage limit on one and want to keep going on another.- Thinking through a problem in a browser Claude chat, then handing the whole thread to Claude Code or Codex to build.- Sharing research sessions with a team. Everyone uploads their sessions, so teammates and their agents can build on each other's work instead of repeating it.It's available as a Mac app, CLI and MCP. Here's the demo: https://youtu.be/7hVhSnSKGl8. Would love to hear your feedback and answer questions! help

pjm331 22 minutes ago | next [–]
If I were you I would look into maybe like analyzing sessions across harnesses? I’m not sure, some way to leverage this shared schema work that is not syncingBecause syncing is trivially solved by just telling the agent to keep a work journal in markdownreplycat-whisperer 6 minutes ago | parent | next [–]
We do that, and it's really the point of the portability work. Once every harness's sessions live in one schema, you can manage and search all of them in one place.The markdown journal is a fair way to do it, and a popular one. It has a couple of limits though.A journal comes out of a prompt, so it records one way of looking at the session. Whatever that prompt didn't ask about is gone, and you usually find out which detail you needed much later. But the raw session still has it.Being able to unify the schema lets you do things notes can't. You can continue a teammate's session on your own machine, or pick up a claude.ai conversation in Claude Code or Codex. The new agent gets the transcript: all the decisions in the trajectory, not a summary of it.replybcorigliano 54 minutes ago | prev [–]
This is good, I like it!! I've been mostly working with Claude and Chatgpt for separate stuff, however sometimes one of them is stuck and I could definitely use this to start a session with the other one and see if it figures it out.Have you tested to see if there was any degradation happening when switching from one model to the other ? I mean some must be inevitable (maybe not!), but how much?replyNars088 41 minutes ago | parent | next [–]
Nars here, one of the co-founders. With longer sessions, the receiving agent sometimes decides to compact it. But the whole transcript still exists and is accessiblereplycat-whisperer 52 minutes ago | parent | prev [–]
In some cases, harnesses try to obfuscate reasoning, but almost everything goes through.reply

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact
Search:

Skillsync addresses the problem of fragmentation and vendor lock-in by creating a system that makes AI chat sessions portable across different coding agents. Currently, most of the work generated by coding agents exists as scattered conversations stored in disparate formats, which prevents seamless switching between agents and locks users into specific providers as skills and memories are invested over time. Skillsync functions as a universal converter designed to move an entire session, encompassing all messages, reasoning, and tool calls, allowing users to resume work exactly where they left off.

The system centralizes all sessions into a single, searchable location and provides granular insights by breaking down what each session contains, including which loaded skills the agent utilized, thereby making stale context easily identifiable. Furthermore, Skillsync facilitates team collaboration through shared workspaces, enabling synchronization of sessions across teams. The architecture is designed to run locally on the user's machine, with the exception being the explicit sharing of data into a shared workspace.

The core of the portability mechanism is an open-source Rust engine named txcript, which serves to translate a session from one agent's on-disk format into another's by mapping conversation, reasoning, and tool history, analogous to tools like ffmpeg or pandoc applied to agent sessions. This translation capability is supplemented by a local-first desktop application. This application surfaces the scattered agent sessions into a single, human-readable interface, making the conversations, reasoning, and tool calls accessible for review, migration, or sharing with teammates.

Skills and memory are managed as portable, human-readable markdown, which are exposed to any agent via the Model Communication Protocol (MCP) for selective retrieval and searching. This approach transforms sessions from disposable logs into actionable units of collaboration, allowing users to spot work patterns, hand off complex tasks to others, and enable non-technical teammates to easily pick up ongoing engineering work. The portability enables scenarios such as moving a session between models like Claude Code, Codex, and Cursor mid-task, or handing off a research thread to another agent. While longer sessions may sometimes result in the receiving agent compacting the transcript, the complete transcript and reasoning always exist and are accessible.