~/onflow.studio/shogun-flow

Shogun Flow

Command an army of coding agents from one inbox.

Label an issue ready and an agent takes it, in a worktree of its own, all the way to a green pull request. You give the orders and answer what only you can answer. The agents do the rest.

Take the tour Source coming soon

The board's inbox, with the stages under it. One card lit, the one that needs you.

# why

Agents are fast. Babysitting them isn't.

One coding agent is a conversation. Three are a juggling act: terminals to check, branches to keep apart, a question asked twenty minutes ago in a tab you didn't look at. Shogun Flow runs them for you and stays quiet until something needs you. Then exactly one thing lights up, in one inbox.

# what you get

  • 01

    One agent per issue

    Label a GitHub issue ready and a Claude Code (or Codex) session picks it up, on a branch of its own. A cap decides how many run at once; the rest wait their turn, and an issue another one blocks waits for it.

  • 02

    A worktree each

    Every run happens in its own git worktree, so agents never step on each other or on the checkout you're working in.

  • 03

    One inbox

    Only what needs you, most urgent first: a question that pauses an agent, a permission, a plan to approve, a pull request to merge. Each says in one line what it needs, with its facts and its own buttons: lettered choices, allow, merge.

  • 04

    Ends on a green pull request

    The agent opens a pull request and waits for its checks. A reviewer reads it before you, and red CI goes back to it. Merge with one click on the board, or let Shogun Flow merge what passed: when parallel pull requests collide, it brings them up to date or sends a fixer, then merges them one by one. A merge that was wrong is one revert away, and the revert waits for you.

  • 05

    Calm at a glance

    Home says three things: what needs you, whether the work is moving, and what each project is doing in one plain line. Reviewed pull requests come with two plain lines on what they're for and what's on you. The stages, from waiting to merged, are a click away.

  • 06

    Plan with your product manager

    Each project has a product manager. On Plan it opens with a short briefing and suggests a goal when you have none; ask it anything, or start a triage session and sort the backlog one issue at a time, each with its call and why. Nothing moves until you click.

  • 07

    Everything on the record

    The Activity page lists everything Shogun Flow did in a project: runs, reviews, merges, labels, settings and HR's changes, filtered by kind. While auto-merge is on, every page says so, and the status line says when it last looked for work and when it looks next.

  • 08

    Runs that survive

    Sessions live in tmux. Close the board or restart the daemon and every run carries on. Attach to any of them for the full terminal. shogun-flow stop stops the daemon, the runs carry on, and shogun-flow install keeps it running across reboots. A laptop that slept is noticed, not mistaken for stuck agents.

  • 09

    Set up, then start

    A new repository opens on a setup, one step at a time: what it needs, the tracker, the agent, your issues and your phone. It says what starting would pick up, and nothing runs until you press start. shogun.config.json is committed, so a team shares one setup.

  • 10

    You choose how agents act

    Prompts off: agents work on their own behind a guard that refuses merges, force-pushes and other dangerous commands. Prompts on: every command is a card. Asked on every machine: a teammate's clone never inherits prompts off or auto-merge.

  • 11

    Roles are markdown

    A role is a prompt with a few lines of frontmatter, including when it runs: on a ready issue, after the builder, after a merge or on a schedule. Copy one into your repository, edit it, commit it.

  • 12

    A team, and HR to change it

    The Team page shows each role at work: what's live, its runs, its success rate and what the agents are saying. To change the team, tell HR. It asks what it needs and writes the change.

  • 13

    Every project, one board

    One daemon serves every repository on your list. Each gets its own group of pages in the menu, and the overview adds them up.

# keyboard

Answer with a key.

The inbox is where you answer every agent, and it never needs the mouse. Move through the cards, pick a letter, the agent gets on with it.

  • jkNext and previous card
  • abcAnswer with a choice
  • ↵Open the run behind a card
  • ?Help: shortcuts, labels, cards, the guard

# install

Coming soon.

It isn't on npm yet. When it is, it's one command, run inside the repository you want it to work on. You'll need:

  • Node 22.13 or newer, git and tmux
  • GitHub CLI, logged in. No token to create: it acts as whoever gh is
  • Claude Code or Codex, logged in
  • A repository on GitHub, with its issues on GitHub or in Linear
# not on npm yet
$ npx shogun-flow

The first time, it:

  1. 1.Checks what it needs and tells you exactly what's missing.
  2. 2.Asks how agents may act. There is no default.
  3. 3.Creates the labels, writes shogun.config.json and a .shogun/ folder.
  4. 4.Opens the board on its setup: the tracker, the agent, an audit of your issues and your phone. Nothing starts until you press start.

# stack

shogun-flow --stack

lang
TypeScript 94% · CSS 5%
stack
Node 22 · Hono · SQLite (node:sqlite) · React 19 · Tailwind 4 · Vite
drives
Claude Code or Codex, through their hooks · tmux · git worktrees
talks to
GitHub, through the gh CLI you're logged into · Linear, if your issues live there
stores
runs, events and cards in SQLite, in ~/.shogun on your machine
runs on
your machine, on 127.0.0.1 only · no account, no telemetry

# how it works

One small daemon serves the board on 127.0.0.1 for every repository on your list and keeps its state in SQLite, in ~/.shogun. Every minute it checks for ready issues and free places under the cap.

A small core owns the run lifecycle, the inbox and the event log. Everything else sits behind four interfaces, so each can be swapped: the tracker (GitHub Issues or Linear), the agent (Claude Code or Codex), the workspace (a git worktree) and the notifier (the board, and your phone).

# issues# agents# pull requests#42rate limitingready#45dark settingsready#47retry webhooksready#49cap 3, waitsqueuedshogun/42needs youworktreeshogun/45workingworktreeshogun/47checks greenworktreepull requestpull requestPR #51checks greeninbox1aredisbin memoryyoureview, merge

Swipe to follow the run

# origin

Shogun Flow started as a private daemon that ran agents on the studio's own issues while the work went on elsewhere. It worked well enough to rebuild it properly: no hardcoded repositories, a first run that needs no file written by hand, and a board in the same look as email-flow.

# source

Source coming soon.

Shogun Flow was shaped around one way of running agents. When the source is out, don't adapt to it: fork it and have your AI make it work your way. Write your own roles, swap the tracker or the agent, change the guard. It's the same conversation that built it.