Hindsight

The post-mortem you read before the outage. Hindsight learns from your team's past incidents in Jira and Confluence to predict what could break, with a transparent confidence score.

Comment

Inspiration

Every incident post-mortem starts with the same sentence: "We should have known this would happen." The signals were almost always already in the team's own tools: a component that broke last quarter, a runbook nobody updated, a bug that looked exactly like this one. The knowledge existed, but it wasn't in front of the person clicking "Deploy." Codegeist's theme is Build with context. Ship with confidence. So we built the app that turns a team's own history into foresight, at the exact moment it matters.

What it does

Hindsight predicts the post-mortem for a change before it ships. Open a Jira issue (or ask the Rovo agent) and Hindsight:

  1. Assembles context: the issue's components and labels, resolved incidents and bugs that previously hit the same components, and related Confluence runbooks (checking whether they are stale).
  2. Predicts a post-mortem: the most likely failure, blast radius, likely on-call and a recurrence window, derived from the retrieved history, not invented.
  3. Scores confidence transparently: a weighted blend of incident-history depth (50%), component overlap (30%) and runbook freshness (20%), each shown with its value and weight, so you can see why it is 68%.
  4. Turns advice into action: one click converts the recommended mitigations into real Jira subtasks.

One engine, three surfaces:

  • A Jira issue panel (UI Kit), the always-works visual.
  • A Rovo agent "Hindsight" that calls the predict-incident action and writes a natural-language post-mortem.
  • A Rovo MCP server (rovo:mcp) exposing predict-incident as a tool, so other agents can use it too.

How we built it

  • Atlassian Forge (Node.js 22 runtime) with UI Kit (@forge/react) for the panel and @forge/resolver for the backend.
  • Modules: jira:issuePanel, rovo:agent, two action modules (predict-incident, create-mitigation-subtasks), rovo:mcp and function handlers.
  • Jira Cloud REST (enhanced JQL search) to retrieve past incidents and to create subtasks; Confluence CQL search to gauge runbook staleness.
  • A small, explainable confidence model with no black-box ML: retrieval, weighted scoring, and LLM reasoning through the Rovo agent.
  • A clearly labelled demo-mode fallback, so a fresh judge environment with no incident history still shows a populated prediction.

Challenges we ran into

  • A UI Kit resolver bundling quirk, where @forge/resolver's default export arrived as a namespace object. We solved it with an interop-safe unwrap.
  • Keeping the prediction honest: everything shown is derived from retrieved issues, and demo incidents are clearly marked as demo data, never passed off as real history.
  • Forge limits such as function-key length and scope choices, which forced us to keep the app small and least-privilege.

Accomplishments that we're proud of

  • A transparent confidence score that shows its reasoning instead of a mystery number.
  • One engine reused across three surfaces (issue panel, Rovo agent, MCP tool).
  • A real write path: the mitigation advice becomes actual Jira subtasks in one click.
  • A deployed, installable production app that runs entirely on Forge with no external services and no stored personal data.

What we learned

Context only creates confidence when it is explainable. Showing why the score is what it is (the exact incidents and the weights) matters more than the number itself.

What's next for Hindsight

Teamwork Graph for true dependency blast-radius, Bitbucket diff enrichment so predictions can see the actual code change, learning from post-mortem outcomes to calibrate the score, and a Marketplace listing.

Built With

Share this project:

Updates

Submission history