The ingredient

Vague requirements, vague cards, AI slop.

That is the whole failure mode, and it multiplies rather than adds. An agent handed a card that never says what done looks like returns something that compiles, satisfies nothing anybody asked for, and costs more to read than it would have cost to write. Thirty of those is not thirty times the output. It is a morning gone.

So the depth goes in at the top, where it is cheapest. Hand Nightshift a requirement and it decomposes it into cards carrying acceptance criteria, a category, an estimate and a path lock: what a good engineer would write given the afternoon, on all thirty rather than the first one.

One requirement in

A paragraph of intent, a ticket, a customer complaint. Whatever you actually have.

Analysed, then decomposed

Into cards small enough for one agent to finish and specific enough to be judged when it says it has.

Graded before anything runs

Depth at grooming time is what makes a night run worth starting. It is also what the gate checks the diff against afterwards.

What you actually get

A board that runs itself, and the dials that decide how far.

Cards, a house style every agent is handed, and a roster you shape. Every figure below is an illustration rather than anybody's night.

Sprint 14Running until 06:00

68%

Autonomy rate

21/34

Points done

Agents working

Waiting on you

Escalated

$18.40

Sprint spend

Ready2

GAL-00031G2

Order total, with GST

3pt

GAL-00034G1

Retry-After on a 429

2pt

In progress1

GAL-00028G3

Session cookie on callback

5ptFull stack coder

In review1

GAL-00026G2

Rate limit the invites

3ptAdversarial reviewer

Ready for testing1

GAL-00022G1

Backlog empty state

1pt

Policy as code

Every change gets a grade. The grade decides the autonomy.

Grades come from a human-editable, diffable ruleset that lives in your repository. Highest matching rule wins.

G1Low risk

Cosmetic, docs, dependency bumps, styling.

Code, review and merge, unattended.

G2Standard

Feature work, components, scoped refactors.

Code and review; a human merges.

G3High impact

Core services, data models, auth, billing.

AI and human review both required.

G4Critical

Infrastructure, migrations, security, CI/CD.

Never autonomous. Named approver only.

The loop

Five steps, and two of them are refusals.

Thirty cards running at once is only worth having if you can leave. The interesting part of an autonomous loop is therefore not what it does: it is what it declines to do, and on whose authority.

A card is groomed

Title, description, acceptance criteria, and the paths an agent is allowed to touch.

The ruleset grades it, before anything runs

Computed from the paths the card declares, by the same policy that will judge the diff afterwards. Both numbers coming from one ruleset is what makes the comparison mean anything.

A coding agent claims it

Clones with a short-lived token scoped to that one repository, works in a throwaway checkout, opens a draft pull request. Nothing an agent writes is presented as ready.

A separate agent reviews the diff

A different machine, on a different lease. No agent ever reviews its own work.

The gate decides, not the reviewer

The actual diff is re-graded and checked against the card’s path lock. If it grades riskier than it was dispatched as, the autonomy decision was made on false information and auto-merge is blocked.

Bring your own model

You choose the model. You hold the key.

Anthropic, OpenAI, Google, Bedrock, Azure or OpenRouter. The coding agents and the review agents can run on different models, because reading a diff and writing one are not the same job and do not cost the same.

Your key, written once

Encrypted on the way in and never readable back. The only path that decrypts one is building a work order for a runner that has asked for work: nothing shows it to a browser, an operator, or a log.

Your contract, your spend

Model cost lands on your account at your rate, not marked up through ours. What you pay us is for the board and the governance around it.

The morning report

The only question anyone has at 8am

Underneath the headline: what merged, what is waiting on you, what the gate stopped, what it cost, and whether you were paying to write the code or to have it read.

23 merged overnight.
5 need you.

23 merged with nobody watching.

4 passed review and are waiting for you to merge.

1 was stopped by the gate and needs a look.

2 are still running and will finish before nine.

30 cards loaded. Spend: $47.80.

When it refuses

A governance tool that only shows you success stories isn’t one

A styling card that quietly edited something outside its scope. Here is what happened to it.

event.review.passedChange matches the card. No findings.

gate.escalatedPath lock violated. Changed files outside the card’s scope: src/auth/session.ts

The review agent approved it: it only ever saw a tidy diff. The gate refused it, because the change landed outside the paths the card declared. Review and authorisation are different jobs, and only one of them is allowed to be fooled.

Getting started

How it works

Three things to set up, once. After that the loop runs on whatever you groom during the day.

Connect the repository

A GitHub App with three permissions, named on the screen. Short-lived tokens, scoped to the one installation.

Install on GitHubcontents · pull_requests · checks

Groom, and let it grade

Acceptance criteria, a scope, an estimate. The grade decides how much autonomy the card is allowed, before anything runs.

Add a search filter to the customers tableG1

paths: app/customers/**

Read the morning's pull requests

The night run works the ready cards within your caps. Every branch arrives with the gate's verdict on it.

grade

no drift

paths

review

Pricing

Priced per board, not per seat

Get started

One board, one agent, one person.

Pro

$10 per board / month, or $80 a year

Up to 5 people. Unlimited agents.

Model spend is yours and is not included: bring your own Anthropic or OpenAI key. See pricing

Nightshift - AI Autonomous Kanban

Who is this for?