Redline

Never waste your AI subscription quota again.

Redline watches your Codex and Claude allowances and dispatches queued agent jobs when there's capacity to spare - with an explanation for every decision.

▶ Watch the 1-minute video · Read why I built it

You're paying for a Codex or Claude subscription. Every five hours or every week, your quota
resets - and whatever you didn't use is gone. Redline watches those allowances and lets you queue
up the work that's always on your backlog: test gaps, refactors, dependency bumps, doc sweeps. When
you're comfortably behind on usage or running out of time before a reset, Redline fires up one of
those jobs using your coding agent of choice (Codex CLI, Claude Code, Pi, whatever you've got).

Jobs are called tasks in the CLI and API; the dashboard and this page say job.

Why Redline

• Every decision is explained. Each cycle records RUN, WAIT, or fail-closed UNKNOWN
  with the reasoning, so you always know why a job did or did not start.
• Safe by default. Automatic dispatch is off until you turn it on. A configured reserve (a
  slice of your allowance Redline will never spend) is always held back for your interactive
  work, and stale telemetry means wait, never run.
• Works with your agents. Codex CLI, Claude Code, Pi, Hermes, or any command. Redline does
  not replace your harness; it decides when to launch it.
• Isolated by design. Jobs run in Git worktrees or DevX sessions, and completed runs keep
  their result, artifacts, and logs so unattended work does not disappear.
• Local only. A loopback service, a SQLite file, and your existing CLI logins. No cloud, no
  account, no telemetry.

Install

macOS app (recommended)

Requires macOS 13 or later. Universal binary, signed and notarized.

brew install --cask croutoncreations/tap/redline

Or download the DMG, drag
Redline to Applications, and launch it. The menu-bar app bundles the service, dashboard, and
CLI; a four-step guide walks you through connecting an account, creating a profile, and queueing a
first job. Automatic dispatch stays off until you enable it.

→ Getting started in five minutes

CLI and headless service (macOS, Linux, Windows)

Run Redline without the menu-bar app - on a Linux box that dispatches overnight, for example.

brew install croutoncreations/tap/redline          # macOS / Linux
go install github.com/croutoncreations/redline/cmd/redline@latest

Or grab a prebuilt archive from Releases.
Linux and Windows builds are exercised in CI; Windows is newer and less battle-tested, so please
report anything odd.

curl -fsSLo redline.yaml https://raw.githubusercontent.com/croutoncreations/redline/main/config.example.yaml
# edit providers and policy, then:
redline --config redline.yaml serve   # dashboard at http://127.0.0.1:7436
redline status --provider codex-main

→ CLI reference · Run as a launchd service

Install with your coding agent

Paste this into a trusted local coding agent. It installs the signed release, keeps safe defaults,
discovers your existing harnesses, and proposes a couple of editable starter jobs without enabling
automatic dispatch on its own.

Help me install and configure Redline from the official Crouton Creations release:
https://github.com/croutoncreations/redline/releases/latest

Before changing anything, confirm this Mac meets the published requirements and show me the release
version and signing identity you intend to install. Download the notarized DMG and its SHA-256 file,
verify the checksum, copy Redline.app into /Applications, and launch it. Do not bypass Gatekeeper,
disable quarantine, install an unsigned build, or replace an existing configuration without asking.

In Redline, leave automatic dispatch disabled while we configure it. Check which of Codex CLI,
Claude Code, Pi, DevX, and Hermes are already installed; do not install or authenticate another
tool without asking. Reuse OpenUsage if its loopback API is healthy, otherwise let Redline use its
native collectors.

Walk me through creating one isolated execution profile for a repository I choose. Then suggest two
small, reviewable starter jobs based on that repository and my available harnesses. Show me each
editable prompt, provider, model, dispatch tier, recurrence, workspace behavior, and any command it
could execute. Ask before saving jobs and again before enabling automatic dispatch. Finish by
showing current allowance status, why the scheduler is waiting or running, where Redline stores its
configuration/database/logs, and how to pause all providers.

See Agent-assisted install for what the agent must not do.

How it works

  Monitor            Decide                 Dispatch              Review
  ───────            ──────                 ────────              ──────
  5-hour + weekly    policy + pace gap  →   next eligible job  →  result, artifacts,
  allowance per      RUN / WAIT / UNKNOWN   in an isolated        logs, lifecycle
  account            (explained)            workspace             events

1. Monitor. Redline reads the same 5-hour and weekly windows your CLIs see, reusing a local
   OpenUsage API when one is running or collecting natively
   when it is not.
2. Decide. A policy compares remaining allowance to remaining time. If you have more allowance
   left than an even burn pace would predict (the pace gap) by more than the policy's trigger,
   and the reserve is still intact, the provider is eligible. When a window is about to reset with
   allowance unspent (near expiry), Redline can release the reserve too rather than let it lapse.
3. Dispatch. Jobs unlock by tier (behind pace → well behind → capacity likely to expire),
   then by priority. Redline claims the job, prepares an isolated worktree or DevX session, and
   launches the harness - the coding-agent CLI the job's execution profile names. One job at a
   time unless you say otherwise.
4. Review. Completed runs keep a concise result, delivery artifacts (such as a draft PR link),
   bounded output, and a lifecycle timeline - in the dashboard, the menu bar, the CLI, or over MCP.

Claude - WAIT	Claude - RUN (near expiry)

More decision examples (Codex and Claude: WAIT, RUN, near expiry, UNKNOWN)

Codex WAIT	Codex RUN

Codex near expiry	Codex UNKNOWN

Claude RUN	Claude UNKNOWN

→ Scheduling and the allowance model explains policies, tiers, calibration,
and the token-capacity estimates in depth.

Give your agent access

Redline ships an MCP server so Codex, Claude Code, or Pi can check allowance, inspect the queue,
add jobs, and ask why is the scheduler waiting? without leaving the conversation.

# Claude Code
claude mcp add --scope user redline -- redline mcp

# Codex CLI
codex mcp add redline -- redline mcp

Use /Applications/Redline.app/Contents/Resources/bin/redline if the CLI is not on your PATH.
Read-only tools are the default; the single dispatch tool is annotated as mutating so hosts can
gate it.

→ MCP and agent guide - tool reference, Pi bridge setup, and a suggested agent
instruction.

More screenshots

Menu bar, active work, completed runs, and configuration

Native quick panel	Active work

Job configuration	Execution profile

All screenshots come from Redline's isolated synthetic demo mode and contain no personal
repositories, paths, credentials, or live allowance data.

Documentation

Using Redline	Reference
Getting started	CLI
Execution profiles and tasks	HTTP API
Scheduling and the allowance model	Architecture
Runs, logs, and notifications	Hermes integration
MCP and agent access	Native macOS app
Mobile dashboard · launchd	Outcome metrics
Troubleshooting	Changelog · Releasing
Agent-assisted install	LLM and coding-agent index

Contributing

Bug reports and pull requests are welcome. See CONTRIBUTING.md for building
from source, running the Go, Playwright, and Swift test suites, and packaging the macOS app.

License

Apache License 2.0 - see LICENSE.

---

_{Built by Crouton Creations. Get new open-source tools and builder notes when they ship.}