Agent-automated project management

Two wings.
More lift.

Plane is an excellent open-source project tracker — boards, sprints, work items — built for human teams. Biplane is our fork of it, made for a dev team where AI agents do much of the building: self-hosted, wired to our own git, with signature-verified Plane webhook deliveries recorded in our ledger. We're not competing with Plane — we're using a good app a bit differently, and sharing it in case your team needs the same.

View on GitHub Join the forum
Biplane — the Wheel
The Biplane Wheel — a live radial view of the project: every ticket a slice, state colors matching the board, module lanes on the outer band
The Wheel, live in the app — the whole project turning: every ticket a slice, colors straight from the board.
The concept

What is Biplane?

A project-management workspace where AI agents and humans share the same tracker — git-linked lifecycle changes can update automatically, and accepted webhook deliveries are recorded for audit.

Wing one — humans

A first-class tracker for people

Boards, work items, cycles, and modules — everything that makes Plane (Community Edition, AGPL-3.0) an excellent project-management system for human teams. We kept all of it.

Wing two — agents

The agent layer we added

We added an agent-focused operating layer alongside Plane's human workflow: tickets that move when git activity references them, a tamper-evident ledger of signature-verified webhook deliveries, policies for what agents may touch, and live views built natively into the interface.

Why fork, instead of bolting on?

We didn't set out to build a project-management product. We're a dev team where AI agents do much of the building, and we needed a tracker that fits how they work: everything on our own hardware, sign-in against our own identity provider, tickets that follow the git activity in our Forgejo instance, and a tamper-evident record of the tracker changes that work produced. Plane's Community Edition was the best open-source base we found — genuinely excellent — but our needs meant changing the application itself, not bolting things on. So we forked it, and we're publishing the result under the same AGPL license. If your team has the same needs, Biplane is yours too.

Security & self-hostingEverything can run on your own hardware, behind your own network — project and audit data stay on infrastructure you control, with outbound services limited to the providers you choose.
Your own identity providerGeneric OIDC single sign-on isn't part of Plane's Community Edition, and local-first deployment needs it. Biplane signs in against your own identity provider — we run a lightweight idP, with Forgejo as a fallback — wired natively into the fork.
Forgejo-native gitPlane's documented git integrations (GitHub, GitLab, Bitbucket) don't currently include Forgejo. Our bridge speaks Forgejo webhooks directly.
Bring your own agent fleetBiplane's automation is driven by your own agents and your git events — any agent stack that can commit code or call an API. Biplane adds no marketplace requirement and no usage meter of its own; the whole layer is yours to run.
Receipts you can verifySignature-verified webhook deliveries land in an append-only, tamper-evident ledger you host yourself — receipts on your hardware, not a vendor's.
Views woven in, not bolted onThe kanban, list, and calendar boards, cycle and module views, the Wheel, and the Traveler all update live on screen as agents work — no page refresh. Useful when updates are frequent, and made practical by owning the frontend.

Biplane supports a larger project of ours — not a project-management tool, but an exploration of what AI agents themselves can be. We'd rather demonstrate that than talk about it. More when it's ready.

Capabilities

What we added

Six pieces, tested together.

Git-driven ticketsA commit that references a ticket moves it to In Progress, a pull request to In Review, a merge to Done. Automatically. Never backwards.
Tamper-evident ledgerSignature-verified webhook deliveries land in an append-only ledger you can audit any time.
The WheelThe whole project as a live turning wheel — every ticket a slice, colors straight from your board.
The TravelerEach work item's recorded lifecycle as a timeline — filed, discussed, moved, done — like a medical record.
Watch modeScreens update only when something actually changed — one tiny change-signal check, then an in-place redraw. No refresh, no clicking, no flicker; perfectly still when nothing happened.
Policy & write-pathFail-closed rules for what agents may touch, with idempotent writes through a gated path.