What is Horologium?
Public Alpha. Horologium is a self-hosted validation slice, not a GA product. See Public Alpha limitations before you rely on anything here for a real decision.
Horologium is a self-hosted Product Truth & Integrity platform. It maintains one canonical, reconciled truth about a software product — its shape, its cross-source integrity conflicts, its deployment reality, and its temporal history — and exposes that truth consistently to humans (a web dashboard) and to coding agents (MCP).
The problem it answers
Software claims accumulate across layers — intent, documentation, code, tests, releases, deployments — and those layers drift out of sync silently:
- A ticket says Done. The code that implements it disagrees with the docs about how it behaves.
- A feature is released in a tagged version, but production is still running an older one. "Done in Jira" is not the same fact as "live for customers."
- Nobody can say, precisely and with a citation, why they believe a given fact about the product is true today — or was true last month.
Horologium reconciles those layers into one queryable Product Truth, with full evidence provenance for every fact, instead of letting each source (a tracker, a doc, a deployment record) assert its own version of reality.
How it gets there — deterministic first, models only where necessary
Horologium does not answer "what's true?" by asking a language model. It:
- Collects deterministic evidence from the systems that already hold the facts — a Git repository, a Jira project, a documentation site, a deployment record.
- Reconciles that evidence with deterministic rules wherever the fact is machine-verifiable: commit ancestry, git tag containment, timestamp ordering, an explicit ticket-key reference in a commit message.
- Uses a language model only where a human would also have to read prose and judge — "does this paragraph describe the refund window, and what does it say?" — and only to produce a proposal, which the Rust core validates against existing evidence and typed rules before it can become part of Product Truth.
Every fact Horologium reports carries its derivation (observed — read
directly from structured data, or inferred — extracted from prose by a
model-backed proposal that was accepted) and cites the exact evidence it rests
on. See Integrity states and evidence for
how that citation model works.
When to use it
- You want a single, queryable answer to "is this Jira ticket marked Done actually the thing running in production?" — with a citation, not a guess.
- You want to catch a documentation/code disagreement (a docs page says one thing, the code says another) before a customer or teammate hits it.
- You're building a coding-agent workflow and want the agent to answer "is this feature live?" from a cited, deterministic source instead of inferring it from a stale README.
- You want to see what a fully-reconciled Product Truth graph looks like — evidence, claims, conflicts, deployment reality — against a realistic fixture, before deciding whether to self-host against your own systems.
- You're an approved Alpha/design-partner evaluating whether the self-hosted artifact (Docker Compose, MCP adapter) fits your stack.
See Scenarios and usage guidelines for exactly how to try each of these, with real commands and expected output.
When not to use it
- It is not a metrics/logs/tracing or general observability tool — it reconciles claims about a product's shape and status, not runtime telemetry.
- It does not replace Jira/Linear/your tracker — it reads from one, it doesn't manage tickets.
- It does not yet support live/network collection from your Git, docs, or deployment systems. You can collect from local-path Git/docs/deployment/Jira sources and from a live Jira project; see Evidence sources for the supported setup and limits.
- It is not a multi-tenant hosted product — one deployment serves one team's truth.
What's actually usable today
| Capability | Maturity |
|---|---|
| Web dashboard (Product map, Integrity, Deployments, Timeline) | SHIPPED |
| MCP read-only adapter (14 tools, 1:1 with the REST API) | SHIPPED |
| REST API read endpoints | SHIPPED |
| Deterministic reconciliation engine (the rules themselves) | SHIPPED as a library, golden-fixture-tested |
| Self-host via Docker Compose, seeded with the golden fixture | SHIPPED — access is by invitation, see Public Alpha limitations |
| Operator-triggered collection and reconciliation jobs over registered sources | PARTIAL — POST /v1/jobs runs collect or collect_and_reconcile; sources are registered through POST /v1/sources |
| Evidence collection from your own Git/Jira/docs/deployment systems | PARTIAL — local-path Git/docs/deployment/Jira sources and live Jira are supported; live/network Git/docs/deployment are not |
horologium-intelligence semantic proposal generation | PLANNED — no worker entrypoint exists yet in this Public Alpha slice |
Public/anonymous self-host (git clone, docker pull) | NOT IMPLEMENTED — private repo, by-invitation distribution (HORO-540) |
| Authentication, multi-tenancy | NOT IMPLEMENTED — see Security, privacy and data boundaries |
This table uses the company-wide maturity vocabulary (SHIPPED / PARTIAL / PLANNED / INTERNAL-ONLY / NOT IMPLEMENTED). See Public Alpha limitations for the full narrative version of the same boundary.
Where to go next
- Scenarios and usage guidelines — real, copy-pasteable walkthroughs: the hosted demo, self-host, and MCP.
- Reality layers — the Implemented → Released → Deployed → Enabled → Observed vector, and why Horologium never collapses it into one status.
- Integrity states and the evidence model — claims, conflicts, and "why do we believe this?"
- Product Shape and temporal history — canonical references and asking what was true at a point in time.
- Self-host quickstart — run Horologium against your own stack.
- Evidence sources — connect Git, Jira, documentation and deployment evidence.
- MCP / coding-agent integration — let a coding agent query Product Truth directly.
- Hosted demo walkthrough — see it running against a synthetic fixture, no install required.
- Security, privacy and data boundaries
- Public Alpha limitations and troubleshooting
Horologium's architecture decisions live as ADRs in the repository
(docs/adr/) — this site is the public-facing explanation of what those
decisions add up to, not a replacement for them. Where this site and an ADR
ever disagree, the ADR is normative.