# Team0

> Team0 is a brain for a company's AI agents. It builds a brain for each person and one for the company from the work people already do, keeps them current, and gives every agent a scoped, sourced read. Team0 installs it in the company's own AWS or Google Cloud account, or hosts the same install for them on a server of its own. Book a call at team0.ai.

Your company changes. Keep your agents in the know.

Every person learns something new each day, and their agents only know what that one person told them. Team0 lets each person's agents know what their colleagues know: what is current, what changed and why, what is still unknown, and where every statement came from. It is not search: search finds what was written, Team0 keeps track of which of it still holds. Each person decides what crosses to the company's brain, and each agent reads only what it is allowed to.

## How it works, from the company's side

Team0 installs it. From then on it maintains itself, learning from the work people already do.

1. Install: Team0 sets it up in the company's own cloud account, or runs it on a server of its own for them.
2. People join by invitation and connect Google for email and calendar; HubSpot, Notion and the other tools people use can be added at any time.
3. Each person connects the agents they use; each agent gets its own access, which can be changed at any time.
4. From then on, every agent starts from its person's brain and what colleagues chose to share. The company's brain is built from its own sources plus what people share, and, if the colleague allows it, an agent can check what a colleague knows about a client. Codex, Claude Code, OpenClaw and Hermes read Team0 on their own before they answer. Other agents connect over MCP with standing instructions that tell them when to read.

## What makes it different from memory or a second brain

Most teams start with an agent and a shared folder of notes it updates after each session. It works at first. Then the files bloat, key details get summarised away, and nobody knows which version still holds; every agent ends up reading a different version of the company. Team0 does the hard part: it keeps one understanding current, from the work itself, and gives every agent the same one. A new agent knows what the last one did.

A second brain is something you feed and keep tidy. Team0 builds itself from the work you connect, keeps itself current, and lends the result to every agent you use.


- Statements, not summaries: each one is tied to who said it, the exact supporting passage, and its source.
- Three clocks: when it was said, when Team0 learned it, and the date it's about.
- Nothing is overwritten: a newer statement supersedes an older one, and the older one stays in history.
- A request is not a commitment, something heard is not confirmed, and silence never proves a task was done.
- Unknowns stay visible instead of being filled with a guess.
- One record per person, built conservatively from every source they appear in.
- Corrections are made once and reach every connected agent.

## How an agent should use Team0

Use Team0 when a task depends on current, sourced context about the user's work: preparing for a meeting, handing over a client without losing what was agreed, picking up work started in another agent, or checking what changed before acting. Do not use Team0 to fetch one raw email or calendar event that the source system can return directly.

