Ravi

Claude Squad

Overview

Claude Squad is a terminal UI that runs multiple AI coding agents — Claude Code, Codex, Gemini, Aider — simultaneously in isolated workspaces. Each session gets its own tmux pane, git worktree, and branch. Teams use it to parallelize coding tasks across a single codebase without merge conflicts or coordination overhead.

The problem it surfaces: when you run 5 agents in parallel, each one may need to authenticate independently — sign up for a SaaS tool, verify an email, complete a 2FA challenge, or call an authenticated API. Without an identity layer, agents either share credentials (insecure) or block waiting for human intervention.

Ravi solves this by giving each Claude Squad session its own provisioned identity: a real email address, a real phone number, and a scoped secrets vault. Agents can operate fully autonomously without exposing developer credentials or cross-contaminating inboxes.

How it works

Claude Squad uses git worktrees to give each session its own branch and working directory. Pair this with Ravi identities and each session also gets its own inbox, phone number, and credentials — a complete per-agent isolation boundary.

Session 1  →  worktree/branch-1  +  ravi identity: agent-1@yourdomain.com
Session 2  →  worktree/branch-2  +  ravi identity: agent-2@yourdomain.com
Session 3  →  worktree/branch-3  +  ravi identity: agent-3@yourdomain.com

Each agent can sign up for services, receive OTPs, complete MFA flows, and store credentials — independently, without race conditions or shared state.

Prerequisites

Install Claude Squad and the Ravi CLI:

# Claude Squad
brew install claude-squad
ln -s "$(brew --prefix)/bin/claude-squad" "$(brew --prefix)/bin/cs"

# Ravi CLI
brew install ravi-hq/tap/ravi
ravi auth login

Claude Squad requires tmux and gh:

brew install tmux gh

Setup

1. Create Ravi identities for your sessions

Create one Ravi identity per parallel session you plan to run. Identities are persistent — create them once and reuse across runs.

ravi identity create --name "agent-1"
ravi identity create --name "agent-2"
ravi identity create --name "agent-3"

Each identity gets a unique email address and phone number. List them:

ravi identity list --json

2. Launch sessions with identity context

Use a wrapper script to inject Ravi identity credentials into each Claude Squad session environment. Claude Squad’s --program flag lets you specify a custom launch command per session.

Create ~/.claude-squad/launch-with-ravi.sh:

#!/bin/bash
# Usage: launch-with-ravi.sh <identity-name> <agent-command>
IDENTITY=$1
shift

# Get identity credentials from Ravi
EMAIL=$(ravi identity use "$IDENTITY" && ravi get email --json | jq -r .email)
PHONE=$(ravi identity use "$IDENTITY" && ravi get phone --json | jq -r .phone)

export RAVI_IDENTITY="$IDENTITY"
export RAVI_EMAIL="$EMAIL"
export RAVI_PHONE="$PHONE"

exec "$@"

Launch individual sessions:

cs -p "~/.claude-squad/launch-with-ravi.sh agent-1 claude"

3. Configure profiles for multi-agent runs

In ~/.claude-squad/config.json, define one profile per identity:

{
  "default_program": "agent-1",
  "profiles": [
    {
      "name": "agent-1",
      "program": "~/.claude-squad/launch-with-ravi.sh agent-1 claude"
    },
    {
      "name": "agent-2",
      "program": "~/.claude-squad/launch-with-ravi.sh agent-2 claude"
    },
    {
      "name": "agent-3",
      "program": "~/.claude-squad/launch-with-ravi.sh agent-3 claude"
    }
  ]
}

When you create a new session in Claude Squad (n), the profile picker lets you select which identity to attach.

What Ravi enables per session

Email verification and OTPs

Each session’s agent can check its own inbox for verification emails without interfering with other sessions:

# Agent running in session 1
ravi identity use agent-1
ravi inbox email --unread --json
ravi inbox sms --unread --json

No two sessions share an inbox. OTPs land in the right place.

Autonomous service signups

When an agent evaluating a SaaS tool needs an account:

ravi identity use agent-1
EMAIL=$(ravi get email --json | jq -r .email)
PHONE=$(ravi get phone --json | jq -r .phone)
PASSWORD=$(ravi passwords create example.com --json | jq -r .password)
# Agent fills signup form, waits for OTP, completes verification

Real credentials. No developer exposure. Stored in the agent’s scoped vault.

Scoped secrets per session

Each Ravi identity has its own secrets vault. Store session-specific API keys or tokens:

ravi identity use agent-1
ravi vault set STRIPE_TEST_KEY sk_test_abc123

The other sessions’ vaults remain untouched.

MFA and 2FA flows

Services requiring TOTP or SMS 2FA are no longer blockers. The agent reads its own SMS inbox or TOTP codes mid-task:

ravi inbox sms --unread --json | jq -r '.messages[0].body'
# Extract the 6-digit code and continue

Running unattended with --autoyes

Claude Squad’s --autoyes flag (yolo mode) lets sessions run completely unattended — agents accept all prompts automatically. Combined with Ravi, agents can complete multi-step workflows that require authentication without any human in the loop:

cs --autoyes -p "~/.claude-squad/launch-with-ravi.sh agent-1 claude"

Why Ravi adds value here

Parallel agents amplify both productivity and identity risk. Without Ravi:

  • Agents share credentials — one session’s signup contaminates another’s inbox
  • OTPs get lost or intercepted across sessions
  • Developers must expose real email/phone to agents
  • 2FA flows block unattended execution

With Ravi:

  • Isolation: each session operates with a clean, independent identity
  • Auditability: every email, SMS, and credential operation is logged per identity
  • No credential exposure: developer credentials never enter the agent environment
  • Scale: create as many identities as sessions — Ravi handles provisioning

The pattern extends naturally: one codebase, five parallel agents, five isolated identities, zero coordination overhead.

Next steps