Build on the same understanding.

Connect any agent that speaks MCP, or call Team0 from your own product over HTTP. Both read the same understanding, under the same access rules, with a record of every read.

Connect an agent Build with the API

Connect an agent over MCP.

Start in Team0: open Agents, choose Connect an agent, and pick yours. Team0 walks you through it. For Codex, Claude Code and OpenClaw there is a plugin, so reading and saving happen on every turn without extra steps.

For any other MCP client

Add a remote Streamable HTTP server at https://api.team0.ai/v1/mcp. Agents that support it sign in to Team0 directly (ChatGPT does). Others send the agent’s own key as a bearer token. Keys are created per agent in Team0 and can be revoked at any time.

Example MCP client configuration

{
  "mcpServers": {
    "team0": {
      "url": "https://api.team0.ai/v1/mcp",
      "headers": { "Authorization": "Bearer t0_live_…" }
    }
  }
}

Living Understanding tools.

These are the Living Understanding tools for a standard agent connection. The live MCP tools/list is authoritative: granted scopes, feature availability, and registered sources determine what that agent can actually call.

Understanding

team0_living_understanding: Read relevant people, priorities, decisions, and open work with source context.
team0_replay_understanding: Reopen an earlier understanding read under the agent’s current access.

Learning and operations

team0_contribute_conversation: Submit a completed exchange for attributed learning.
team0_share_tool_activity: Submit an attributed update about work the agent performed.
team0_get_operation: Check whether queued Team0 work has completed.

The installed Codex, Claude Code, and OpenClaw plugins handle pre-turn reads and completed-turn contributions automatically while active; their manual contribution tools are hidden. Other hosts must call contribution tools explicitly. A permitted tool is not evidence that a host has loaded or used it.

Additional Living Understanding tools

These need the listed scope; correction also requires delegated human authority. Event contribution can appear when a registered source is available, while automatic plugins handle contributions through their hooks.

team0_get_evidence: Resolve an evidence reference from a frozen understanding read. (wm.evidence.read)
team0_explain: Compose an answer from a frozen understanding read. (wm.compose)
team0_get_composition: Retrieve a completed composition. (wm.compose)
team0_contribute_event: Submit an event from a registered source; the conversation tool replaces it when available. (wm.events.write)
team0_correct_understanding: Request an exact fact correction as an authorized human. (wm.corrections.write)

Agent network: messaging between your agents

Connected agents can find your other agents and message them through Team0. This is on by default and can be switched off per agent. A message waits in the receiving agent's Team0 inbox until it next checks, and replies return to the agent that asked.

list_my_agents: List the other agents you connected. (c2c.directory.read)
find_recipient: Resolve a name to one of your agents, and report any ambiguity instead of guessing. (c2c.directory.read)
message_agent: Send a message or hand-off to another of your agents. (c2c.message)
check_inbox: Read messages and hand-offs waiting for this agent. (c2c.inbox.read)
read_channel: Read a whole conversation thread. (c2c.inbox.read)
check_response: Pick up a reply that took longer than the first request. (c2c.inbox.read)
ack_message: Mark an inbox message as handled. (c2c.inbox.write)

Build with the API.

Your own product can read the same understanding over HTTP. The API is an invite-only beta; its contract documents what is available without granting access.

A server integration: Uses a revocable t0_live_ key, kept in your platform’s secret store. Never in browser code, source control, images or logs.
A browser app: Uses OAuth Authorization Code with PKCE, so each person signs in to Team0 themselves.

First call: what this key can use

curl \
  -H "Authorization: Bearer $TEAM0_API_KEY" \
  https://api.team0.ai/v1/capabilities

The response lists only the features and scopes enabled for that application and account.

The rules every connection follows.

One connection per agent: Every agent gets its own grant and credential. Revoking one never touches the others.
Reads are scoped: An agent only receives what its grant allows. Tools it isn’t allowed to use don’t appear in its list at all.
Writes are evidence, not truth: What an agent saves is labelled with its name and weighed like any other source. It can’t make itself trusted.
Everything is on the record: Each read keeps the exact request and what Team0 returned, so you can see what any agent worked from.

Need access or help?

For API access, partnerships, higher volume, or anything that isn’t working, email hey@team0.ai.

Agents that work with Team0 How it works Security

Machine-readable

OpenAPI contract MCP discovery OAuth discovery Scopes llms.txt

Older connections

Agents already connected with a t0c2c_ key at https://api.team0.ai/mcp/mcp keep working. New connections use https://api.team0.ai/v1/mcp.

Your agents will change. Your understanding shouldn’t.

How it works

Invite-only private beta.