From setup to your first handoff.

Claude Code and Codex are supported; the CLI runs from this repository and is not published to npm yet.

You need an invitation. A teammate invites you from their team page, by GitHub username or email address, and sends you the link — or Anva emails it, where an email provider is configured. Only that one account can accept it, invitations last seven days, and whoever sent it can withdraw it. There is no code that lets anyone in.

Open the link, sign in with GitHub, and join. Then link the computer whose sessions you want to share:

npm run anva -- login --server <team-server-url>

That prints a URL. Open it, check the machine name is yours, and authorize it. Nothing is typed at the terminal and nothing names you, so the machine ends up on the account you are already signed in as rather than a second one. Use HTTPS for a shared server.

Run npm run anva -- workspace to check the destination. If you belong to multiple teams, select one with npm run anva -- workspace <workspace-id> before syncing.

Then choose what it may upload — nothing syncs until you do:

npm run anva -- scope add ~/dev/your-project
npm run anva -- watch --install

Already signed in and in a hurry? Machines → “Link this machine” copies a single command with a one-time token in it, which skips the browser round trip. Keep that token private.

The workspace brings your team’s shared Claude Code and Codex sessions together. Sessions are grouped into projects using the repository’s git remote, so different folder paths on different machines still map to the same project.

Open a session to read its messages and follow its branch and activity. Membership belongs to the workspace: teammates join once to access its projects, rather than receiving a separate invitation for every repository.

The handoff inbox shows work waiting to be picked up. An offer can go to a specific teammate or remain open to the workspace.

Folder scope is explicit. An empty scope list uploads nothing. Add only repositories you intend to share; Anva reads the session files your coding agents already create.

npm run anva -- scope add ~/dev/your-project
npm run anva -- sync
npm run anva -- watch

Use sync for one upload pass or watch to keep syncing. Transcript secrets matching the local redaction rules are removed before upload. Redaction is pattern based; review the material you share and keep credentials out of source files.

Uploading and sharing are separate. Sessions are private by default. Share an individual session, or enable sharing for your future sessions in a repository on its project page. Sharing existing sessions is a separate action that shows how many it will publish. Handing off a session also shares it with the team.

1. Stop your local coding agent so the checkout stays stable. In the session, choose a teammate (or Anyone) and select Hand off.
2. Keep the sender’s linked machine and sync process running. The brief job runs there using the sender’s Claude Code login, and Anva captures the code for the handoff.
3. The receiver reviews the brief in their inbox and selects Pick up this work.
4. The receiver resumes into their own local checkout using the command below.

npm run anva -- resume --repo ~/dev/your-project
# Or continue with Codex:
npm run anva -- resume --repo ~/dev/your-project --agent codex

Resume checks the repository identity, fetches the handoff from that checkout’s origin, verifies the recorded commit, and creates a separate worktree. The brief is written to .anva/HANDOFF.md and loaded into the selected agent. Use --no-launch to prepare the checkout without starting an agent.

Uncommitted work can travel too. Anva captures eligible edits and new files in a snapshot commit and publishes it to refs/anva/handoffs/<id> on origin. The sender’s branch, index, and working files stay in place. Both teammates need access to the git remote.

Ignored files are excluded. Tracked credentials are not protected by adding them to .gitignore; snapshot checks also refuse detected secrets and snapshots over 25 MB. Stop editing while the handoff is being prepared so the brief matches the captured code.

Senders can cancel an open offer; recipients can decline. Drafts expire after 30 minutes and pending offers after seven days. Expired offers cannot be accepted.

A brief captures what changed, the decisions behind it, approaches already tried, and open questions. Claims can carry references such as msg:12, tool:<uuid>, and sha:abc123.

The server checks those references against the session record. References to missing messages or another session are removed. If a claim has no valid reference left, it is labelled inference. Select a citation chip to inspect the source in context.

Changes are parsed from the real diff. A valid citation establishes traceability; it does not guarantee that a model’s interpretation is correct. Review the brief and its open questions before continuing.

Anva’s MCP server lets a coding agent consult work shared with your workspace. It uses the linked machine’s token and inherits your access.

• anva_search finds decisions and context in shared sessions.
• anva_digest summarizes recent team activity from the record.
• anva_handoffs lists work waiting for you, with its brief.

The Anva checkout includes an MCP configuration for Claude Code. For another project, configure your MCP client with the absolute path to the Anva checkout:

{
  "mcpServers": {
    "anva": {
      "command": "npm",
      "args": ["--prefix", "/absolute/path/to/anva", "run",
        "--silent", "anva", "--", "mcp"]
    }
  }
}

For a direct terminal query, run npm run anva -- ask "Why did we choose this approach?". MCP results are attributed and fenced as untrusted data so another session’s text is not treated as instructions.

Workspace membership gates access to projects; teammates can read your sessions only when you share them. Machine tokens are stored as hashes, and synced transcripts pass through local secret redaction before upload.

Handoff snapshots move through your existing git remote. They are separate refs, not access controls: their visibility depends on the repository’s permissions. Share only repositories and sessions your workspace should be able to access.

Brief generation uses the sender’s local Claude Code login. The standard sync and handoff flow does not require giving Anva an inference API key. A Codex session can be synced and resumed, while brief generation currently requires Claude Code on the sender’s machine.

No sessions appear? Check the selected workspace, confirm the repository is in scope, and run npm run anva -- sync from the Anva checkout. Only supported agent sessions in allowed folders are uploaded. If your teammate cannot see a session you can open, check its sharing setting.

A brief is still preparing? Keep the sender’s machine and sync process running. Use npm run anva -- doctor to check the local Claude Code installation and sign-in.

Nothing to resume? Accept the handoff in the browser first. Confirm that the local checkout has the correct origin and that your git credentials can fetch it.

Trying Anva locally? Use Node 20+ and run the following from this repository. The local database uses PGlite; Docker is not required.

npm install
DATABASE_URL= MIGRATION_DATABASE_URL= npm run db:migrate
npm run db:seed
npm run dev:local

Open http://localhost:3100. This starts an isolated local app with PGlite and demo identities, even when .env.local contains production settings. Stop local dev servers before running migrations: two processes must not open the same PGlite database.