The Stack / Swarm Platform
Every new chat, you explain the project again.
Your AI is brilliant for an hour and amnesiac by morning. Close the window and the context is gone — the decisions, the constraints, the reason you did it that way. Swarm Platform is the shared memory that survives the window. One place your chats, your agents, and your team all read from and write to.
A fresh chat opens already knowing the project. Not because you pasted a brief — because the memory was already there.
Status
Hosted platform
Stage — Closed beta · Invite-only
Connects — Claude Code, Codex, Cursor, claude.ai
Via — Model Context Protocol, over OAuth
Retrieval — Semantic — ranked by relevance, not recency
Authored by — The agents. Humans steer.
The problem
The context window is not memory.
Every model has a window. When the window fills or the session ends, the working knowledge that lived inside it is gone. So the same context gets rebuilt, by hand, over and over — and the cost shows up in three places at once.
01
You re-explain, every time
The stack, the constraints, the decision you already made and the reason you made it. Ten minutes of setup before the assistant is useful — paid again on the next chat, and the next.
02
Agents work blind to each other
One agent decides something on a branch. The next agent never hears about it, contradicts it, and now two things are true at once. Nobody wrote it down where the other one would look.
03
The knowledge leaves with the tab
Why a thing is built the way it is lived in a chat that closed last Tuesday. It was never in the repo, never in the docs, and now it is nowhere. The next person — or the next model — rediscovers it the hard way.
What it is
A shared memory your AI reads at the start and writes to as it works.
Not a bigger context window. A durable one — outside any single model, shared across every chat, agent, and person on the project. Six things make it work.
Typed records
Decisions, standards, facts
Knowledge is stored as typed records, not a wall of chat log. A decision and its rationale. A standard the next agent must follow. A fact that stays true. Each one small, named, and citable.
Channels
One per project or workstream
Context is scoped to a channel, the way a repo scopes code. Your team and your agents share the channel for the thing they are actually working on — nothing bleeds in from the rest.
Session-start recall
Warm from the first message
A new session pulls the channel's canon before it answers. The assistant opens already knowing what was decided, what the rules are, and where things stand.
Semantic retrieval
The relevant few, not the recent many
Records are ranked by meaning against the task at hand, then reranked for precision. The session gets what matters now — not the last hundred things anyone typed.
Lifecycle + supersession
Memory that stays current
When a decision changes, the old record is superseded, not deleted — the new truth is what gets recalled, and the history is still there when someone asks why it changed.
Workspace boundary
Membership is the wall
Channels live inside a workspace. Access is workspace membership — enforced everywhere context is read or written. Private working notes stay private until you choose to share them.
How it works
Connect the agent you already use. Nothing else changes.
Swarm Platform speaks the Model Context Protocol, so any MCP-capable agent connects to it directly — Claude Code, Codex, Cursor, a claude.ai connector. You keep your tools. They gain a memory.
The agents do the writing. People do the steering — which channel, what gets shared, what becomes canon. There is no form to fill in and no second app to keep up to date.
Step one · Connect
Point your agent at the platform
One MCP connection, authenticated with OAuth. No token pasted into a config file, no per-machine setup to babysit. The agent can now read and write the channels you belong to.
Step two · Read
Every session starts warm
At the top of a task the agent pulls the channel's relevant canon. Say "catch me up on the project" and it answers from memory instead of asking you which project you mean.
Step three · Write
Decisions get captured as they happen
When the work produces something worth keeping — a decision, a standard, a hard-won fact — it lands as a record on the channel. The next session, and the next teammate, start from it.
The moment it clicks
A brand-new chat. No brief. It already knows.
Stylized for clarity. The point is the first exchange — a cold session that answers from the channel's memory instead of asking you to start over.
Fresh session · no history
Channel · payments-service
You
Using Swarm, catch me up on the payments-service project.
Assistant · reading channel memory
Caught up. Here is where it stands:
Decision — Refunds over $500 route to a human approver before they issue.
Standard — Every provider call carries an idempotency key; retries must be safe.
Fact — The ledger is the source of truth; the CRM mirror is read-only.
Open — Webhook auth is Basic in the URL, not HMAC — confirmed last session.
Trust
Shared does not mean exposed.
Memory is only useful if you trust what is in it and who can see it. Two controls do that work — the workspace boundary decides who reads a channel, and capture mode decides what ever leaves a session.
Private working context stays private by default. A record becomes shared canon only when the rule you set says it should — automatically, on your say-so, or never.
Off
Capture mode
Nothing leaves the session. Use it for exploratory work you do not want on the record.
Propose
Capture mode
The agent drafts what is worth keeping; a human confirms before it becomes channel canon. Steering without the typing.
Auto
Capture mode
Durable knowledge is captured as it happens, no prompt required. For channels where the whole point is that nothing gets lost.
Why we are building this
From Daniel
We run agents on our own work every day, across a dozen projects and more machines than I want to count. The bottleneck was never the model. It was that every session started from nothing — and the thing one agent learned at 2 p.m. was gone by the time another picked the work up at 4.
Swarm Platform is the memory we built so that stopped happening. A fresh chat that already knows the project is not a demo trick here — it is how we work. We opened a closed beta because enough people watched it over our shoulder and asked for it.
— Daniel
Closed beta
Stop re-explaining the project. Ask for an invite.
Access is invite-only while the beta is small. Tell us what you are building and we will get you in when your cohort opens.