Inspiration

Atlassian describes Teamwork Graph as an associative memory for the organisation: who's doing what, what's already been decided, and what happens next. The middle part is the one teams lose most often.

Every engineering org we know has a story like this. "We spent a quarter consolidating on Postgres after two settlement incidents." Eight months later a ticket lands: "Store onboarding documents in MongoDB, it's faster." Nobody on the new squad was there for the original decision, the ADR sits on page 4 of a Confluence space, and the work ships. In 2026 the ticket is just as likely to be a plan written by an AI coding agent that has never heard of your decisions.

ADRs were supposed to fix this. They don't, because they're write-only: nothing reads them back at the moment someone is about to contradict them. We built Precedent to close that loop.

What it does

Precedent is a Forge app that turns decisions into a living ledger that's read back wherever work happens:

  1. Drift detection in Jira. Every new or edited work item is checked against accepted decisions. Each decision carries guardrails: terms that signal contradicting work, usually the alternatives the team rejected. When a work item hits one, Precedent's issue panel turns red. It names the decision, quotes it, explains the conflict, and offers Resolve with Rovo or Not a conflict. It also leaves one explanatory comment and sets an issue property. Work touching a superseded decision or an open proposal is surfaced too.
  2. The Precedent Rovo agent. It answers "why did we choose X?" with decision ids and dates. It checks the work item you're on, reads a comment thread and drafts the decisions it finds for you to confirm, supersedes old decisions while keeping history, and lists what's due for review.
  3. 8 reusable Rovo actions (search-decisions, get-decision, check-work-against-decisions, get-work-item-discussion, record-decision, find-decision-experts, list-decisions-for-review, update-decision-status). Any team can add them to their own agents in Rovo Studio.
  4. An MCP server for AI coding agents. The same actions are exposed through rovo:mcp, so Claude Code, Cursor and other clients can run a pre-flight check on a plan before writing code, with each user's own permissions. We ship a plain-markdown SKILL.md (downloadable from the app) that teaches an agent the loop: check, stop on conflict, cite, offer to supersede.
  5. "Who to ask" from the Teamwork Graph. A decision is only useful if you can reach the people behind it. Precedent walks the Teamwork Graph from a decision's owners to their teams and the Jira work they're carrying now, from linked work items to pull requests and goals, and from source pages to their owners and contributors.
  6. A decision ledger (Jira global page): search, status filters, supersession timelines, a drift feed, health views (review-due, open proposals, decisions without guardrails, most-consulted), an activity feed showing whether a person, Rovo or an MCP agent did something, and a live pre-flight check box.
  7. Confluence import. Precedent scans ADR pages (Status / Context / Decision / Consequences / Alternatives) and Confluence /decision items, turns rejected alternatives into guardrails, and imports after review. A page-byline item shows which decisions came from that page.

How we built it

  • Forge modules: jira:issueContext, jira:globalPage and confluence:contentBylineItem (one React Custom UI app built with Atlassian Design tokens, light and dark), a trigger on avi:jira:created:issue / avi:jira:updated:issue, rovo:agent, 8 action modules, rovo:mcp, and a weekly scheduledTrigger for personal-data reporting. It's a multi-app Forge app: Jira required, Confluence optional.
  • Teamwork Graph API: api.asUser().requestTeamworkGraph() with curated queries (atlassianUserInTeams, atlassianUserAssignedJiraWorkItems, jiraWorkItemLinkedExternalPullRequests, jiraWorkItemGoals, confluencePageOwners, confluencePageContributors). Each edge type degrades independently, so a missing scope or product never breaks the panel.
  • Matching engine: we deliberately made conflict detection deterministic and explainable. It combines BM25 relevance over weighted decision fields, guardrail phrase detection (stemming, aliases like pg → postgres, gap-tolerant phrases, de-duplication of overlapping hits), and scope-tag overlap with Jira labels and components. Every verdict comes with a reason a human can audit. The language understanding comes from Rovo, or from the user's own coding agent via MCP, working on top of structured results. So Precedent needs no LLM of its own, has zero egress, and is "Runs on Atlassian"-eligible.
  • Storage: Forge KVS holds decisions, per-work-item checks (so the panel, the drift feed and the comment trigger agree and never double-comment), the activity feed and settings.
  • Permissions: everything user-initiated runs asUser(). Only the background trigger runs asApp(), to read the changed work item and leave the comment.
  • Quality: 27 automated tests cover the matcher, the ADR parser and the full backend (Forge modules faked in memory). A mock mode of the UI let us iterate on design outside Atlassian.

Challenges we ran into

  • Making "conflict" trustworthy. An LLM verdict on every ticket would be slow, costly and occasionally wrong in ways nobody can explain. Guardrails gave us a precise, explainable signal, and BM25 plus tags gives the softer "this decision applies" signal. Rejected alternatives turned out to be exactly the right guardrails, so we derive them automatically when importing ADRs.
  • One set of actions, three audiences. The same handlers serve the Precedent agent, other people's Rovo agents and external MCP clients. That meant compact JSON results with explicit guidance fields, and inferring context (e.g. the current work item) when a Rovo call has it and an MCP call doesn't.
  • Teamwork Graph schema drift. The API is in Preview, so each traversal is isolated and failures are reported without breaking the experience.

Accomplishments we're proud of

  • A decision recorded in Jira by a human becomes, seconds later, a guardrail that can stop an AI coding agent's plan before it writes code. The same memory serves people and agents.
  • No LLM bill, no egress, explainable verdicts.
  • Precedent is useful in the first minute: import the ADRs you already have, or load the sample log.

What we learned

The best context for AI isn't more documents. It's the decisions behind them, with their owners, their rejected alternatives and their history. Atlassian already holds all of that; it just wasn't being read back at the moment of work.

What's next for Precedent

  • A Bitbucket pull-request check, so drift shows up in code review.
  • Teamwork Graph write: ingest decisions as first-class graph objects so other apps can traverse them.
  • Decision "health" nudges in Rovo when a review date passes or when an owner changes teams.

Bonus prize write-ups

Best Agents (Rovo): Precedent ships a rovo:agent with a tuned prompt and four conversation starters, plus 8 action modules designed as reusable tools. Any Rovo Studio agent can add Check work against decisions or Find who to ask about a decision. The issue panel and ledger open the agent in context with rovo.open() (e.g. Resolve with Rovo on a conflict, Capture decisions with Rovo on a work item). Write actions (CREATE and UPDATE) only run after the agent shows a draft and the user confirms.

Best app with Atlassian MCP: the same 8 actions are exposed as tools through a rovo:mcp module at https://mcp.atlassian.com/forge/61fb6068-b5aa-4043-b082-14fc68386c9c. We ship a plain-markdown SKILL.md (shown and downloadable under Connect agents in the app) that teaches coding agents to run check-work-against-decisions before planning, stop and cite on conflicts, and record new decisions after confirmation. The video shows the agent setup screen: the Rovo agent, the one-line claude mcp add command and the skill file. Our own test org is registered with a personal email address, and Atlassian doesn't enable Rovo for those, so the live Rovo and MCP paths are best exercised on a Rovo-enabled test site.

Best Teamwork Graph integration: Precedent consumes the Teamwork Graph API (requestTeamworkGraph, as the user) to answer who to ask about any decision. The path runs from owners to their teams and current Jira work, from linked work items to pull requests and goals, and from source Confluence pages to owners and contributors. Results appear in the ledger and through the find-decision-experts action for Rovo and MCP agents.

Built With

Share this project:

Updates

Submission history