Your planning board,
running itself.

Sully watches your board and spawns headless Claude Code sessions that plan, implement, open PRs for, and review each ticket — every ticket in its own git worktree, with results posted back to your board and GitHub.

View on GitHubSee how it works

A recreation of the Sully desktop app showing a board with five columns — Uncategorized, Planning, Plan ready, In progress and In review — holding 10 tickets, two of them with live agent sessions writing a plan and editing code. All of the tickets shown are fictional examples.

How it works

Five steps from ticket to pull request.

  1. 1

    A ticket lands in a mapped column

    You map your board columns to phases — planning, in progress, in review. Use Linear, or Sully’s own local tickets if you would rather not connect anything. Moving a card is the only trigger Sully needs.

  2. 2

    Sully cuts a worktree and a branch

    Every ticket gets a dedicated git worktree and branch, so parallel work never collides and your main checkout stays untouched.

  3. 3

    A headless agent runs the phase

    A Claude Code (or Codex) session runs the phase the column implies: writing the plan, implementing the change, creating the PR, or reviewing it.

  4. 4

    Plans land in .sully/plan.md for review

    You read the plan before a line of code is written. Agents can ask blocking questions, and you answer them in the in-app ticket chat.

  5. 5

    Sully advances it to a merged PR

    Coding, PR creation, and review follow as the ticket moves, with progress posted back to your board and GitHub along the way.

Phase configuration

Every phase gets its own agent, model, and budget.

Plan with Opus and a planning skill, implement with Sonnet, open the PR with Haiku, review with Codex. Each phase carries its own injected prompt, permission mode, timeout, and MCP server subset, so you are not paying frontier-model prices to write a commit message.

  • Planning
  • Coding
  • Create PR
  • Commit & Push
  • Address Comments
  • Figma Comments
  • PR Review
  • Error Investigation

A recreation of Sully's Settings screen, showing the phase configuration panel: one card per phase with dropdowns for agent, model, skill, permissions, timeout, and which MCP servers to load, plus a free-text prompt injected into every session for that phase. The values shown are fictional examples.

Features

Everything the loop needs, in one window.

Board-driven orchestration

Column-to-phase mapping drives the whole workflow, with per-ticket opt-in via labels so nothing runs that you did not ask for.

Git worktree isolation

Each ticket gets its own worktree and branch.

Plan review and ticket chat

Review agent plans and answer agent questions without leaving the app.

Automated PR creation and review

Creates PRs, and watches for PRs where you are a requested reviewer — spawning review sessions automatically.

CI auto-fix

Reads failing GitHub Actions logs and PR review comments, then reprompts the agent to fix them.

Production error investigation

Pulls errors from PostHog error tracking and spawns investigation sessions.

Embedded terminals and browser

Split and dockable terminals, a browser panel, and a dev server runner.

One-click deploys

Run your own release commands per repo.

Usage tracking and doctor

Per-session budgets, a live usage bar, and diagnostics for your CLIs, tokens, and MCP servers.

Integrations

It plugs into the tools already on your machine.

Linear
Polls tickets by column, moves states, and reads and posts comments through the GraphQL API. Optional — Sully also ships local tickets that live in your repo.
GitHubgh
Creates PRs, checks CI status, fetches failing Actions logs, and reads and posts PR review comments.
Claude Codeclaude
The main agent for planning, coding, PR creation, review, and error investigation.
OpenAI Codexcodex
Optional alternative agent, configurable per phase.
MCP servers
Per-phase server selection from ~/.claude.json, with OAuth re-login support.
Figma
Injects a Figma token into sessions so agents can read design comments.
PostHog
Queries error tracking to feed production error investigation sessions.
Git
Worktrees, branch sync, and mapping repos to local paths.
CI providers
GitHub Actions log fetching, plus CircleCI and Vercel status through the PR check rollup.

Getting started

Clone it, run it, move a ticket.

Prerequisites

  • macOS — Sully is an Electron desktop app
  • Node.js 20+ — to run and build the app
  • claude — Claude Code installed and authenticated
  • gh — GitHub CLI installed and authenticated
  • git — with your repos cloned locally
  • A board — a Linear API key, or Sully’s built-in local tickets
  • Optional — codex CLI, a Figma token, a PostHog API key

Run the app

$ git clone https://github.com/sulaimanh/sully.git$ cd sully$ npm install$ npm run dev

On first launch a guided setup wizard checks your CLIs, takes your credentials (stored encrypted in the macOS Keychain), points Sully at a repo, and maps your board columns to phases. You can re-run it any time from Settings.

Or install it for real

$ npm run deploy:mac

Builds the app, drops Sully.app into /Applications, and relaunches it — so you get a real dock icon instead of a dev server. Re-run it whenever you pull.

Stop babysitting tickets.

Sully is open source under the MIT License. Clone it, point it at your board, and watch a ticket go from plan to PR.

View on GitHub