Turn AI coding agents into a visual Kanban build loop.
Describe a feature → generate a specification or brainstorm interactively → decompose into tasks → autonomous agent builds each task → you review via approve/reject gate.
All installers live on the latest release page — or run instantly with npx relay-studio (no install).
macOS note (manual download only):Installing via npm avoids this. If you instead downloaded the.dmg
/.zip
and see "app is damaged and should be moved to trash", run this in Terminal:
xattr -cr "/Applications/Relay Studio.app"
This removes the macOS quarantine flag. The app is not signed with an Apple Developer certificate yet.
relay-demo.mp4 #
Relay Studio is distributed via npm — no code-signing prompts, no quarantine command.
npx relay-studio
npm install -g relay-studio
relay-studio
The first run downloads the app for your platform (macOS Apple Silicon, Windows x64, Linux x64) and caches it under ~/.relay-studio/
. Later runs launch instantly.
Intel Macs: install via the
.dmg
from the[latest release](npm distribution is Apple Silicon only).
Prefer a classic installer? Every platform build is attached to the latest release:
| Platform | Asset | Notes |
|---|---|---|
| macOS (Apple Silicon) | ||
.dmg installer · .zip |
||
Run xattr -cr "/Applications/Relay Studio.app" after first launch (see note above) |
||
| Windows (x64) | ||
.exe (NSIS installer) · .zip |
||
| Choose install location during setup | ||
| Linux (x64) | ||
.AppImage |
||
chmod +x then run |
All assets are listed on the ** latest release** page.
Relay Studio is a desktop application that wraps AI coding agents into a structured, visual build workflow. Instead of manually prompting an AI and copy-pasting code, Relay automates the full cycle: planning, task decomposition, code generation, and review — all in a Kanban-style interface. Supports Claude Code and OpenAI Codex as execution engines.
Relay has two workspaces, switchable from the left rail:
Build— the feature-to-PR Kanban loop (spec → tasks → agent build → review gate).** Schedule**— a scheduler that runs agent jobs on your machine one-off or on a recurring cadence, chains them into reusable playbooks, and gates results behind an optional approval step.
Setup— Choose your engine (Claude Code CLI, OpenAI Codex CLI, or Anthropic API key) and open a project folder** Describe a feature**— Write what you want built in plain English, attach screenshots, reference project files with@filename
Specification or Brainstorm— Generate a spec directly, or brainstorm interactively with structured Q&A, approach proposals, and incremental design approvalTask decomposition— The spec or design document is broken into 3-10 structured tasks on a Kanban board** Build loop**— Start the agent and watch it build each task, streaming progress in real time** Review gate**— For each completed task, review the diff — approve to commit, or reject with notes to retry** Run your project**— Click the Run button to preview your app with auto-detected run commands** Code Review**— Run the AI code review agent to scan for security issues, performance problems, race conditions, and convention violations — then selectively fix themCreate PR— When all tasks complete, create a pull request directly from the app** Track progress**— Cost, tokens, build time, and first-pass success rate in the Summary view
Specification Wizard— AI-generated feature specs with streaming preview, clarification questions,@file
tagging, image paste support, and manual editingBrainstorm Mode— Interactive structured conversation: AI asks focused questions with multiple-choice options, proposes 2-3 approaches with trade-offs, presents design sections for incremental approval, then generates a design documentKanban Board— Drag-and-drop task management across Pending, Building, Human Review, and Complete columns** Agent Loop**— Autonomous code generation with /stop controls and three build modes:** for Review**— s after each task for human approve/reject** Auto-Pilot**— Commits each task automatically and continues** Continuous**— Builds all tasks without pausing; review at your own pace
Human Review Gate— Syntax-highlighted diff viewer with file tree, approve/reject flow, and git integration** Smart Review Detection**— Tasks with no file changes are auto-approved and skip the review gate
Two-Phase Review— Phase 1 analyzes the feature diff for issues (read-only); Phase 2 fixes selected issues in a single commit** Stack-Aware**— Auto-detects your tech stack (React, Express, Go, Python, Rust, etc.) and applies stack-specific review rules** Convention-Aware**— ReadsCLAUDE.md
,.cursorrules
, and other convention files to enforce your project's actual rules7 Review Categories— Security, Performance, Race Conditions, Error Handling, Best Practices, Conventions, Accessibility** 3 Severity Levels**— Critical, Warning, Info — with per-finding checkboxes and bulk select by severity** Selective Fixing**— Choose which findings to fix; the agent applies all selected fixes in one engine call, one commit** Model Selection**— Pick which model reviews your code before starting analysis** Fresh Context**— Each review phase runs on a clean context window, independent of the build loop** Works with All Engines**— Uses your selected engine (Claude Code, Codex, or API key) for both analysis and fixes
Run agent jobs on a schedule — the Schedule workspace in the left rail.
One-off & recurring jobs— Queue a job to run now, at a specific date/time, or on an hourly / daily / weekly cadence; recurring jobs auto-re-arm at their next occurrence when they finishBoard & Week views— Track jobs across Backlog, Queue, Running, Needs Approval, Done, and Failed columns, or see them laid out on a weekly calendar (click a slot to schedule there)Playbooks— Save reusable job templates, including multi-step chains where each step's output hands off to the next; run a playbook against any working directoryApproval gate— Flag a job to require approval; it s in a Needs Approval column where you can approve, edit the result, or reject — chained jobs stay blocked until the prior step clearsSkills— Attach a Claude library skill (personal~/.claude/skills
or installed plugin skills) to a job to shape how the agent worksUsage & cost— A usage panel with total tokens/cost, per-playbook and top-job breakdowns, and a daily trend** Keep awake**— Optional keep-awake toggle so scheduled jobs still run when the machine would otherwise sleep
Claude Code CLI(default) — Uses your existing Claude Code authentication via@anthropic-ai/claude-agent-sdk
OpenAI Codex CLI— Uses your existing Codex authentication via@openai/codex-sdk
Anthropic API Key— Direct SDK calls via@anthropic-ai/sdk
with built-in file toolsPersistent Sessions— Keep one Claude Code session alive across all tasks for 1M token context (reduces token waste)
- Type
@
in any text field to reference project files - Autocomplete dropdown with fuzzy search across git-tracked files
- Referenced file contents are injected into the AI prompt
- Available in feature descriptions, task descriptions, and acceptance criteria
Auto-detection— Detects run command frompackage.json
,Cargo.toml
,pyproject.toml
,go.mod
,docker-compose.yml
,Makefile
Custom override— Define your own command in.relay/run.json
Live output— Streams stdout/stderr in a tabbed panel with clickable URLs** Play/Stop toggle**— In the board header, right next to model picker
- Automatic branch creation with search/filter for base branch
.gitignore
management (auto-adds framework-specific patterns)- Commit on approve, push to remote, PR creation
- Feature rename, archive, and delete
Multi-Feature Support— Multiple specs per project with independent task backlogs** Add Tasks Manually**— "+" button in Pending column or 3-priority-column layout in wizard** Feature Rename**— Inline edit in board header** Feature Archive**— Archive completed features to keep workspace focused** Build Timer**— Live elapsed timer while a task is being built** Persisted Summaries**— Task duration, actions, and files changed survive app restart (loaded from DB + git)** Metrics Dashboard**— Per-task and aggregate stats including cost tracking with per-model breakdown** Dark / Light Mode**— Toggle in sidebar, respects system preference** Keyboard Shortcuts**—Space
to toggle the agent loop,Esc
to close panelsAuto-Updates— Built-in update checker for new releases** Per-Project SQLite**— All data stored locally in.relay/relay.db
inside your project folderDesktop Notifications— Get notified when tasks need review or the build finishes
Relay Studio supports three engine modes, selectable in Settings:
| Engine | Auth | Best For |
|---|---|---|
| Claude Code CLI (default) | ||
Uses existing claude login auth |
||
| Claude Code / Max plan users | ||
| OpenAI Codex CLI | ||
Uses existing codex login auth |
||
| Codex / ChatGPT Pro users | ||
| Anthropic API Key | ||
Your sk-ant-* key |
||
| Pay-per-token usage |
| Layer | Technology |
|---|---|
| Desktop shell | Electron 30 |
| Frontend | React 18, TypeScript, Tailwind CSS v4, shadcn/ui |
| State | Zustand |
| AI (Claude) | @anthropic-ai/sdk , @anthropic-ai/claude-agent-sdk |
| AI (Codex) | @openai/codex-sdk |
| Database | better-sqlite3 (per-project) |
| Git | simple-git |
| Build | Vite, electron-builder |
- Node.js 18+
- npm
- One of: Claude Code CLI,OpenAI Codex CLI, or anAnthropic API key
git clone https://github.com/YoniRaviv/Relay.git
cd Relay
npm install
npm run dev
Opens the app with Vite HMR. The Electron main process and preload script are compiled alongside the renderer.
In dev mode, enter ** dev-bypass** as the API key to skip real API validation. You can also seed a demo project with sample data:
npx tsx scripts/seed-demo.ts
Then launch the app, enter dev-bypass
as the key, and select the "Demo Project" to explore the UI with pre-populated tasks.
npm run build
Produces a packaged application in release/
(.dmg
on macOS, .exe
on Windows, .AppImage
on Linux).
npm run lint
Launch Relay Studio and choose your engine in the setup screenCreate or open a project— point to any folder on your machine** Click "New Feature"**— describe what you want built, use@filename
to reference codeChoose your path— click "Generate Specification" for a direct spec, "Brainstorm" for an interactive design session, or "Skip" to add tasks manually
Review the specification— the AI generates a detailed spec (or design document from brainstorming); edit as needed, then approve - Review tasks— the spec is decomposed into ordered tasks grouped by priority
Select your model and build mode, then clickStart****Watch the agent work— each task streams activity in the feed below the board** Approve or reject**— review diffs, commit approved work, reject with notes to retry
Run your project— click the Run button to preview your app** Run Code Review**— click "Code Review" in the sidebar (available when all tasks are done), select your model, and start the analysis. Review findings by severity, select which to fix, and apply fixes in one clickCreate a PR— use the green button to add a remote or create a PR** Check the Summary**tab for cost, performance, and code review metrics
electron/
main.ts # Electron main process
preload.ts # Context bridge (relayAPI, ~90+ methods)
agent/ # Agent runner, prompts, loop controller, engines
engines/ # SDK engine, CLI engine, Codex engine
openaiRunner.ts # Codex text generation for PRD/clarify/decompose
reviewRunner.ts # Code review agent (two-phase: analyze + fix)
stackDetector.ts # Auto-detect project tech stack
reviewPrompts.ts # Review prompt templates with stack-specific rules
db/ # SQLite connection and schema (9 migrations)
git/ # Git utilities (lock mutex, commit helper)
runner/ # Project runner (auto-detect, spawn, stop)
scheduler/ # Job scheduler (service, schedule/recurrence, dispatch, playbook chains, skills, DB)
ipc/ # IPC handlers (settings, project, prd, brainstorm, tasks, agent, git, review, reviewAgent, runner, metrics, scheduler)
shared/
types.ts # Shared TypeScript interfaces (EngineMode, BuildMode, etc.)
pricing.ts # Model pricing table (Anthropic + OpenAI, engine-tagged)
src/
pages/ # Board, PRDWizard, Setup, Summary
modules/ # Feature-based component modules
board/ # KanbanBoard, TaskCard, TaskDetail, AddTaskButton, ArchiveView
agent/ # LoopControls, AgentActivityFeed, RunProjectButton, RunOutputPanel
review/ # ReviewPanel, DiffViewer, PrCreationDialog
reviewAgent/ # Code Review Agent panel (idle, analyzing, findings, fixing, complete)
prd/ # PRDPreview, PRDEditor, FeatureInput, BrainstormChat, FileAutocomplete, StreamingProgress
scheduler/ # SchedulerView, JobBoard, WeekView, JobDetail, NewJobModal, Playbooks, UsagePanel, RecurrencePicker
settings/ # SettingsView (3 engines), ModelPicker (engine-filtered)
project/ # ProjectSelector, ProjectSidebar, GitHistoryPanel
metrics/ # TaskMetricsTable, MetricCard
shared/ # Reusable utilities, hooks, types, and components
components/ui/ # shadcn/ui primitives
store/ # Zustand store
lib/ # Utilities (theme, keyboard shortcuts)
| Key | Action |
|---|---|
Space |
|
| Play / the agent loop | |
Esc |
|
| Close the active panel (review or task detail) |
This project is licensed under the GNU General Public License v3.0.