Different people. Different agents.
Same project understanding.

Osmos gives a team one shared project memory that every assistant reads from and writes to — so a decision made once in ChatGPT is already known the next time someone asks Claude. Connect your assistant in a minute; nothing to install.

Start free Watch the handoff

How to connect See the app What stays private

Sam
ChatGPT

Let's settle it — all public APIs use opaque cursor pagination. No offset/limit.

Matthew
Claude

Asks: "Build the messages endpoint."

Used from Osmos

Ready

An illustration of a real handoff, not a recording. Two people, two accounts, two different models — and nobody pasted anything.

  • Claude Available
  • ChatGPT Available
  • Any MCP client Available
  • REST API Available
  • Claude Code Planned
  • Cursor Planned
  • Codex Planned
  • Gemini Planned

"Planned" means exactly that. Nothing is marked available until it is documented and tested.

The problem

Your team collaborates. Your agents don't.

You decide something once, with one agent. Every other agent on the project keeps working from a version of the world where you never decided it.

Today

ChatGPT isolated
Claude isolated
Cursor isolated

The gap gets closed by hand: someone remembers, re-explains, pastes context between chats, or an agent re-derives the decision from the code and gets it slightly wrong.

With Osmos

ChatGPT shared context
Claude shared context
Cursor shared context

Durable decisions, constraints, and findings live with the project. Each agent pulls what matters for the task in front of it, and publishes what it learned.

The Osmos moment

Tell one agent once. The project remembers.

A cross-agent handoff is the thing Osmos exists to produce. Here is what happened in the demo above.

Captured

Sam's agent recognised a durable decision and published it to the shared context. Sam did nothing extra — no copying, no second app.

Recorded

The project kept it, along with who made the decision, which assistant published it, what kind of thing it is, and when.

Retrieved

Matthew's agent synced before answering and received the decision — different person, different model, different account.

Day to day

You won't think about it after the first day.

Osmos runs underneath the tools you already use. There is no new chat app to check and no workspace to migrate into.

9:14

You settle an API question in ChatGPT

An ordinary working conversation. Your agent publishes the decision on its own — you don't stop to write it down anywhere.

14:30

Your teammate asks Claude for the endpoint

It already builds cursor pagination. Nobody messaged anybody. This is the moment the product is for.

Thu

You change your mind

The new decision replaces the old one. Assistants stop citing the version you abandoned, and the old one stays in the history where you can still find it.

Next month

Someone new joins

You invite them to the context. Their agent starts from the project's accumulated understanding instead of an empty context window.

Contexts

One context per project. Switched from the chat itself.

A context is a named project brain with its own memory and its own members. Your client work does not leak into your side project, because they are not the same context.

Northwind API updated today

4 people · shared with the whole team

Active in this chat
Mobile rewrite updated today

2 people · you can edit

Active in this chat
Side project updated in May

Just you

Active in this chat

Ask, don't configure

"Switch to the mobile rewrite" is enough. You can pin a context to one conversation and leave your other chats where they were.

It always says where it is

Every answer knows which context it is working in and what you are allowed to do there. If it can't tell, it asks you instead of guessing.

Finished projects go quiet

Archive a context and it disappears from every list, and agents stop seeing it immediately. The memory is kept, so restoring it brings everything back.

Private and shared

Your own notes. One shared project.

Each person keeps their own working notes, which stay theirs. What the project needs to know is shared, and both assistants read it — so neither of you has to re-explain, and neither of you hands over everything.

Person A
ChatGPT Private
  • noteStill unsure about the Redis cache — revisit
  • noteMy TODO: refactor the auth middleware
Shared project context
Both accounts Shared
  • decisionPublic APIs use opaque cursor paginationPerson A
  • constraintPostgres 16, no extensions beyond pgcryptoPerson B
Person B
Claude Private
  • noteClient keeps changing the brief — keep receipts

Both accounts read the shared project. Neither can read the other's private notes.

Nobody re-explains the project

The second assistant doesn't need the first conversation pasted into it. It reads what the project already established and starts from there.

A briefing, not an archive

Each assistant gets what matters for the task in front of it, not everything the project has ever known. So the project can keep growing without every conversation getting slower and more expensive.

Sharing

Share a project brain like you'd share a document.

Three independent controls, in the shape you already know from Google Docs. Change one and see who can read the context.

People

Invite by email at view, edit, or manage. If they don't have an account yet, signing up through the invite joins them.

Anyone with the link

For a contractor or a reviewer you don't want to chase for an account. Generating a new link invalidates every copy already circulating.

Organisation

When several contexts belong to the same group of people, grant the whole group at once instead of person by person.

