Lingtaiboard · 2026-09-30GitHub

A working loop for coding agents

Let your backlog move. Keep control of what lands.

Lingtai picks up labeled GitHub issues, lets an agent work on them one at a time, runs your repository’s checks, and lands passing work. If a run needs you, it stops with a reason.

$ curl -fsSL https://lingtai.hczhang.com/install.sh | sh

macOS and Linux, arm64 or x64. It checks a SHA256 before it unpacks a byte, and ends at lingtai init. Or read it first: the script · from the release

Set up Lingtai See how it works

Runs on your machine · Uses your issues and checks · No signup

What changes for you

Less assigning. Less watching. Fewer mysteries.

Your existing workflow stays in GitHub. Lingtai does the repeatable work between an issue and a decision.

The queue is already yours

Label an issue. Your recipe decides what is eligible; there is no second backlog to maintain.

You set the boundaries

The agent writes code. Your local recipe determines the checks and whether a person must approve.

Only step in when needed

See what is moving, what landed, and why something stopped—without chasing an agent’s transcript.

Why Lingtai

An agent can make a patch. Who runs the rest of the loop?

Giving an agent a task is one thing. Keeping a queue moving safely, especially when you are away, needs a way to choose work, check it, and hand failures back.

THE QUESTIONLINGTAI’S ANSWER
What should it work on?Your labeled issues
Where can it work?One disposable worktree
Can the change land?Your checks and approval rule
What happened when it stopped?A visible reason on the board

How you use it

Start with one repository.

Set it up on your machine, tell it which issues count, then let it run.

  1. 01

    One command, from a bare machine

    $ lingtai init

    It asks for a Postgres URL, creates the tables, detects your agent runtime, and creates the GitHub App from a manifest in one click. It ends on the board, ready for a repository.

  2. 02

    Review the proposed rules

    The board reads the repository and proposes labels, checks, and limits. You make the two lasting choices: how far a ticket may run, and whether a person approves the merge.

  3. 03

    Check it, then start

    $ lingtai doctor
    $ lingtai start

    Label an issue. Follow the run on the local board.

The work, in the open

A board that shows the stops, too.

The local board puts queued, running, waiting, and landed work together. When a publishable snapshot is available, this is Lingtai’s own board—not a demo with invented results.

Lingtai’s own board2026-09-30 · f2e4f7c29 work items · 2101 agent turns · $199.53 spent
Queued3
withheld a private repository · tech-debt
title withheld
  • under an hour
withheld a private repository · bug
title withheld
  • under an hour
  • 27 turns
  • $0.92
withheld a private repository · documentation
title withheld
  • 45 hours
Running1
withheld a private repository · tech-debt
title withheld
  • under an hour
  • 43 turns
  • $1.49
Waiting on you0

Nothing is waiting on you.

Landed25
  • withheld$17.24
  • withheld$2.34
  • withheld$14.83

and 22 more, all of them in the log.

Snapshot from 2026-09-30, not live. Lane counts and totals include all work, even when only a few cards are shown. 29 private-repository cards have identifying details withheld; their lane and totals still count.

Know the edges

Useful today. Still unfinished.

Self-hosted software you can inspect, pause, and improve—not a promise that every edge is solved.

  • Postgres is required. A database of its own — not one belonging to a project you manage. Running entirely on SQLite is decided and three-quarters built: it becomes a choice you make at setup, not a default you fall into. Track #179
  • Not a container sandbox. Guarded runs use a worktree, a filtered environment, and a recording hook; sandboxed is a tier the schema names and nothing enforces yet.
  • A running daemon holds the code it started with. Merging does not reach the process that is conducting, so picking up new code is lingtai restart — which refuses first, on a commit the remote has not got, a dirty tree, or a red doctor.
  • 0.9.0 is the first release. It exists to prove this path end to end: four binaries, a board, checksums, and an installer.