Ravi

Aperant

Overview

Aperant is a cross-platform Electron desktop app that wraps Claude Code in a full autonomous coding workflow. It runs up to 12 parallel agent terminals in isolated git worktrees, coordinates planning and QA loops, and integrates with GitHub, GitLab, and Linear to pull issues and push merge requests — a full autonomous dev cycle with minimal human intervention.

Aperant solves execution exceptionally well. What it doesn’t solve is authentication and identity when agents need to operate beyond the local repository. Ravi fills that gap: persistent identities, a credential vault, dedicated email addresses, and phone numbers — one per agent slot.

The problem Ravi solves

With up to 12 agents running in parallel, each may need to:

  • Authenticate to external APIs (GitHub, npm, deployment platforms)
  • Complete email verification when spinning up a new SaaS trial
  • Receive an SMS OTP from a cloud provider
  • Store credentials discovered during a task without leaking them to other agents

Without Ravi, tokens sprawl across dotfiles, email flows require human interruption, and there’s no clean way to give each agent distinct credentials for the same service.

How it works together

One Ravi identity per agent terminal

Ravi supports multiple named identities, each with its own email address, phone number, and secrets vault. Map one identity to each Aperant agent slot:

Aperant TerminalRavi IdentityEmailVault
Agent 1agent-build-1build-1@in.ravi.appisolated
Agent 2agent-build-2build-2@in.ravi.appisolated
Agent 3agent-deploy-1deploy-1@in.ravi.appisolated
…………

Each agent authenticates to external services under its own identity, with full auditability of which agent touched what.

Credential vault at runtime

Instead of embedding API tokens in config files or environment variables, Aperant agents fetch credentials from Ravi’s vault at task start:

# Fetch a GitHub token at runtime
GITHUB_TOKEN=$(ravi secrets get GITHUB_TOKEN)

# Fetch npm credentials
NPM_TOKEN=$(ravi secrets get NPM_PUBLISH_TOKEN)

Tokens are E2E encrypted at rest and scoped to the identity — one agent’s vault is inaccessible to another.

Email verification without human interruption

When an autonomous task involves spinning up a new service — a Vercel project, Cloudflare Worker, SaaS trial — agents hit signup walls requiring email verification. With Ravi, the agent uses its provisioned email address and polls for the verification link:

import subprocess
import json
import time

def get_verification_link(identity_email):
    # Agent signs up with its Ravi email address
    # Then polls for the verification message
    for _ in range(12):  # 60-second window
        result = subprocess.run(
            ["ravi", "email", "list", "--unread", "--json"],
            capture_output=True, text=True
        )
        threads = json.loads(result.stdout)
        for thread in threads:
            if "verify" in thread["subject"].lower():
                # Read and extract the link
                return extract_link(thread["thread_id"])
        time.sleep(5)
    return None

The agent completes the full signup flow — no human needs to check an inbox.

SMS OTP for cloud providers

Many cloud providers (AWS, GCP, Twilio) send SMS codes during account setup. Ravi’s provisioned phone numbers let agents receive and read these codes programmatically:

def get_sms_otp(identity_phone):
    time.sleep(10)  # Allow delivery
    result = subprocess.run(
        ["ravi", "sms", "list", "--unread", "--json"],
        capture_output=True, text=True
    )
    conversations = json.loads(result.stdout)
    for conv in conversations:
        messages = get_messages(conv["conversation_id"])
        for msg in messages:
            match = re.search(r'\b\d{4,8}\b', msg["body"])
            if match:
                return match.group()
    return None

Setup

1. Install Ravi CLI

npm install -g @ravi-hq/cli
ravi login

2. Create identities for your agent slots

# Create one identity per Aperant agent slot
ravi identity create --name "agent-build-1" --email "build-1"
ravi identity create --name "agent-build-2" --email "build-2"
ravi identity create --name "agent-deploy-1" --email "deploy-1"

Each identity gets a unique email address and phone number.

3. Seed the vault with shared credentials

# Store credentials each agent will need
ravi secrets set GITHUB_TOKEN ghp_yourtoken --identity agent-build-1
ravi secrets set GITHUB_TOKEN ghp_yourtoken --identity agent-build-2
ravi secrets set ANTHROPIC_API_KEY sk-ant-... --identity agent-build-1

4. Configure Aperant task context

In Aperant’s task description or injected context, include the identity name for that terminal slot. The agent can then switch to the correct Ravi identity at task start:

ravi identity use agent-build-1

All subsequent ravi calls operate under that identity’s vault and inbox.

Identity badge in the UI

The Aperant interface could expose a small identity badge per terminal — “this agent is operating as build-1@in.ravi.app” — giving users full auditability of which agent authenticated where. This transforms Aperant from a code runner into a credentialed autonomous operator, the distinction that matters when you’re deploying, not just building.

Why Ravi over shared dotfiles

Shared dotfiles / env varsRavi per-agent identities
Credential isolation❌ All agents share same tokens✅ Each agent has its own vault
Email verification❌ Requires human✅ Agent receives and reads independently
SMS OTP❌ Requires human✅ Agent reads from provisioned number
Audit trail❌ No record of which agent authenticated where✅ Full per-identity history
Rotation❌ Manual, risky✅ Update vault once, all agents pick up
Multi-account testing❌ Complex workarounds✅ Distinct identity per slot

Next steps