Who can read this context

    An assistant can never share

    Granting access is a human action, taken in the app. There is nothing an assistant can do to let someone else in — not by mistake, and not by being talked into it.

    Nothing opens by surprise

    Putting a context into an organisation grants nobody anything until you say so. Grouping projects and exposing them are two separate decisions.

    Turning it off doesn't evict people

    Switching link sharing off stops new people joining. Anyone already inside keeps the access you gave them until you remove it.

    What AI saw

    "What exactly did Claude know when it said that?"

    Every time an assistant picks up project knowledge, Osmos keeps the receipt: what it asked for, what it was given, and what was held back. Answerable afterwards, not guessed at.

    "Implement the messages endpoint" Claude · today, 14:30
    0 things it was told
    0 withheld — not yours to read
    0 sent to any third party

    Withheld items are counted, never named — you learn that something was kept back, not what it was or whose it is. The record belongs to the person whose assistant made the call, so not even the context's owner can read yours.

    Trace a bad answer to its source

    When an assistant says something odd, you can open the exact briefing it worked from and find the stale decision behind it — then retract that, so nothing cites it again.

    Proof that private stayed private

    The same record is the privacy receipt. It shows your teammates' private notes never entered the answer, rather than asking you to take that on trust.

    The app

    A place to look, when you want to look.

    Most days you won't open it. It's here for the days you need to check what the project believes, who can see it, or what an agent was told.

    Northwind API · you can manage
    decision from a teammate Public APIs use opaque cursor pagination Sam · today
    constraint Postgres 16, no extensions beyond pgcrypto Priya · Tuesday
    finding Upstream rate limit is 100 requests per minute per key Sam · last week
    private My hunch: the flaky test is a timezone bug only you

    Filter to what's shared, to your own private notes, or both. Anything wrong can be retracted, and assistants stop seeing it.

    Getting there

    Three steps, then it's background.

    Create your account

    Continue with Google or GitHub, or an email and password. You can also start from inside Claude or ChatGPT and create the account on the way through.

    Connect your assistants

    Add Osmos as a connector in Claude and ChatGPT. One address and a sign-in, once per assistant. Nothing to install and no server to run.

    Work normally

    Name a context and carry on. Your assistants read what the project knows before they work and publish what's worth keeping after — and the project's understanding compounds.

    Walk through connecting →

    Privacy and control

    Shared deliberately. Traceable by default.

    Connecting an assistant does not mean handing over everything. Osmos decides what each person may read and write — the model never gets to make that call.

    Private stays private

    Your teammates' private notes never reach the model at all. Not removed from the answer afterwards — never sent in the first place.

    Nothing goes to a third party

    Your project memory is never sent anywhere else to make Osmos work. No outside model reads it, summarises it, or indexes it: finding what matters happens in the same database your memory already lives in, and nowhere else.

    Disconnect any assistant

    Every assistant you connect is listed, and you can cut any one of them off on its own. The next thing it tries to read fails.

    Where it came from

    Who said it, which assistant published it, what it was based on, and when — attached to the knowledge itself, not reconstructed later.

    Look at any of it

    Read what the project believes, see who changed access and when, and retract anything that shouldn't be there.

    Nothing is deleted behind you

    Archiving a project hides it from every assistant immediately and keeps the memory. Nothing is removed for a billing reason either.

    Read what Osmos protects and how →

    Questions

    Is this another chat app?

    No. There is no Osmos chat interface and nothing to migrate into. It runs underneath the assistants you already use and gives them a shared project memory.

    Does Osmos read my whole ChatGPT or Claude history?

    No. It receives what your assistant deliberately sends it — what it is working on, and the durable knowledge worth keeping. Transcripts are not uploaded. The point is to share decisions and findings, not conversations.

    What do my teammates actually see?

    Only what was shared to a context they have access to. Your private notes are yours alone: their assistant is never sent them, so keeping them private does not depend on a model choosing to keep a secret.

    Can I keep client work separate from everything else?

    Yes — that's what contexts are for. Each one has its own memory, members, and access, and an agent works in exactly one at a time. You can also pin a context to a single conversation so switching in one chat doesn't move the others.

    How do I bring in someone who doesn't have an account?

    Invite their email address and they get a link; signing up through it joins them. Or turn on "anyone with the link" for view or edit access when an account isn't worth the friction. A link can never grant the right to re-share.

    Which assistants work today?

    Claude and ChatGPT, added as a connector in each. Anything else that speaks the same connector standard works too, and there is an API for everything that doesn't. The rest are listed as planned above, and we won't call one available until it's documented and tested.

    Is my project memory used to train anything?

    No. Osmos never sends your memory to any third party — there is no embedding model, no summarisation model, and no outside call involved in finding what's relevant. That work happens where your memory already is, and nothing about it is used to train anything.

    What does it cost, and how long is data kept?

    Free covers three contexts with a few people and assistants; Pro is $8 per person per month. See pricing. Your memory and the record of who shared what are kept for as long as the context exists. The records of what each assistant was shown expire after 90 days, because each one lists a person's private notes and shouldn't become an archive in its own right.

    What happens when a decision changes?

    The new decision explicitly replaces the old one. The old version stays in the history, with who made it and when, and assistants stop being told the version you abandoned.

    What if a project ends?

    Archive the context. It leaves every list and assistants stop seeing it immediately, but nothing is deleted — restoring it brings all of the memory back exactly as it was.

    Your agents shouldn't have to start over.

    Give your team one evolving project understanding across the AI tools they already use. Free for your first context.

    Start free See how it connects