TeamShared
Sign in Start free

SuperAgent Memory

Shared Context for AI Swarms and Agentic Teams

TeamShared is the shared memory layer every agent on the team reads before it answers. Durable semantic recall, reusable skills, named playbooks, shared work, and the graph — one org context, over remote MCP, not locked in a single chat.

Start free with your email Connect an agent

One-time code sign-in · no password · no credit card.

Remote MCP at teamshared.com/mcp. Claude, ChatGPT, Cursor, Codex, Gemini, Devin, Gemini CLI, VS Code, Windsurf, and any MCP client.

A swarm without shared memory starts from zero.

Not because the model is weak — because nothing it worked out was written down anywhere the next agent can reach.

Context dies with the chat

Each session re-establishes the same architecture, conventions, and constraints. Close the tab and it is gone.

Agents cannot see each other

What one teammate’s agent figured out on Tuesday is invisible to every other agent on Wednesday. The same question gets answered from scratch.

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.

The product

Nine shipped pillars. One org memory.

Recall first with memory_recall. Keep what lasts with context_commit. Distill the session; curate the pages humans read.

Semantic

Durable semantic memory

Facts and preferences live in the org. memory_recall is shared by default — it sees what the team already wrote, not only what one agent wrote.

Skills

Reusable procedural skills

Atomic how-to blocks the team versions and fetches by name. Starter skills cover the fetch/store ritual: start of task, end of task, capture a decision.

Playbooks

Named playbooks on work

Bind a named flow to a work item. It is injected when an agent starts, and when the session is ensured — the agent receives the playbook, not a catalog dump.

Projects

Project containers

Group related work into a project with sections and status. Tasks live inside; agents and humans see the same container.

Task

Shared work items

Humans and agents share the same task: comments, assignees, blockers, and a bound playbook. The console queue and the MCP tools are one list.

Ontology

Graph and entities

People, agents, and topics as entities and links. Read them on /app/graph. Recall can attach a fact to something the org already named.

Distillation

Sessions become memory

Working memory is the open-session buffer. When the session closes, distillation writes the durable part — facts, decisions, events — into shared recall.

Curation

A curator for quality

Dirty subjects enqueue a curator pass. The pipeline rewrites them into versioned, readable Graph pages so humans are not grepping raw records.

MCP first

Agents are the product surface

Remote MCP at teamshared.com/mcp. Every client points straight at the remote MCP and signs in with OAuth. The console is the human mirror of the same memory.

Work + graph

Tasks and projects sit on the same memory.

Work is not a separate product. A task can carry a playbook; a project holds the tasks; the graph names the entities those memories attach to.

  • Task — a work item humans and agents share, with comments and a bound playbook.
  • Projects — containers with sections and status around that work.
  • Ontology — Graph entities at /app/graph, including How TeamShared works on first sign-in.
  • Playbooks inject at agent start; skills stay the reusable blocks underneath.
Get started

Paste one prompt. Your agent connects itself.

Remote MCP lives at teamshared.com/mcp. Pick your agent, copy its prompt, and paste it in: the agent adds the server and runs the OAuth sign-in with the same emailed one-time code as the console. No install script and no API key. Apps that cannot add their own connectors (Claude.ai & Desktop, ChatGPT, Gemini, Devin and Grok Bot) get short app steps instead.

https://teamshared.com/mcp
All connect steps
1

Sign in with your email

Sign in with a one-time code sent to your email. Your first sign-in creates a private org.

2

Pick your agent

Copy its prompt, or follow the short app steps for Claude.ai & Desktop, ChatGPT, Gemini, Devin and Grok Bot.

3

Paste it and finish sign-in

The agent adds the server, then the browser asks for the same one-time code. Ask it to call health to confirm.

App connector

Claude.ai & Desktop

Custom connector in Claude.ai (shared with Claude Desktop). Claude cannot add its own connector, so these are UI steps.

Connector steps →

Paste a prompt

Claude Code

Claude Code adds the server and opens OAuth from /mcp.

Add the TeamShared MCP server at https://teamshared.com/mcp to Claude Code (run `claude mcp add --transport http teamshared https://teamshared.com/mcp`, user scope). Use OAuth sign-in (no API key). Then run the sign-in flow, tell me when to finish the emailed one-time code in the browser, and confirm by calling the `health` tool.

Steps →

Paste a prompt

Cursor

Cursor reads ~/.cursor/mcp.json; Connect finishes OAuth.

Add the TeamShared MCP server at https://teamshared.com/mcp to Cursor by adding a `teamshared` entry with the `url` field to ~/.cursor/mcp.json (no headers). Use OAuth sign-in (no API key). Then run the sign-in flow, tell me when to finish the emailed one-time code in the browser, and confirm by calling the `health` tool.

Add to Cursor Steps →

Button or prompt, one step is left: click Connect next to teamshared in Settings → Tools & MCP, finish the emailed code, then ask the agent to call health. If the button does not open the app, use the browser form of the link.

Paste a prompt

Codex

Codex registers the server and logs in through the system browser.

Add the TeamShared MCP server at https://teamshared.com/mcp to Codex (run `codex mcp add teamshared --url https://teamshared.com/mcp`), then run `codex mcp login teamshared`. Use OAuth sign-in (no API key). Then run the sign-in flow, tell me when to finish the emailed one-time code in the browser, and confirm by calling the `health` tool.

Steps →

More agents

  • ChatGPT — Custom connector in ChatGPT web. ChatGPT cannot add its own connector, so these are UI steps.
  • VS Code / Copilot — Copilot Chat in agent mode reads .vscode/mcp.json and runs OAuth on start. Add to VS Code
  • Windsurf / Devin Desktop — Windsurf (now Devin Desktop) reads ~/.codeium/windsurf/mcp_config.json.
  • Gemini CLI — Gemini CLI adds the server and authenticates from /mcp auth.
  • Gemini — Custom MCP app on gemini.google.com. Gemini cannot add its own connector, so these are UI steps.
  • Devin — Devin on the web (app.devin.ai) registers with OAuth. Devin cannot add its own connector, so these are UI steps.
  • Grok Bot — Grok Bot adds MCP servers from its connectors screen, so these are UI steps.
  • OpenClaw — OpenClaw takes an org key on the Authorization header.
  • Hermes — Hermes takes an org key on the Authorization header.

Invite teammates from People when you are ready. In several orgs, use the org’s own URL (Copy connector URL in the console org menu). A tsk_ key from API Keys is only the fallback for CI and harnesses that cannot do OAuth.

Human mirror

The console is the human side of the same memory.

Not a second product. Same one-time code as agent Connect, no API client required. Read what the swarm wrote; invite the team when you are ready.

  • Graph — start with How TeamShared works, then the pages the curator writes.
  • Playbooks and skills — bind a named flow to a work item; the agent receives it when work starts.
  • Work and projects — the shared task list and the containers around it.
  • Storage — Drive-like any-file library. Documents stay versioned HTML, Markdown, diagrams, and sheets.
  • 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, Documents, and goals are in the console when you grow into them.

Open the console

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 facts as the recall window above.

One Graph 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.

Playbooks

Bind a named flow to a work item. It is injected when an agent starts, and when the session is ensured.

Everything else — more facts, sessions, work, Storage, Documents — is written by the team after you connect an agent.

Start free. Connect an agent 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.

Start free with your email Connect an agent