Inspiration

Organizations make important decisions every day, but those decisions don't always reach the documents employees rely on.

Imagine a finance team approving a new $1,500 reimbursement threshold while an active checklist still requires approval above $500. Both documents exist in Confluence, but employees receive conflicting instructions.

This is decision drift: when operational guidance no longer reflects approved organizational decisions.

Enterprise search helps people find information. But finding a document doesn't necessarily mean its instructions are still valid.

That inspired DecisionProof, an AI-powered decision auditor designed to identify outdated guidance, explain contradictions, and help teams keep their operations aligned with organizational decisions.

What it does

DecisionProof is an Atlassian Forge application powered by Rovo that audits Confluence spaces for inconsistencies between approved decisions and operational documentation.

Instead of requiring users to manually identify every relevant document, DecisionProof discovers pages within a Confluence space, retrieves their contents, and evaluates potential contradictions.

Key capabilities

  • Space-wide auditing: Discovers and examines Confluence pages within a selected space.
  • Decision verification: Compares approved decisions against operational instructions.
  • Context-aware reasoning: Considers effective dates, document status, and policy scope to distinguish genuine contradictions from legitimate exceptions.
  • Evidence-backed findings: Explains potential conflicts using references to source documents.
  • Retrieval diagnostics: Records HTTP response status, extracted content length, and truncation information.

In an initial controlled test, DecisionProof identified an outdated reimbursement checklist requiring approval above $500, despite a governing decision establishing a $1,500 threshold.

It also distinguished historical policies and travel-specific exceptions from genuine contradictions.

Our goal is to help organizations act on the decisions they've actually made, rather than outdated instructions.

How we built it

DecisionProof was developed using Atlassian Forge, Atlassian Rovo, JavaScript, Node.js, and the Confluence REST APIs.

The application uses a custom Rovo agent connected to three Forge actions:

  1. search-confluence — Searches Confluence using Confluence Query Language (CQL).
  2. list-confluence-pages — Enumerates pages within a Confluence space.
  3. get-confluence-page — Retrieves page content, version information, and source references.

The agent uses these tools to discover organizational documents and reason about relationships between decisions and operational procedures.

We implemented a lightweight document-processing layer that converts Confluence storage-format content into readable text while preserving basic headings, paragraphs, and table boundaries.

We also added retrieval telemetry to record HTTP status, character count, and whether retrieved content was truncated.

Development and testing were conducted in a synthetic Confluence workspace containing approved decisions, operational procedures, historical policies, and scope-specific exceptions.

The application is version-controlled using Git and GitHub, with much of the development and deployment performed through Termux on Android.

Challenges we ran into

Authentication and API compatibility

Initial Confluence API requests from Rovo actions encountered authentication errors. We switched to app-context requests for the development prototype while recognizing that production use requires appropriate authorization controls.

An older Confluence content endpoint also returned HTTP 410, requiring migration to the Confluence REST API v2.

Preserving document structure

Our initial HTML extraction removed tags but also lost important formatting, particularly table boundaries.

We improved the extraction process to preserve basic document structure and decode common HTML entities.

Distinguishing contradictions from exceptions

Different instructions are not always contradictory. Historical policies, future-effective decisions, and scope-specific exceptions require careful interpretation.

This led us to design controlled tests that evaluate whether DecisionProof can distinguish genuine conflicts from legitimate differences.

Developing on Android

Building and deploying a Forge application using Termux introduced challenges involving command-line tooling, debugging, and environment configuration.

These constraints encouraged incremental development, careful testing, and maintaining a stable GitHub baseline.

Accomplishments that we're proud of

  • Built and deployed a working Forge-powered Rovo agent integrated with Confluence.
  • Implemented custom actions for Confluence search, page retrieval, and space-wide enumeration.
  • Completed an initial six-page controlled audit, invoking page-reading actions for all six pages.
  • Identified a genuine contradiction between an approved Finance decision and an outdated reimbursement checklist.
  • Distinguished historical documents and travel-specific exceptions from active contradictions in the controlled test.
  • Improved document extraction to preserve basic structural boundaries.
  • Added retrieval telemetry and verified successful HTTP 200 retrieval with no truncation.
  • Established a version-controlled GitHub repository for continued development.

A particularly meaningful milestone was moving from manually comparing two selected documents to having DecisionProof independently enumerate and examine an entire small Confluence space.

What we learned

Building an AI agent that retrieves documents is different from building one that evaluates whether organizational instructions remain valid.

Reliable decision auditing requires understanding authority, effective dates, scope, exceptions, and supporting evidence, not simply matching similar text.

We also learned that AI-generated findings need verifiable source references and observable retrieval behavior.

Most importantly, organizational context can help teams not only find knowledge but also recognize when that knowledge has become inconsistent.

What's next for DecisionProof

Our next development milestones include:

  • Expanded evaluation: Testing future-effective decisions, semantic contradictions, and ambiguous policy relationships.
  • Persistent audit findings: Storing structured findings and source metadata for later review.
  • Human-approved Jira remediation: Allowing users to review and approve corrective Jira issues.
  • Findings interface: Building a lightweight Forge interface for reviewing audit results.
  • Broader validation: Comparing DecisionProof against ordinary Rovo Chat and testing more realistic organizational documents.

Our long-term vision is to help organizations maintain alignment between the decisions they make, the knowledge they publish, and the work their teams perform.

DecisionProof: Making organizational knowledge not just searchable, but accountable.

Built With

Share this project:

Updates

Submission history