relay_url = "https://relay.example.com"

<div align="center">

<p><img src="./logo.png" alt="Rig" width="400" /></p>

<h3>The best of Pi, Codex, Claude Code, Kimi Code, and Grok Build — unified in one coding-agent harness.</h3>

<p>
  Use model-native prompts and tools with provider access already configured on
  your machine. Rig adds no account or subscription of its own, never pools or
  resells provider access, and leaves provider terms and limits in force. 
  
  Built by the authors of
  <a href="https://github.com/slopus/happy">Happy</a> and
  <a href="https://github.com/slopus/happy2">Happy 2</a>.
</p>

https://github.com/user-attachments/assets/99a7dee6-36ef-4110-95b2-e236633640a4

<p>
  <a href="#quick-start">Quick start</a> ·
  <a href="#why-rig">Why Rig?</a> ·
  <a href="#how-rig-compares">Compare</a> ·
  <a href="#configuration">Configuration</a> ·
  <a href="DEVELOPMENT.md">Development</a>
</p>

</div>

Rig is an open-source coding-agent harness built on top of
[Pi](https://github.com/earendil-works/pi)'s foundations. It recreates the best
parts of [Codex](https://github.com/openai/codex),
[Claude Code](https://code.claude.com/docs/en/overview),
[Kimi Code](https://code.kimi.com), and
[Grok Build](https://github.com/xai-org/grok-build) in one consistent local
runtime: the right prompts and tools for each model, useful defaults, safe
execution, durable sessions, subagents, MCP, and a friendly terminal interface.

The result is one harness that works well on its own and exposes a stable layer
for future client integrations. Apps can integrate once instead of maintaining
a different adapter for every coding agent.

## Quick start

### Step 1: Install Rig

```sh
npm install -g @slopus/rig
```

### Step 2: Sign in to the agents you want to use

Rig does not have another account to create. Run the coding agents you want and
complete their normal sign-in:

```sh
codex
claude
kimi login
grok login
```

Rig then uses the credentials already managed by those installations. The daemon
checks local credential presence when it starts without contacting provider
servers. Restart the daemon after a new login so the provider enters the model
catalog. Once enabled, Kimi and Grok credential rotations are hot-reloaded from
their local auth stores without copying tokens into Rig.

### Step 3: Start building

```sh
cd your-project
rig
```

Ask for what you want in plain English. Rig can inspect the repository, edit
files, run commands, delegate work, and verify the result. Use `/model` at any
time to choose an available model.

### Optional: Connect Happy mobile

Happy is enabled for the normal Rig CLI by default. Disable it machine-wide in
`~/Happy/Config/happy.toml` on macOS or `~/happy/config/happy.toml` on Linux,
then restart the daemon:

```toml
[settings]
happy_integration = false
```

Development runs disable Happy synchronization by default so local builds do
not appear as mobile machines or mirror test sessions. Set
`RIG_DISABLE_HAPPY_SYNC=0` to opt a development run back in. Any Rig host can
force the integration off with `RIG_DISABLE_HAPPY_SYNC=1`; this overrides the
configuration file.

Repository `rig.toml` files (or fallback `happy.toml` files) cannot enable or disable this machine-level
integration. When enabled, Rig automatically imports newer credentials from
`~/.happy` when its daemon starts. To authenticate directly from Rig instead,
run:

```sh
rig happy auth
```

Scan the QR code with Happy. Terminals with Kitty or iTerm2 image support show
a PNG QR code; other terminals get Happy's compact text QR. Every primary Rig
session you open is then synchronized live with Happy. Mobile messages enter
the same session and permission boundary as terminal messages; there is no
separate local/remote control mode.
Happy can also send encrypted image attachments, stop the active turn, and
select any provider-qualified Rig model and supported reasoning level.

## Why Rig?

Pi is a wonderfully small, flexible foundation. Codex, Claude Code, Kimi Code,
and Grok Build each add excellent model-specific behavior, but they expose different
tools, permissions, session models, and integration protocols. Rig brings those ideas together
without making you rebuild the setup for every model, machine, or repository.

- **Feels native to the model.** GPT receives Codex-style prompts and tools;
  Claude receives Claude Code-style prompts and tools; Kimi receives its coding
  prompt and Chat Completions contract; Grok receives the open-source Grok Build
  prompt and tool contracts.
- **One dependable workflow.** Sessions, permissions, MCP, Docker, background
  commands, reviews, goals, and headless execution work through one interface.
- **Thoughtful defaults.** A fresh install is useful immediately, while global
  and project-local configuration remain available when you need them.
- **Ready for other clients.** A local daemon, persisted sessions, and a durable
  event stream let terminal, mobile, and web clients build on the same runtime.
  The [remote terminal A

... (truncated)