Runquay is an open-source orchestrator for AI coding agents. It runs the official Codex, Claude Code, Gemini CLI and Antigravity CLI tools on your own machine, turning project goals into a durable task queue with bounded milestones, checkpoints, isolated account profiles and explicit approval before any paid invocation.

Does Runquay need its own API key or subscription?

No. Runquay requires no account, no telemetry and no separate model API key. It drives coding CLIs you have already installed and signed into, so the accounts, requirements and costs are the vendors' own.

What happens when an agent hits its usage limit?

For Claude Code, Runquay pauses that profile for an hour, selects the next connected profile, and asks for a new one-run approval before continuing. For Codex it checks quota before each milestone and switches at a configurable reserve. Work resumes from the checkpoint files rather than from conversation history.

Can it run multiple accounts at once?

You can add as many profiles as you need, but one worker runs at a time. Profiles are isolated through each tool's own configuration directory — CODEX_HOME, CLAUDE_CONFIG_DIR, GEMINI_CLI_HOME — and Runquay never requests passwords, copies auth files or exports vendor sessions.

Which operating systems does it run on?

Windows, macOS and Linux including Ubuntu, on Python 3.11+. Local verification covers Windows and Ubuntu 24.04 under WSL; macOS startup is definition-tested and still needs a run on real hardware.

Is it safe to expose the dashboard?

No, and it is not designed for it. The dashboard binds only to loopback and validates Host and Origin specifically to prevent that. Do not put it behind a proxy or tunnel.

Runquay

Overview

Running coding agents by hand means babysitting them: a terminal per tool, a context window that forgets, and a usage limit that stops the work halfway through a change. Runquay puts a durable queue in front of the official CLIs you already have installed. Work is broken into bounded milestones, each writes a checkpoint to disk, and every invocation that could cost money asks first. The dashboard and the orchestration stay on your machine — only the coding requests themselves reach your chosen provider.

What it does

One durable, prioritised queue across Codex, Claude Code, Gemini CLI and Antigravity CLI
Every milestone writes a checkpoint file, so a later run continues from disk rather than from conversation history
Isolated per-tool account profiles — separate CODEX_HOME, CLAUDE_CONFIG_DIR and GEMINI_CLI_HOME
Codex quota checks before each milestone, with a configurable reserve that fails closed
Claude Code usage-limit handoff: pauses the limited profile, selects another, and asks for fresh approval
Explicit per-task tool selection — no silent cross-provider fallback and no copying of conversation history
Local SQLite state and a dashboard bound only to 127.0.0.1 with Host/Origin validation and CSRF checks

Quickstart

Start the dashboard

From the extracted folder. Use python3 on macOS and Linux; Windows users can double-click start.cmd.

python runquay.py start

Open it

The browser opens automatically; this is the fallback.

http://127.0.0.1:8765/

Run as a user service (optional)

Startup is opt-in and per user — Task Scheduler on Windows, a LaunchAgent on macOS, a user systemd unit on Linux.

python runquay.py service preview
python runquay.py service install
python runquay.py service uninstall

Check the install

python runquay.py doctor

What each adapter actually supports

Runquay drives the official CLIs rather than reimplementing them, so what it can do per tool is bounded by what that tool exposes headlessly. The table below is the honest version — several adapters are contract-tested rather than live-tested, and the project says so.

Tool	Execution and account handling
`Codex`	Native exec with same-profile resume; separate CODEX_HOME profiles; quota guard tested
`Claude Code`	Print JSON with same-profile resume; CLAUDE_CONFIG_DIR profiles; limit-triggered handoff
`Gemini CLI`	Headless JSON with edit-approval mode; separate GEMINI_CLI_HOME profiles
`Antigravity CLI`	Print JSON and vendor sandbox; current login, custom wrapper for isolation
`Other headless tools`	Custom argv, prompt on stdin, checkpoint JSON on stdout

Why checkpoints instead of conversation history

A coding agent's context is the first thing lost when a run ends — at a usage limit, a timeout, or a switch to a different account. Carrying the conversation across is not generally possible and, where it is, it is not reliable.

Runquay takes the other route. Each turn completes one milestone, runs checks, and writes an AUTOWORK_CHECKPOINT.md alongside a structured result. A later run — on a different profile, or a different tool entirely — picks up from those files and the project's own Git history. Nothing depends on a session that may no longer exist.

The trade is deliberate: a handoff loses conversational nuance and keeps the working state. For long-running work that is the half worth keeping.

Approvals, quotas and the spending boundary

The part that matters when software is allowed to invoke paid tools on your behalf is what it will do without asking. Runquay's answer differs per provider, because what each provider lets you check differs.

Codex exposes official quota checks, so Runquay runs them before each milestone and every fifteen seconds. At the reserve — 90% used by default — it stops and selects another eligible profile. Positive or unknown paid balances fail closed rather than proceeding.

Claude Code cannot be checked before a run, so every invocation needs approval. If its CLI explicitly reports a usage limit, Runquay pauses that profile for an hour, moves to the next connected one, and asks again. It does not silently rerun a milestone that may have partly completed.

For other tools, billing is unverified and each invocation, milestone and retry needs explicit approval. The project is blunt that polling is not an atomic spending guarantee.

What stays on your machine

The dashboard binds only to 127.0.0.1, validates Host and Origin, rejects cross-site loads, and uses an HttpOnly SameSite cookie with CSRF checks and a restrictive content policy. State is local SQLite; run logs are private. Runquay itself requires no account, no telemetry and no separate model API key.

What it cannot do is change the trust boundary of the tools it runs. Processes running as your OS user share that boundary, vendor CLIs keep their own credentials on disk, and the custom adapter adds no sandbox of its own.