Ravi

Introduction

What is Ravi?

Ravi is an identity provider for AI agents. One API call creates an Identity — a coherent online persona an agent can use to communicate, store credentials, and authenticate with services.

:::caution[The problem Ravi solves] Without Ravi, your agents run as you. Same email address, same phone number, same credentials. That creates three concrete problems:

  1. Security exposure — your agent has access to every email you’ve ever received, every service you’re logged into
  2. Broken isolation — you can’t tell which action came from you vs. the agent; audit logs are meaningless
  3. Blocked verification flows — services send OTPs and verification emails to a real inbox; agents can’t intercept them from your Gmail without granting full account access

Ravi gives each agent its own email, its own phone number, and its own credential vault — completely separate from yours. :::

Where do you want to go?

GoalStart here
Get a working agent in 5 minutesQuick Start
Run multiple agents in parallelMulti-Agent Setup
Use Ravi without a GUI (headless / CI / Docker)Authentication → CI setup
Understand what an Identity actually isCore Concepts → Identities
Find a specific CLI commandCLI Reference
Add Ravi to an existing orchestrator or frameworkBuild an Integration
Integrate with a named toolIntegrations

What you get

Each Identity bundles everything an agent needs:

CapabilityHow it works
EmailAuto-generated address per Identity — send, receive, and thread conversations
Phone & SMSDedicated phone number for receiving verification codes and SMS
Credential vaultE2E-encrypted password storage per Identity (zero-knowledge)
Secret vaultE2E-encrypted key-value store for API keys and environment variables
TOTPBuilt-in 2FA code generation for services that support authenticator apps

The core abstraction

An Identity is not an Agent. An agent is the software; an Identity is the persona it wears. One agent can have multiple identities. One identity can be handed between agents. They’re separate concepts.

Think of it like a SIM card: the agent is the phone, and the Identity is the SIM. You can move a SIM between phones. Multiple phones can share the same account but each gets its own SIM with its own number, inbox, and stored contacts. If you burn the phone (delete the agent), the SIM (Identity) and everything on it can survive.

For developers with an AWS background: same idea as IAM roles vs. the applications that assume them — the Identity is the role, the agent is the application.

Identity
├── Email address (auto-generated, receives real email)
├── Phone number (receives SMS, OTPs)
├── Credential vault (E2E-encrypted username/password/notes per service)
├── Secret vault (E2E-encrypted key-value secrets)
└── TOTP secrets (generates 2FA codes for enrolled services)

Integrating into an existing agent framework?

If you’re adding Ravi to an existing orchestrator, harness, or framework (rather than building from scratch), the fastest path is the machine-readable spec:

curl https://docs.ravi.app/llms.txt

/llms.txt covers every CLI command, API endpoint, environment variable, parallel-agent pattern, and common error in a single flat file — readable by both humans and AI coding agents. The Build an Integration guide walks through the four steps: provision an identity, use it in a workflow, retrieve credentials, and handle failures.

Framework integrations don’t require the CLI at all — see TypeScript REST API, Python & Production Patterns, and the MCP server for tool-call-based access.

Why not existing tools?

ApproachProblem
Share your personal accountsSecurity risk — agent sees all your email, credentials exposed
1Password for agentsRequires desktop app, biometric gates, tmux hacks — architecturally broken for autonomous operation
Plain text credentialsInsecure — credentials stored on disk in the clear
Email-only servicesNo credential storage, no 2FA — only solves part of the problem

Ravi is API-native. Two environment variables, no desktop app, no human-in-the-loop. Your agent runs autonomously.

See it in action

Create an Identity in one command:

ravi identity create --name "my-agent" --json
{
  "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "name": "my-agent",
  "inbox": "my-agent@in.ravi.app",
  "phone": "+15559876543"
}

Your agent now has a real email address and phone number. Use them to sign up for services, receive OTP codes, and send email — all from an isolated Identity that doesn’t touch your personal accounts.

# Retrieve credentials at runtime
EMAIL=$(ravi get email --json | jq -r '.email')
PHONE=$(ravi get phone --json | jq -r '.phone_number')

Works anywhere — including headless. Ravi is designed for autonomous operation: no desktop app, no browser required at runtime. Login uses a device-code flow you complete once; after that, all CLI commands run without user interaction. This makes Ravi safe to use in CI pipelines, Docker containers, background agent processes, and remote servers.

Next steps