> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enagrams.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Team Onboarding

> Getting your whole team set up with shared agent coordination

## Overview

Enagrams is most powerful when every developer on the team connects their agent to the same workspace. This guide walks through onboarding a team of 2–10 developers.

## Workspace Setup (Owner)

### 1. Create the Workspace

Pick the path that matches where you are:

* **You have the repo cloned locally** — from the repo root, run `npx enagrams init`. The CLI authenticates you, binds the workspace to this repo, and writes all IDE configs in one shot.
* **You want to set it up before cloning** — create it in the [dashboard](https://enagrams.com/dashboard) with **New Workspace**, then click **Connect GitHub** on the new workspace and pick the repo. The Enagrams GitHub App resolves the repo fingerprint server-side and binds it for you.

See [Workspace Management → Creating a Workspace](/guides/workspace-management#creating-a-workspace) for all four paths and when to use each.

<Tip>
  If you create the workspace in the dashboard **without** the GitHub App, use the repo's basename as the slug (`github.com/org/chatgpt-wrapper` → `chatgpt-wrapper`). The CLI uses slug-matches-basename as the trigger for a one-keystroke **"bind this repo to `<workspace>`"** shortcut when a teammate runs `init`.
</Tip>

### 2. Invite Team Members

From the dashboard: **Workspace → Team → Invite** (enter email). The teammate gets an email with an accept link. Pick a role when you invite or change it later:

* **Owner** — full access, can delete workspace, bind/unbind repo.
* **Admin** — can manage members, bind/unbind repo, change settings.
* **Member** — can create decisions, claim work packages, use MCP.

<Note>
  Enagrams is invite-only — teammates can't join by guessing the slug or running `init` in the bound repo. The invite email is the only path in. See [Sharing a Workspace](/guides/workspace-management#sharing-a-workspace) for the full flow the teammate sees.
</Note>

### 3. Tell Teammates to Run `enagrams login`

Nothing to share manually — no slugs, no API keys, no invite codes. Once you've sent the dashboard invite, each teammate clones the repo and runs:

```bash theme={null}
npx enagrams login
```

The CLI fingerprints the repo, recognizes it's already bound to your workspace, and — because the teammate just accepted your invite — fast-paths them to a **"Continue with `<workspace>`"** prompt. One keystroke and they're in.

If a teammate runs `login` **before** you've sent the invite, they'll see:

```
This repo is exactly already bound to an Enagrams workspace:
  My Startup (my-startup)

  Ask one of its admins for an invite:
    • owner@example.com

Once you accept the invite, re-run `enagrams login`.
```

That's the hint — they forward it to you, you invite them, they retry.

## Per-Developer Setup

Once a teammate has accepted an invite:

```bash theme={null}
npx enagrams login   # authenticate + continue with the bound workspace
npx enagrams init    # (optional) drop IDE hooks + MCP configs for this repo
```

`init` detects the already-bound workspace and skips straight to writing IDE configs for whichever of Cursor, Claude Code, and Codex it finds installed. After that:

* IDE-specific tweaks: [Cursor](/guides/cursor-setup) · [Claude Code](/guides/claude-code-setup) · [Codex](/guides/codex-setup)
* `enagrams status` to verify the session is live.
* `enagrams watch` in a spare terminal for a live team dashboard.

Each developer gets their own API key automatically, stored in `~/.config/enagrams/config.json` (global, like `gh` or `vercel`) — never in the repo.

<Warning>
  Never share API keys. Each developer needs their own — it's how Enagrams tracks which human is behind each agent session.
</Warning>

## Running Your First Coordinated Session

### Scenario: Two developers, same codebase

**Developer A** starts a Cursor conversation:

> "Build the user authentication flow with JWT tokens. Open a workstream for it."

Their agent calls [`workstream_start`](/mcp/workstream-start) to create `ena/auth-jwt`, begins working, and acquires symbol-level reservations on the auth files.

**Developer B** starts a Cursor conversation soon after:

> "Add user registration to the API."

Their agent's briefing shows:

```
Active workstream you can join: ena/auth-jwt ("Build JWT auth flow")
  members: Developer A
  reserved symbols:
    src/auth/login.ts::validateToken    (Developer A, 8 min)
    src/auth/middleware.ts::requireAuth (Developer A, 8 min)

Recent decisions (1):
  Chose JWT for auth (Developer A, 5 min ago)
```

Developer B's agent joins the workstream with [`workstream_join`](/mcp/workstream-join) (if registration is the same effort) or starts a new one, builds registration compatible with the JWT decision, and avoids the locked symbols.

## Recommended Workflow

1. **Start of day** — open the [Activity Feed](https://enagrams.com/dashboard/feed) to see active agents and workstreams.
2. **Before a task** — check [Work Packages](/concepts/work-packages) for anything from recent meetings; claim what's yours.
3. **Working** — start or join a [workstream](/concepts/workstreams). Hooks handle locking automatically.
4. **Shipping** — call [`confirm_ready`](/mcp/confirm-ready) to run the [test gate](/concepts/test-gate), then `sync_commit` after committing. Teammates on `enagrams watch` get the change automatically.
5. **After a meeting** — paste the transcript at [Meetings](https://enagrams.com/dashboard/meetings) to extract decisions and generate work packages.

## Dashboard Views

| View            | URL                       | Purpose                                             |
| --------------- | ------------------------- | --------------------------------------------------- |
| Overview        | `/dashboard`              | Active agents, active workstreams, recent decisions |
| Activity Feed   | `/dashboard/feed`         | Real-time event stream                              |
| Workstreams     | `/dashboard/workstreams`  | Active branches, members, tasks                     |
| Decisions       | `/dashboard/decisions`    | Full decision timeline with stale flags             |
| Conventions     | `/dashboard/conventions`  | Tier-grouped team rules                             |
| Tasks           | `/dashboard/tasks`        | Per-workstream kanban                               |
| Negotiations    | `/dashboard/negotiations` | Open and resolved turns                             |
| Work Packages   | `/dashboard/packages`     | Meeting-derived task board                          |
| Team            | `/dashboard/team`         | Per-person drill-down                               |
| Knowledge Graph | `/dashboard/graph`        | Decisions connected by shared symbols               |
| Meetings        | `/dashboard/meetings`     | Transcript ingestion and history                    |