Context dies with the chat
You spend the first ten minutes of every session re-establishing the same architecture, conventions, and constraints. Close the tab and it is gone.
Shared memory for coding agents
Recall what the team already wrote. Write down what should last. Share it by default.
Agents search the org’s memory before they answer, keep the part that should still be true next week, and leave it visible to every other agent in the org. That is the product — not a task queue, and not a finished knowledge base on day one.
One-time code sign-in · no password · no credit card.
Built for Cursor, for developers.
Every session starts from zero.
Not because the model is bad — because nothing it worked out was written down anywhere it can reach next time.
Your teammates start from zero too
What your agent figured out on Tuesday is invisible to everyone else’s agent on Wednesday. The same question gets answered from scratch, five times over.
The knowledge exists — just not anywhere searchable
The decision lives in a chat log nobody can grep, a pull request nobody reread, and one engineer’s head.
Recall. Commit. Share.
Two tools and a default. Working memory is the open-session buffer — not a sixth kind of durable memory.
Recall first
Before answering, the agent searches the org with memory_recall. Shared by default: it sees what the team already wrote, not only what it wrote itself.
Commit what lasts
At the end of a turn, context_commit keeps the durable part — a fact, a preference, a decision — and lets the chatter go.
Everyone reads the same memory
What one teammate’s agent commits, every teammate’s agent can recall. The working session stays per-chat until it is committed or distilled.
Hour one is a starter set, not a finished memory.
The first sign-in creates your private org and writes this small, honest seed — the same three facts as the recall window above.
One wiki page
How TeamShared works — sign-in, recall-first, and shared-by-default, so the console is not empty.
Three facts
Auth is an emailed one-time code. Recall is shared by default. Recall first; write down what lasts.
Three starter skills
The fetch/store rituals: teamshared.start-of-task, teamshared.end-of-task, teamshared.capture-decision.
Everything else — more facts, sessions, work, files — is written by the team after you connect an agent.
Get started
Connect once. Same email code as the console.
No install script, and no API key pasted into a config file for Cursor desktop.
Sign in with your email
Request a one-time code and you are in. Your first sign-in creates your own private org — invite teammates from People whenever you are ready to share the memory.
Install the Cursor plugin
Settings → Plugins → Add marketplace, point it at github.com/teamshared-ai/teamshared-plugin, then run /add-plugin teamshared. The plugin registers the MCP server and ships the recall rule.
Click Connect
Settings → Tools & MCP → teamshared → Connect. The browser asks for the same email and one-time code you just used. Nothing to paste, no token to rotate.
Cloud Agents and Grok Bot inherit that Desktop Cursor Connect.
Grok Bot iOS native Connect is unsupported — that in-app sheet cannot
finish. Sign in from Desktop Cursor instead. Durable backup if Connect
does not follow the agent: mint one org tsk_ key under
API Keys and put it on the MCP
Authorization header.
Codex, Claude, Hermes, and CI use that same org tsk_
key — mint it once you are signed in.
For humans
Somewhere to read what your agents wrote.
The console is the human side of the same memory. Same one-time code as Cursor, no API client required.
- Wiki — start with How TeamShared works, then the pages your agents curate.
- Memory explorer — search the facts and records your agents have written.
- People — invite the team by email when you are ready to share the org.
- API keys — mint a
tsk_key for Cloud, Grok Bot, or another harness.
Work, files, and strategy are in the console when you grow into them.
Start free. Connect Cursor when you are ready.
Your private org is ready the moment you sign in. The starter set is already there. The rest is written by the team.