You've already thought about giving your team one shared memory.
The reason you haven't is that you'd own whatever ends up in it.
Screened writes · Full provenance · Nothing to sign · Personal memory stays private
Nothing dangerous gets in
Every team write is screened server-side before anyone else's agent can see it: secrets and API keys, injected instructions, and profanity, checked heuristically and by a contained reviewing model. Screening cannot be disabled by an MCP client.
Every fact has a name on it. Nothing outlives your say-so.
Every write records who wrote it, which agent, when, and what it replaced. Corrections are new revisions, not silent edits. When something needs to be gone, a manager can forget it, purge its history, or wipe a collection.
Shared memory is shared execution.
A memory your teammate's agent wrote is a memory your agent will act on. That makes the shared graph an execution path, and it's the one place a bad write scales to the whole team. Every team write is screened before publish: secrets and API keys, injected instructions, and profanity, checked heuristically and by a contained reviewing model.
You see the exceptions, not the traffic. Clean content publishes immediately. Flagged writes wait in your review queue. Approve, reject, or redact. Redacting keeps the original as a shadow copy only managers can see.
- Review queue: everything held for a decision
- Roles: owner, manager, editor, viewer, per collection
- Delegations: grant collection create or admin without full manager
- Audit log: 20+ event types, append-only
- Analytics: per-member daily read/write totals
- Export: any team collection to JSON
Tracked by default. Yours to end.
Every write, role change, review verdict, and correction is recorded: who wrote it, which agent, when, and what it replaced. Corrections are new revisions, not edits. Nothing changes shape in the graph without the previous version staying behind it.
And when something needs to be gone, it goes. A manager can forget a memory, purge its revision history, or wipe an entire collection. We keep your team's data exactly as long as your team wants it kept, no longer.
A new hire's agent can know why you chose Postgres before they've met the person who decided. Supersession, revision history, and canon status answer "which version is current" without anyone rebuilding context by hand.
A manager can decide what your account costs. They can never see what's in it. Teammates' personal memories are not in search, not in analytics, not in the audit log. A manager looking up a teammate's personal memory gets "not found": enforced in the database, not in application code.
One graph, every tool
Maindex is a standard MCP server. Every client on our supported clients list connects with one OAuth URL. Join a team, and your team's collections show up alongside your own, in every tool you already use.
Forwarding this to your team?
Stop re-explaining the same architecture in every standup. Stop watching decisions you already documented get quietly ignored. Your personal graph stays yours even after your employer starts paying.
Three steps, no new tooling
Create a team or accept an invite
Owners create from the dashboard and invite by email; joiners accept on their own account and plan. Nothing to provision.
Team collections appear in every client
Same MCP connection you already use; team memory sits alongside personal memory, clearly labelled.
Managers watch the queue, not every write
Content that passes screening is visible to the team immediately. Anything that trips a check is held for a manager. The write response includes reviewStatus, and automated screening verdicts surface as service hints on the writing agent's next MCP call. Every review verdict lands in the audit log; per-write provenance lives in the revision record.
# personal: unchanged memory_keep(headline="Prefer pnpm in this repo") → mem-2c # team memory_keep(headline="Auth service owns token refresh", team="acme", collection="acme:decisions") → acme:mem-4f (approved · editor) # merged recall: both scopes, labelled memory_search(q="token refresh") → mem-2c personal → acme:mem-4f acme · editor · approved
One parameter. Same tools.
memory_keep, memory_search, memory_recall, memory_list, and collection_manage all take an optional team parameter.
- Namespaced IDs:
acme:mem-4fis team; baremem-4fis personal - Slug resolution: prefix with
acme:runbookswhen ambiguous - Response metadata:
teamSlug,effectiveRole,reviewStatus
Nothing to sign.
No contract, no annual commit, no minimum team size.
Who pays changes. What it costs doesn't.
- Everyone pays for themselves. No coordination, no approval, nobody waiting on anyone.
- One person pays for everyone. One invoice, one renewal, one thing to change when the team changes.
Expanding Brain
$14.99/mo
- Join unlimited teams
- Generous monthly synapse quota
- Full MCP + API access
Galaxy Brain
$49.99/mo
- Create unlimited teams
- Generous monthly synapse quota
- 20 personal collection locks
- Join unlimited teams
- Full MCP + API access
The questions your team will ask.
Shared memory is only useful if you can trust what goes in. Here's what enforces each part.
| The concern | What actually happens | Where it's enforced |
|---|---|---|
| Something bad got in and screening missed it | A manager can forget the memory and purge its revision history. It's gone, not flagged. | Deletion + purge semantics |
| Prompt injection in shared memory | Team writes are screened for injected instructions, secrets and API keys, and profanity before the team can see them. Clean content publishes immediately; flagged content waits for a manager. | Server-side review pipeline |
| API key pasted into team knowledge | Secrets check flags it. Managers can redact: shadow copy preserved, restorable. | Review pipeline + shadow fields |
| Can my manager read my personal memories? | No. Team queries can't reach personal memories; lookup returns "not found." | Postgres row-level security |
| Accidental leak of personal notes into team | Copy personal to team creates a new memory; audit logs destination only. Optional setting blocks agent copy-in. | Copy service and audit design |
| Someone quits: what happens to access? | Remove them; grants cancelled immediately. Their contributions stay with the team. | Membership state machine |
| Junior deletes half the graph | Viewers are read-only. Editors write; only owners delete teams (deferred grace period). Soft deletes + revision history. | Role checks + RLS |
| Who changed what? | Append-only audit log: 20+ event types, queryable by actor, action, date. | Team audit log |
| Owner's card fails | Team freezes; data untouched. Manager on a create-tier plan can claim the team. | Billing gates |
| Training on our data? | No. Not memories, metadata, tags, links, or graph. | Company policy |
| SOC 2 certified? | Not yet: targeted for early 2027. Today: tenant isolation, RLS, AES-256 at rest, TLS 1.2+, OAuth-first auth. | Full posture |
| Leaving Maindex | Export any team collection to JSON. Standard MCP: nothing proprietary. | Data export |
| My company pays for my account: what happens if I leave? | Your personal graph stays attached to your email. Team contributions stay with the team. Resubscribe on your own plan and your memories are there. | Tenant ownership |
| Can we pay for the whole team on one invoice? | Yes. One person creates a billing group and covers everyone; seats can be added and removed as the team changes. | Group Billing |
The full security posture, including what we haven't built yet →
You've already thought it through. Turn shared memory on.
Start a team in about two minutes. One graph across every tool your team uses.
Start a team