Inspiration

A ticket says "retire the old Auth API". It looks small and safe. A second ticket upgrades that same API. Also safe. Nobody reviews them together, and the services that break are two links away, on issues nobody opened. The team finds out in production, and afterwards nobody can show what was known when the decision was made.

Jira already holds most of that evidence in issue links. We wanted the check to happen before the change, inside Jira, with people still making the decision.

What it does

ANTICIPATE turns proposed changes in Jira into evidence-backed decisions, in six steps:

  1. See the links: Evidence Graph. It reads the Jira issues and links you can access and builds a dependency map. Every relation is Confirmed, Inferred or Unknown and keeps its Jira source. Indirect consumers (two or more links away) come with the path that reaches them. Unreadable evidence stays Unknown, never "safe".
  2. Test changes together: Scenario Lab. Changes that are harmless alone can collide. Moving consumers to API v2 passes on its own, but combined with a breaking upgrade of v2 the result is Needs review: three records break only when both changes run. Simulations are deterministic and reproducible. "What if it slips?" also shows which due dates and releases move if an issue is delayed.
  3. Find a safer plan: Safe Change Composer. It re-simulates bounded variants on the same evidence and ranks them by blockers, conflicts, unknowns and impact. On the sample project it ranks a compatibility phase first, with 0 conflicts, and states each assumption in plain words. Simply splitting the work still leaves 2 conflicts. Proposals only: it never approves or executes.
  4. Keep approvals honest: Decision Radar. Approval is bound to the evidence it was based on. When someone adds a new link in Jira, the Radar flags it, a re-check confirms the evidence changed, and execution is refused with zero writes. The Decision Time Machine replays when and how the evidence changed.
  5. Verify each change: execution and Prevention Passport. A person approves selected Jira actions, then confirms execution as a separate step. Each change is only marked Verified after reading Jira back. The Prevention Passport records what was known, what was compared, who approved what and what was verified, and it exports to JSON or prints as an A4 report. An optional Jira workflow validator blocks the transition until the decision is complete and live Jira agrees.
  6. Ask your assistant: Rovo & MCP. Seven read-only rovo:mcp tools and the ANTICIPATE Decision Reviewer Rovo agent answer "what happens if we retire, upgrade or delay X?" with the same engine, under the user's own Jira permissions. They explain; they cannot approve or execute.

Release Safety groups every change by fixVersion, worst first (Blocked, Evidence incomplete, Needs review, ..., Verified), and never reads missing evidence as safe. A guided demo creates six labelled sample issues so anyone can try it in minutes.

How we built it

  • Forge app on Jira Cloud: a Custom UI global page (React, TypeScript), Node.js resolvers that call Jira REST as the user so Jira permissions apply, Forge storage for snapshots, plans, approvals and execution leases, a jira:workflowValidator, rovo:mcp tools and a rovo:agent.
  • Evidence graph: a bounded, cycle-safe crawl of issue links and components; each edge keeps its Jira link id, observation time and status.
  • Deterministic engine: a pure TypeScript package applies each option to an isolated copy of a frozen snapshot, traces impact through reverse dependencies with causal paths, evaluates policies and returns a reproducible hash. No probabilities, no invented savings.
  • Safe execution: approval is bound to the plan version and expires with the snapshot. Execution takes a per-plan lease, uses idempotency keys and marker reconciliation so retries never duplicate, and reports Verified only after re-reading Jira; partial outcomes are reported as Partial.
  • Shared contracts: zod schemas validate every request and response on both sides.
  • Quality: 336 backend tests (authorization, concurrency, outage policy, a 50-cycle soak test, storage-failure injection), 75 engine tests, 13 contract tests, 225 frontend unit tests and 200 Playwright cases on Chromium, Firefox and WebKit, including accessibility checks on light and dark themes. CI runs typecheck, lint, tests, Playwright and a security audit on every pull request.
  • Two-person team: one owner on backend, engine, Forge and security; one on interface, accessibility and presentation, coordinating through written contracts in the repository.

Challenges we ran into

  • Honesty in the interface. Never showing a capability as active just because it is declared, never treating a timeout as success or failure, never letting "Completed" read as "allowed to ship". That is why the Passport shows the Jira transition status next to the outcome.
  • Assumed work vs real work. A "migrate first" plan could complete while consumers still depended on the change. The validator now re-evaluates the change on live Jira evidence before opening the gate.
  • Safe retries without multi-key transactions: leases, idempotency keys and recovery by plan ID.
  • Jira's issue-link direction, which reads the opposite way from the API. We found it on a real site and locked it with a regression test.

Accomplishments that we're proud of

  • A full judge journey on a brand-new Jira site, installed from the public link: sample data, graph, comparison, verdict, approval, verified execution and a completed Passport.
  • The workflow validator refused a transition while the migration was only assumed, then allowed it once consumers had really migrated.
  • 6 of 6 approved Jira writes verified by reading Jira back; execution refused with zero writes after the evidence changed.
  • All seven MCP tools verified from an external MCP client, with Jira re-read and unchanged afterwards.
  • A synthetic benchmark: on 200 generated graphs, impact matches an independent oracle (precision and recall $= 1.0$). It checks the engine against its own definition; it is not a field-accuracy figure.

What we learned

The valuable part is not the graph, it is the decision: comparing options on the same evidence, testing changes together, and keeping a record of who decided what, on which facts. And honesty is a feature: a clearly shown Unknown earns more trust than a confident guess.

What's next for ANTICIPATE

  • Teamwork Graph sources (pull requests, deployments, Confluence). A prototype exists, but it is not in the shipping build, so we do not claim it.
  • A shared decision workspace with separation of duties (backend prototype, not released).
  • More change types (database migrations, feature-flag removal) and policy packs per team.

Built With

  • atlassian-forge
  • eslint
  • forge-custom-ui
  • forge-storage
  • github-actions
  • hyperframes
  • jira-cloud
  • jira-rest-api
  • jira-workflow-validator
  • mcp
  • node.js
  • playwright
  • prettier
  • react
  • rovo
  • rovo-agent
  • typescript
  • vitest
  • zod
Share this project:

Updates

Submission history