1. The person connects the agent in Team0 (Agent reads, in the Team0 console). Each agent gets its own grant, which can be stopped or revoked at any time.
2. Codex, Claude Code, OpenClaw and Hermes can install the Team0 plugin, which reads before each reply and saves each finished conversation.
3. Any other MCP client connects to the Streamable HTTP server at `/v1/mcp` on the company's own Team0 address (shown in Setup). Agents that support it sign in to Team0 with OAuth (ChatGPT does); others send their own per-agent key as `Authorization: Bearer t0_live_…`.
4. Main tools: `team0_brain` (a scoped, sourced read of what the request names), `team0_get_evidence`, `team0_replay_understanding`, `team0_explain`, `team0_contribute_conversation` and `team0_share_tool_activity` (saved as evidence under the agent's name, never trusted automatically), and `team0_get_operation`. The tool list an agent sees depends on its grant.
5. A person's own connected agents can also message each other through Team0 (`list_my_agents`, `message_agent`, `check_inbox`). This can be switched off per agent; a message waits in the receiving agent's Team0 inbox until it next checks.

Machine-readable: [OpenAPI](https://team0.ai/openapi.json), [MCP discovery](https://team0.ai/.well-known/mcp.json), [OAuth discovery](https://team0.ai/.well-known/oauth-authorization-server), [scopes](https://team0.ai/.well-known/oauth-protected-resource).

## Agents that work with Team0

Claude Code, Codex, Claude, ChatGPT, OpenClaw, Hermes, Claude Cowork, Town, Lindy, monday.com and Base44.

## Core pages

Every public page has an agent-readable Markdown version at the same address plus `.md` (the homepage's is /index.md). Each page also links to it with `<link rel="alternate" type="text/markdown">`. The links below go to the Markdown versions.

- [Home](https://team0.ai/index.md): what Team0 is, in one scroll.
- [Product](https://team0.ai/product.md): what each person sees of their brain (Brain, Agent reads, Setup).
- [How it works](https://team0.ai/how-it-works.md): install, each person's brain, what crosses to the company, and a read an agent can trust.
- [The World Model](https://team0.ai/world-model.md): the technical overview: the knowledge stack, where Team0 differs, the system diagram, measurements and limits.
- [Architecture](https://team0.ai/world-model/architecture.md): follow one email through Team0: background ingest, a checked write path, twelve truth checks, sharing and the company brain, a scoped read, a governed door, every connected agent, and what is kept for how long.
- [Data model](https://team0.ai/world-model/data-model.md): typed statements, provenance, holder attribution, three clocks, trusted/candidate/evidence/dormant lanes, ontology held as data.
- [Entity resolution](https://team0.ai/world-model/entity-resolution.md): deterministic keys merge, similar names never merge on their own, conflicting addresses split, extracted relationships are re-checked nightly by models from two vendors.
- [Truth maintenance](https://team0.ai/world-model/truth-maintenance.md): state supersession keyed on identity and type, typed reversible verdicts, corrections outrank automation, contradictions resolved by asking.
- [Trust and scope](https://team0.ai/world-model/trust-and-scope.md): support, provenance, relationship and attention kept separate; scope compiled into every query (prevention, not redaction).
- [Understanding Engine](https://team0.ai/world-model/understanding-engine.md): meaning layers, eight retrieval pools, deterministic packets, frozen replayable agent reads.
- [Memory vs understanding](https://team0.ai/compare/memory-layers.md): how Team0 differs from memory layers such as mem0, OpenMemory, Zep, Letta and Supermemory, described from their own docs.
- [What is a second brain for AI agents?](https://team0.ai/second-brain.md): a plain explainer: why agents need one, what it holds, how agents read and save, the three ways people build one (each agent's own memory, markdown files, a second brain that builds itself) with what each is good at and what to watch for, and six questions to ask of any second brain.
- [Markdown second brain vs Team0](https://team0.ai/markdown-second-brain.md): markdown files are great, a second brain built on them isn't. You trust your AI to keep the files right; six ways it quietly breaks (overwritten, half updated, a guess saved as fact, cut by a summary, never told, out of reach); and how Team0 builds itself and keeps itself current for every agent you connect.
- [Team0 comparisons](https://team0.ai/compare.md): how Team0 compares with Supermemory, Mem0, Letta, Zep, and the memory built into Claude and ChatGPT; each competitor described only in its own published words.
- [Supermemory vs Team0](https://team0.ai/compare/supermemory.md)
- [Mem0 vs Team0](https://team0.ai/compare/mem0.md)
- [Letta vs Team0](https://team0.ai/compare/letta.md)
- [Zep vs Team0](https://team0.ai/compare/zep.md)
- [Claude and ChatGPT memory vs Team0](https://team0.ai/compare/claude-and-chatgpt-memory.md)
- [The 31 problems](https://team0.ai/agentic-understanding.md): everything that has to be solved before an agent can understand someone.
- [Walk through an example](https://team0.ai/example.md): one week at a 90-person software company landing a customer; each day one person learns something, and a colleague's own agent answers without Team0 and with it.
- [Sources](https://team0.ai/sources.md): what the understanding learns from.
- [Works with](https://team0.ai/works-with.md): the agents that connect today.
- [Claude Code and Codex](https://team0.ai/claude-code-and-codex.md): switching between Claude Code and Codex without explaining anything twice.
- [Use cases](https://team0.ai/use-cases.md): meeting preparation, client handovers, picking up in any agent, seeing what changed.
- [How a pilot works](https://team0.ai/pricing.md): install around one job, test it on ten of your own questions, with and without Team0, then decide. Terms and pricing are discussed on a call.
- [Developers](https://team0.ai/developers.md): connect agents over MCP or build with the HTTP API.
- [Trust and control](https://team0.ai/trust.md): what users can see, correct, stop and delete.
- [Security](https://team0.ai/security.md): what Team0 keeps and doesn't, isolation, processors, and straight answers.
- [Privacy](https://team0.ai/privacy.md) and [Terms](https://team0.ai/terms.md).
- [Journal](https://team0.ai/blog.md): essays on how understanding works and what we learned building it.
- [FAQ](https://team0.ai/faq.md): answers to common questions about Team0 and pilots.
- [About](https://team0.ai/about.md) and [Support](https://team0.ai/support.md): company, founder, and how to reach us (hey@team0.ai).

## Team0 Journal

- [Memento's Problem Was Never the Notes](https://team0.ai/blog/agentic-understanding/mementos-problem-was-never-the-notes) — AI agents are like the hero of Memento: they can't form new memories, so they live on notes. Better learning will help. But the notes still have to stay true.
- [AI Agents Need to Know What Changed](https://team0.ai/blog/agentic-understanding/ai-agents-need-living-understanding) — An assistant can find an old email. Can it tell what changed since then? Why Team0 gives agents a way to work from the situation as it stands now.
- [Beyond the Knowledge Base: How a Company Learns to Understand Itself](https://team0.ai/blog/agentic-understanding/beyond-the-knowledge-base-company-understanding) — Search can find the message. It can't always tell whether the work is done, who knows the answer, or what changed. What a Company Brain needs beyond search.
- [The Four Levels of Agentic Understanding](https://team0.ai/blog/agentic-understanding/four-levels-of-agentic-understanding) — Remembering an old answer is easy. Noticing that it stopped being true is harder. Four things an AI assistant needs to do well.
- [Your Agent Needs a Model of Your World, Not a Longer Chat History](https://team0.ai/blog/agentic-understanding/your-agent-needs-a-world-model) — A chat history remembers what was said. It doesn't reliably know which meeting moved, who made a promise, or what changed afterward.
- [A Second Brain You Have to Feed Isn't One](https://team0.ai/blog/building-team0/a-second-brain-you-have-to-feed-isnt-one) — I don't want another system that asks me to maintain folders before it can help me. The lesson that shaped how we're building Team0.
- [Which Promises Are Still Open?](https://team0.ai/blog/world-model-in-practice/a-reminder-is-not-a-commitment) — An email that says “sent” is not always proof of delivery. Here's how Team0 handles a promise it has captured as open work.
- [Your Agents Should Not Each Build a Second Brain](https://team0.ai/blog/world-model-in-practice/one-world-many-agents) — Correct one assistant, and the others may still repeat the mistake. Why Team0 keeps one changing picture of the work and gives each agent only what it may see.
- [Why First Contact Is Not a Relationship](https://team0.ai/blog/world-model-in-practice/truth-is-not-attention) — A stranger's urgent email should not become your top priority just because it arrived today. A mistake we found while building Team0.

## Privacy and security

- Team0 runs in the company's own AWS or Google Cloud account, or on a server of its own that Team0 runs for them. Each install has its own server, database and encryption key, whether it runs in the company's cloud or Team0 hosts it.
- Each person's brain sits in its own database schema; nothing crosses to the company's brain unless its owner shares it.
- Team0 never trains AI on customer content. AI calls use the company's own accounts, under those providers' business terms.
- Team0 does not hold SOC 2. When it runs in the company's cloud, the data stays in the company's own account, under its own controls.
- Sharing is off until each person chooses. Only work facts from company mail cross, with the sharer's name; quotes and evidence stay home. A person can withdraw what they shared at any time, and it is gone within a minute. Admins can't read anyone's brain.
- People can see the source of every statement, correct it, remove it, stop an agent or cut it off.

## Canonical summary

Team0 is a brain for a company's AI agents, installed in the company's own cloud or hosted by Team0 on a server of its own. It keeps a sourced, current, correctable brain for each person and one for the company, and gives each connected agent a scoped read, so each person's agents know what their colleagues know.