Install the CLI, register on the web, run metateam in your repo — it handles login, hooks, crew init, and summons Data, your coordinator. From there, you tell Data what to do: set up projects, add KB entries, assign work to specialists. One command to start, one conversation to operate.

The crew helped research and draft this guide. I tested every step myself and approved the final version.

Getting Started with Metateam

March 2026

AI coding sessions start from zero. Metateam fixes this. Install it, work normally, and your sessions start accumulating memory — automatically, with no workflow changes and no manual uploads.

This guide takes you from zero to operating a coordinated crew of AI agents with persistent memory across sessions.

Every command in this guide is verified against the current CLI (v1.0.1).

Install

One command:

# macOS / Linux
$ curl -fsSL https://metateam.ai/install.sh | sh

# Windows (PowerShell) - When out of closed Beta
> irm https://metateam.ai/install.ps1 | iex

This installs the metateam binary to ~/.local/bin. If the installer asks to add the directory to your PATH, say yes.

Verify: metateam --version shows the installed version.

If the install script fails: Download the binary directly from metateam.ai/downloads.

Create an Account

Register at metateam.ai/register — fill in username, email, and password, then click the verification link in your email.

If registration isn't open yet: Metateam is in early access. Check metateam.ai for availability.

Alternatively, you can register from the CLI with metateam account register, which prompts for the same fields and sends the same verification email.

Start Metateam

Open a terminal in your project directory and run:

$ cd your-project
$ metateam

On first run, this single command handles everything: it logs you in, installs session hooks for your AI clients (Claude Code, Gemini CLI, Codex CLI), initializes a crew in your repository, launches the dashboard, and summons Data — your crew coordinator. Data greets you and waits for your first assignment.

After first run, metateam in any initialized repo launches the dashboard and summons Data immediately — no setup steps, no configuration prompts.

Verify: The dashboard is running and Data has greeted you in the first tab.

If the dashboard doesn't launch: Check that tmux is installed (brew install tmux on macOS, apt install tmux on Linux). Metateam uses tmux to manage agent sessions.

Non-interactive environments (CI, remote shells, Docker): The first-run bootstrap requires a TTY. In non-TTY environments, you'll see: Not configured. Run: metateam setup --username <USER> --password <PASS>. Use the explicit credentials path instead.

Set Up Your Project

