Every capability that turns your board into delivery truth.
KalMatrix reads Jira and GitHub as they already are, checks what’s claimed against what’s merged, forecasts every active sprint, and puts one diagnosis in front of you before standup. Here is exactly what it does — and the evidence behind every call it makes.
Every “done” ticket, checked against merged code.
A green board is a claim. Merged code is the fact. KalMatrix reconciles the two on every run and flags the “watermelon” tickets — green on the outside, red in the repo — before they roll up into a status report leadership trusts.
- Verified-done vs board-done, per ticket and per sprint
- The inflated point count named, so you know what to spot-check
- Works the moment GitHub is connected — nothing to instrument
- Turns “I think we’re fine” into a number you can defend
A calibrated probability of a miss — not a straight-line guess.
Real sprints don’t burn down evenly; teams sandbag early and crunch late. So 15% done on day 5 of 15 is healthy and 15% on day 11 is a dead sprint walking. KalMatrix fits an S-curve to each active sprint and returns a calibrated probability of missing committed scope — plus the day it stops being recoverable.
- Per-sprint probability of a miss, modelled on how teams actually finish
- The recoverability day — after which no amount of crunch closes the gap
- Closed-form arithmetic, no model in the path: every number traces to sprints you can open
- On day one with no history it speaks from an industry prior — and tells you that is what it is doing
One named diagnosis a day. The one thing that matters.
Twenty-two behavioural checks are useless as twenty-two alerts — that is a feed, and feeds get muted. KalMatrix clusters them into situations and writes one brief: the one thing, what is literally happening (named tickets, named blockers, named reviewers), and the concrete move to make today. A quiet day is reported as a quiet day; manufactured urgency would make it unreadable inside a month.
- The one thing today, with the evidence attached
- Named specifics: which ticket, which blocker, which reviewer — never “go ask around”
- A concrete lever — the move that changes the outcome, not a maxim
- What changed since yesterday’s brief, computed by diffing, not by adjectives
It arrives thirty minutes before standup. In each team’s own timezone.
A tool you have to remember to open is a tool you stop opening. The chase list lands in the team’s Slack channel before the meeting, already read: what moved, what is stuck, who it waits on, and whether the forecast shifted overnight.
- Timed to each team’s standup in its own local timezone — not one global hour
- “Moved yesterday” understands weekends: Monday reports Friday through Sunday, not “nothing moved”
- On it · Snooze 1d · Not real — one tap, and snoozed items stop nagging until the snooze lapses
- Tomorrow’s brief opens with how many of yesterday’s chases were actually picked up
- Friday sends a receipt: calls published, calls graded, and the points cut after a flagged risk was acted on
- • PAY-311 merged — refund idempotency shipped
- • PAY-284 moved to In Review
“It will miss” is not advice. “Cut these nine points” is.
Open one sprint and get the whole decision surface: what will land at the current pace, which specific items are dragging it, and the exact scope to cut — with named candidates, ranked by how recoverable each one is.
- Named descope candidates with the point total, so the trade is a decision, not a debate
- Blockers ranked by blast radius — what actually sits behind each one
- Real burn versus board burn, on the same axes, so ghost progress is visible
- The scope timeline: what was added or quietly removed, when, and at what point cost
- Per-item ETAs from conditional counting — a ticket already stuck six days gets an honest answer, not the median
Commit to the calendar reality — not the wish.
Before the sprint starts, KalMatrix weighs your proposed commitment against what the team has actually landed. Not the velocity number that re-counts the same carried-over ticket three sprints running — each item counted once, on the sprint it finally finished in.
- Honest throughput: every item counted once, on final completion, not recycled carryover
- How much of what you commit has historically landed — the number the wish is measured against
- Your estimation bias, stated as a correction factor rather than a folklore buffer
- A recommended commitment sized to clear the bar, so spillover becomes a choice
Fifteen teams, one read, one shared cause.
A delivery director does not run a sprint; they answer to a steering committee about a dozen of them. This rolls the per-sprint forecasts up and — the part that saves the week — names the shared upstream cause, so three programs stop escalating the same blocker three separate times.
- Every commitment at risk this quarter, ranked, across all teams
- The common cause behind clusters of risk, named once
- Per-team estimation bias as a correction factor — a roadmap input, not a folklore 20% buffer
- Bus-factor concentration: where reviews and rollbacks funnel through one person, reported as “1 of 6 engineers”
Your team writes faster than anyone can read. Here’s the gap that opens.
AI-assisted work can ship more, or it can generate more churn that looks like progress. KalMatrix separates the two at team and org level — and answers the newer question underneath it: whether your humans are still keeping up with what the agents are producing.
- Review debt: how many business days of review the open queue represents, at the pace reviews actually happen
- An agent scoreboard — what each bot or coding agent merged, how much was reviewed, how much came back. Agents are tools, so naming them costs nobody their privacy
- AI-marked code that reached main with no human approval, flagged with the pull request named
- Throughput and rework broken out per team — never per person, and always with the coverage of the attribution disclosed beside it
Attribution is the honest tier only — commit co-author trailers, bot authorship, and self-reported tags. Untagged AI use stays invisible, so every one of these numbers reads conservative rather than flattering.
Did we ship — or did we ship a fire?
A sprint can hit its committed scope and still be a quality miss: the code went out and came back as an incident. KalMatrix reads deploys from the GitHub Deployments API where you have it, falls back to a labelled merge heuristic where you don’t, and always tells you which one it used.
- Change-failure rate, MTTR and deploy frequency — the DORA-shaped reads, from your own event stream
- Incidents traced back to the change that caused them, not the revert that fixed it
- Which incidents trace to AI-assisted change, stated as correlation and labelled as such
- Measured deploys always beat the heuristic, per repo, so one team wiring up CI never makes another look like it stopped shipping
Every forecast arrives with its own hit rate.
A prediction you cannot audit is just an opinion in a confident font. Every forecast KalMatrix publishes is written down, then graded when the sprint closes — and forecasts reconstructed after the fact are labelled as such, so the scorecard can never take credit for a warning nobody was actually shown.
- Every published call recorded, then graded against what really shipped
- Replayed forecasts flagged as replayed — no credit for warnings nobody saw
- Rule-level learning too: “sprints where this fired missed 7 of 11 times, against a base rate of 31%”
- Thin evidence returns nothing rather than a fabricated date
The tells a seasoned delivery lead reads — watched on every run.
Underneath the brief, twenty-two behavioural checks run continuously. Each one is thresholded against your own team’s normal rather than a number we picked, so a team that reviews in two days and a team that reviews in five are both judged against themselves.
Dependency blast-radius
One blocked ticket rarely blocks one thing. KalMatrix traces what sits behind it, so you escalate the dependency holding the most points hostage — not the loudest one.
Reviewer bottleneck
When most pull requests route through one person, review becomes the sprint’s hidden critical path. Surfaced by name, before it stalls the board.
Scope creep — and silent descope
Points added after commitment, and work quietly pulled out to flatter the burn. Both are logged to a ledger with the date and the point cost.
Stale in-progress
Tickets sitting “In Progress” with no commit behind them for longer than this team’s own normal. The clearest early tell that someone is silently stuck.
Pressure wave
Pull requests ballooning above the team’s norm while more of them merge without independent review. This pattern precedes incidents by one to two weeks.
Ghost closes
Tickets closed with no merged code, and the bulk-close on a sprint’s final day. Held back for teams whose link coverage is too sparse to judge fairly.
Rework loop
Work that has bounced backwards more than once — review to in-progress, QA to development. Every bounce is a handoff somebody refused.
Rushed & unreviewed merges
Self-merges, merges minutes after opening, and AI-authored code reaching main with no human approval. Historically the strongest precursor of hotfixes.
behavioural checks in all — clustered into situations and synthesised into one brief, so you read a decision rather than a feed of alerts nobody acknowledges.
See every one of these on your kind of data.
The live demo loads a fully-populated workspace — real sprints, real forecasts, real diagnoses. Read a delivery brief in the next 30 seconds, no signup.