"Two hours, tops" — the Kanban board now answers with a P50 and a P90


There is a card on the Kanban board. The description is good, and it ends with “estimate: 2 hours.” You hand it to a worker and go do something else. Three hours later it is still running. Six hours later it is running tests. At hour nine you finally have a PR.

Next time a similar task shows up, you write “estimate: 2 hours” again. Not because you have a bad memory, but because nothing anywhere records that this class of task actually took nine. Estimation rarely fails for lack of methodology. It fails for lack of feedback.

Epoch, a community plugin now in the Hermes catalog, closes exactly that loop: estimate, measure, calibrate.

What it actually does on the board

Three moves, all at moments you already care about:

  1. The instant a worker claims a task, the plugin posts a Monte Carlo estimate as a task comment — P50 and P90, with P80/P95 alongside, not a vague “about two hours.”
  2. When that run completes, it records the run’s wall-clock hours back into Epoch’s own ledger, tagged auto_wallclock — measured, not typed in by a human.
  3. The next estimate calibrates from those actuals. The more runs, the smaller the error.

It hangs off two Kanban hooks: kanban_task_claimed and kanban_task_completed. You do not change your task workflow. If the plugin is installed and the board is in use, the estimate appears on the card.

It also registers an epoch_estimate tool and an /epoch slash command for asking for a standalone estimate.

Three things to know before installing

First, it is a community plugin, not something built into Hermes. The catalog tier is community, the maintainer is KyaniteLabs, and requires_hermes is >=0.21.6.

Second, it needs Node 22+ and network access to npm on the first run. The plugin is a thin shell; the estimator itself is a child process running npx -y @kyanitelabs/[email protected], which downloads Epoch and its dependencies the first time.

Third, the task title is passed to that local CLI — the first 80 characters, plus your three-point hint. Nothing leaves the machine, but “stays local” and “sends nothing” are different promises, and this one is the former.

Install is one command:

hermes plugins install epoch

Then confirm it is in the list and enabled:

hermes plugins list

Plugins take effect on the next load cycle. If you installed it while a session was already running and its tool does not show up, restarting the gateway once is the simplest fix.

Writing a card that can actually be calibrated

By default, it falls back to a reference-class estimate — a range derived from historical tasks of the same kind. That default is useful from day one, because Epoch ships a bundled reference database.

What makes estimates accurate, though, is an explicit three-point range in the task:

Refactor fee calculation to remove floating point drift

epoch: 2/4/10h

2/4/10h is most optimistic / most likely / most pessimistic. With three numbers, the Monte Carlo has a distribution to sample, and P50/P90 mean something. Without it, the plugin can only produce a reference-class range — usable, but not as good as your own input.

Keep the units simple: h for hours, three slash-separated numbers. “2-10 hours” is not a three-point estimate.

Where it deliberately stays narrow

Plugins that keep books on your work are easy to over-scope, and Epoch’s disclosure is unusually specific. A few points are worth repeating:

  • The child process environment is scrubbed: only PATH, HOME, locale and temp dirs, plus Node/npm cache, registry, CA and proxy variables are allowed through. The parent environment, API keys and Hermes secrets are never passed.
  • Telemetry is forced off: every plugin run sets EPOCH_TELEMETRY=0. Standalone Epoch telemetry is opt-in; the plugin never opts you in.
  • Data lives under HERMES_HOME/plugin-data/epoch/: estimates, actuals and run bindings, shared by every profile.
  • /epoch is a restricted passthrough: it forwards other subcommands but refuses serve, self-improve, and anything that mutates telemetry or data. On gateway platforms it also refuses ledger-writing subcommands unless you set allow_write_slash_on_gateway: true.
  • Comments are display only: estimates are bound to runs through a mapping stored next to the ledger, so a forged marker in a comment cannot redirect recording.

Hook work runs on short-lived background threads with a copied contextvars context, so it never delays worker spawn. If the process exits before a job finishes, a profile-local outbox replays it when the plugin next loads.

Three caveats that matter

One: the 12-hour recording ceiling. A sanity gate accepts only runs between 0.05 and 12 hours, and no more than 10× the estimate. The intent is obvious — reject obviously wrong measurements — but it also means a 14-hour run’s actual is not recorded. If your tasks are long, calibration data will be sparse.

Two: the first run can stall on npm. Dependencies download on first use. With an npm min-release-age-style policy, the pinned version may not have aged enough and the download is refused. The plugin keeps the job queued and retries instead of erroring out, so the symptom is “the estimate never appears,” not a clear failure. After installing, trigger it once manually to confirm the download works.

Three: it does not know the 2 hours you had in mind. The three-point range is yours; the plugin can only sample it. Habitually optimistic most-likely values produce an optimistic P50 — except that this time the bias is recorded and absorbed by the next estimate. That is the part where it beats a human, but it also means the first few estimates deserve skepticism.

Who it fits, who it does not

Fits: teams with recurring task types, cards with a clear definition of done, and ten seconds to spare on a three-point range. After two or three weeks, “how long does this kind of task take” stops being a matter of memory and mood.

Does not fit: one-off exploration (no reference class to speak of), projects that run longer than 12 hours per task (the gate discards them), and fully offline hosts that cannot reach npm.

One note on how it relates to Hermes’ own board machinery: the task lifecycle, review and reclaim behavior are built into Hermes; Epoch only hangs an estimation layer on the claim and complete hooks. To understand the board itself, see the Kanban review lifecycle. For what else is worth installing, this breakdown of the catalog batch sweep explains the admission rules.

When you can use it

The catalog entry merged on November 8, 2026 (PR #149757), version 0.7.0, and it is already on main. On a stable release you can install it as long as requires_hermes is satisfied (>=0.21.6) — the catalog is read at runtime, so no Hermes release is needed.

The short version

Estimates miss because nobody feeds actual hours back in. Epoch adds a hand at two moments on the Kanban board: at claim time it posts a Monte Carlo estimate with P50/P90, and at completion it writes the real hours into a ledger. The cost is a first-run npm download and a 12-hour ceiling on what gets recorded; the payoff is that, from about the third week, the number on your card starts resembling reality.