RAPID Overview

RAPID is an orchestration layer for AI-assisted development. It manages the complexity of running AI coding tools, providing magic defaults that work out of the box.

The Problem

AI coding assistants are powerful but require significant setup:

Environment Consistency — AI tools need consistent environments to work reliably
Context Preparation — Agents perform better with proper documentation and project context
Secret Management — API keys must be injected securely, not committed to repos
Container Isolation — Running AI agents in containers provides security boundaries
Tool Fragmentation — Each AI tool (Claude, OpenCode, Aider) has different setup requirements
Multi-Agent Coordination — Running multiple AI agents requires manual orchestration

Setting this up for each project is tedious, error-prone, and often results in inconsistent experiences.

The Solution

RAPID provides a zero-config experience with smart defaults:

rapid init    # Interactive setup with sane defaults
rapid dev     # Everything starts automatically

That’s it. No manual configuration, no service management, no authentication prompts.

What `rapid init` Does

Interactively configures your project with smart defaults
Sets up MCP servers (context7, tavily, and the RAPID MCP server)
Configures secrets management (1Password, Vault, or env vars)
Generates instruction files (CLAUDE.md, AGENTS.md)
Creates devcontainer configuration if desired

What `rapid dev` Does

Auto-starts services — Event bus, RAPID MCP server, containers
Auth passthrough — Uses your existing Claude/OpenAI credentials
Launches your AI agent — With full MCP tool access
Enables multi-agent features — Agents can communicate via the event bus

What `rapid stop` Does

Gracefully exits AI CLI sessions
Stops dev container and services
Cleans up temporary resources

Core Principles

1. Magic Defaults

Everything works out of the box:

Event bus enabled by default — agents can communicate immediately
Auth passthrough — use your existing Claude/OpenAI credentials
RAPID MCP server — always available for agent coordination
YOLO mode — skip permission prompts in isolated environments

2. Wrap, Don’t Reinvent

RAPID wraps existing AI coding tools rather than building another one. Claude Code, OpenCode, and Aider are excellent tools — RAPID makes them easier to use consistently.

3. Configuration as Code

Everything is defined in rapid.json:

Which AI agents are available
How secrets are loaded
What context files to include
Container and MCP server configuration

4. Secure by Default

Secrets never stored in plaintext
Containers provide isolation
API keys injected at runtime only
Sandboxed command execution available

5. Multi-Agent Coordination

Run multiple AI tools that work together:

Event bus — agents communicate in real-time via Redis
Shared context — all agents see the same project state
Task delegation — agents can request help from each other
Presence tracking — know which agents are active

The RAPID Methodology

Beyond tooling, RAPID embodies a methodology for effective AI-assisted development:

Research (R)

Before engaging AI, gather context:

Read existing documentation
Understand codebase structure
Identify patterns and conventions
Review related implementations

Augment (A)

Enhance gathered context with external knowledge:

API documentation
Framework references
Design patterns
MCP server integrations

Plan (P)

Structure work before execution:

Break complex tasks into steps
Define acceptance criteria
Identify dependencies
Create todo lists

Integrate (I)

Ensure environment is ready:

Start dev containers
Load secrets
Verify tooling
Setup services

Develop (D)

Execute with AI assistance:

Generate code
Test implementations
Iterate on feedback
Review and refine

Key Features

Auth Passthrough

RAPID automatically detects your existing AI tool credentials:

Claude Code — Uses ~/.claude.json OAuth tokens
OpenAI — Uses ~/.openai or environment variables
Anthropic API — Uses ~/.anthropic configuration

No need to configure API keys if you’re already logged in. See Auth Passthrough for details.

Event Bus

Multiple agents can communicate in real-time:

Claude: "I've designed the auth module"
  → sends task_complete to event bus

OpenCode: Sees notification, picks up implementation
  → sends review_request when done

The event bus uses Redis (auto-managed) and is enabled by default. See Event Bus for details.

RAPID MCP Server

A centralized MCP server provides all agents with shared tools:

Tool	Description
`bus_register`	Register with the event bus
`bus_send`	Send messages to other agents
`bus_messages`	Retrieve messages
`bus_agents`	List connected agents
`secure_exec`	Execute sandboxed commands
`get_secret`	Access secrets securely

The server runs centrally so all agents share state. See MCP Servers for details.

YOLO Mode

In isolated environments (containers, VMs), agents can skip permission prompts:

{
  "agents": {
    "available": {
      "claude": { "yolo": true }
    }
  }
}

This dramatically speeds up development cycles. See Agent Configuration for details.

Comparison to Manual Setup

Task	Manual	With RAPID
Initial setup	Write configs, install tools	`rapid init`
Start everything	Multiple commands, manual order	`rapid dev`
Authentication	Configure API keys everywhere	Auth passthrough
Load secrets	Export vars, source .env, etc.	Automatic
Generate context files	Write AGENTS.md manually	Auto-generated
Multi-agent comms	Build your own message system	Event bus included
Switch AI tools	Exit, configure, restart	`rapid dev --agent`
Run multiple agents	Manual tmux setup	`rapid dev --multi`

When to Use RAPID

Good fit:

Teams wanting consistent AI-assisted workflows
Projects requiring secure secret management
Developers using multiple AI tools
Multi-agent workflows requiring coordination
Organizations with container-based development

Not necessary:

Single-file scripts or quick experiments
Projects not using containers or isolation
When using only one AI tool without secrets

Auth Passthrough — How credential detection works
Event Bus — Inter-agent communication
Agent Integration — How agents connect to RAPID
Container Lifecycle — Container management