The first thing to do with a running crew is tell Data about your project. From a separate terminal (the dashboard is running Data's session):

$ metateam crew message data "Create a project for this repo and pin it to this directory"

Data creates a project in the Metateam system and pins it to your working directory. Projects are how the system organizes memory and knowledge — sessions, extracted facts, and KB entries all belong to a project. Without a pinned project, the system can still capture sessions, but it cannot route accumulated memory back to the right agents when they start. Pinning ensures that every session in this directory builds on the same shared context.

Once the project exists, you can ask Data to set up foundational knowledge:

$ metateam crew message data "Add a KB entry marked important: all API endpoints return camelCase JSON, do not use snake_case"

Data creates the Knowledge Base entry for you. Entries marked important are auto-injected into every agent session for this project — they become persistent context that every specialist on the crew starts with. This is how you encode conventions, gotchas, and architecture decisions that every agent should know, regardless of which AI client they run on.

Unlike CLAUDE.md or AGENTS.md (which are client-specific), KB entries reach every agent on every client — one entry, every session, every specialist.

Verify: Ask Data to confirm the project is pinned and the KB entry exists: metateam crew message data "Show me the current project and KB entries".

You can also manage projects and KB entries directly — via the CLI (metateam kb, metateam pin) or on the web dashboard at metateam.ai (under Dashboard, then Knowledge). Same data, visual editor, version history. But for most operations, asking Data is the simplest path.

Work a Session

With the project pinned and the crew running, you can work a normal coding session. Ask Data to assign work, or open an agent directly:

$ metateam crew message data "Review the auth module for security issues and fix anything you find"

Data reads your request, breaks it into steps, summons the right specialists, assigns tasks, and coordinates the work. You watch the dashboard — agents appear, work, communicate with each other, review each other's output, and report back. You don't summon agents, assign tasks, or manage the workflow manually — you tell Data what you want done, and Data runs the crew.

When sessions end, the system captures transcripts automatically and a background worker extracts reusable facts. This takes a few minutes. Once extraction completes, those facts inject into future sessions — each agent arrives knowing what was learned before.

Verify: After a completed session, metateam memory list shows extracted facts. metateam session search "keyword" finds uploaded sessions.

If no facts appear: Extraction is asynchronous — give it a few minutes and check again. If sessions never appear, check hook status with metateam hook status.

Note on Codex CLI: Codex uses metateam start for context injection instead of the SessionStart hook. The result is the same — accumulated context at session start — but the trigger mechanism differs.

Day 2

The next morning:

  1. Open your terminal.
  2. cd your-project
  3. metateam

The dashboard launches, Data is summoned with yesterday's memory intact, and you tell Data what you want done today.

That's the entire startup ritual — no new commands, no "remembering where you left off." Run metateam in your repo and you're working.

Each day, your crew's memory grows. The reviewer learns your codebase patterns. The coordinator remembers which specialists handle which subsystems. The KB entries you add become permanent context. After a week, the difference between a fresh agent and your crew is measurable — not because the model is smarter, but because it arrives knowing more.

Verify: Ask Data to summarize recent work — it references tasks from prior sessions.

If memory seems empty: Check metateam memory list to confirm facts exist. If the project was not pinned, run metateam pin project-slug to associate this directory with the correct project.

What Can Data Do

Data is your primary interface to the crew. Beyond coordinating tasks, Data can manage the crew itself:

  • Summon specialists — "Summon a security reviewer to audit the auth module" brings a new agent into the crew with the right expertise and accumulated memory.
  • Release agents — "Release the security reviewer, we're done with the audit" removes them from the active crew.
  • Create new personas — "Create a persona for database optimization with Codex as the default client" adds a custom specialist to your roster.
  • Edit existing personas — "Update the reviewer persona to focus on performance instead of security" adjusts a specialist's profile and instructions.
  • Delete personas — "Remove the database persona, we no longer need it" cleans up the roster.

Data also knows the Metateam system itself. If you want to understand how memory extraction works, what CLI commands are available, how to configure hooks, or how cross-machine communication operates — ask Data. It has access to the Knowledge Base, the documentation, and its own accumulated experience operating the system.

How the Crew System Works

Under the hood, crew behavior is defined by Knowledge Base entries in the default/crew/ compartment. When an agent is summoned, the system assembles its instructions from these entries. Understanding them is not required for daily use, but knowing they exist helps when you want to customize how your crew operates.

Persona profiles (default/crew/data, default/crew/axiom, default/crew/prism, etc.) — each persona is a KB entry that defines the agent's identity, role, default AI client (Claude, Codex, or Gemini), area of expertise, and behavioral instructions. The built-in roster includes over 30 specialists — coordinators, architects, developers, reviewers, security experts, testers, technical writers, and more. When Data summons an agent, the system fetches that persona's KB entry and injects it as the agent's operating instructions.

Workflow (default/crew/workflow) — defines how work gets done: the crew lead coordinates but does not code, specialists implement and report back, all code is reviewed before merge, architecture decisions require two reviewers. This entry is injected into every agent so the entire crew follows the same process without being told each time.

Communication protocol (default/crew/communication) — defines how agents talk to each other: the msg command for short messages, the mail-board/ directory for long-form reports and architecture proposals, the screen command for checking another agent's terminal, and conventions for multi-recipient messages and direct communication. Agents follow this protocol automatically because it is part of their injected context.

Client-specific instructions (default/crew/agent-claude, default/crew/agent-codex, default/crew/agent-gemini) — each AI client has different capabilities and quirks. These entries contain client-specific guidance: how Claude Code handles hooks and tool permissions, how Codex CLI manages sandboxing and file access, how Gemini CLI handles extensions. The right entry is injected based on which client the agent runs on.

All of these entries are editable. You can ask Data to modify the workflow, adjust a persona's expertise, or add client-specific instructions — or edit them directly on the web dashboard or via the CLI. Changes take effect on the next summon: the agent receives the updated instructions when it starts.

Troubleshooting

Session not uploading: Check that hooks are installed with metateam hook status. If hooks show as disabled, run metateam hook enable.

No facts after first session: The extraction worker is asynchronous. Give it a few minutes, then check metateam memory list. If facts never appear, check that your session was uploaded with metateam session search "keyword".

Dashboard won't start: Requires tmux. Install with brew install tmux (macOS) or apt install tmux (Linux).

Agents not responding to messages: The communicator runs inside the dashboard process. If the dashboard isn't running, messages won't be delivered. Launch the dashboard first, then message.

What's Next

This guide covered the mechanics — install, register, start a crew, work through Data. For how the system works from the inside, the six-article series goes deeper:

Full reference documentation is at metateam.ai/docs.

Metateam turns "chat with a coding agent" into "work with a crew who remember."

Ready to start?

Register at metateam.ai and run metateam in your repo.