Sentinel-9

Thumbnail
System Architecture
Flowchart
Workflow
UML Sequence Diagram
Working Architecture

Inspiration

The idea for Sentinel-9 was born from two painful realities we’ve faced in corporate tech:

The "3 AM PagerDuty" Fatigue: SREs are burning out. We realized that nearly 40% of production incidents are "low-hanging fruit"—simple config errors or missing null checks—that still require an engineer to wake up, diagnose, and patch manually. The "Silent Data Leak": In fast-moving teams, sensitive data (PII/PHI) often slips into Jira tickets or Confluence pages during frantic debugging sessions, creating massive compliance risks (HIPAA/GDPR) that go unnoticed until an audit.

We asked: What if we could build a single agent that acts as a Tier-1 SRE to fix bugs instantly AND a Compliance Officer to protect data proactively?

What it does

Sentinel-9 is an autonomous AI agent running natively on Atlassian Forge that operates in two distinct modes:

Mode 1: SRE Detective (The Fixer) When an incident is created in Jira Service Management: Analyses the ticket logs and stack traces instantly. Investigates the connected GitHub repository to find the exact "culprit commit" that caused the breakage.Fixes the code by generating a solution, creating a new branch, and opening a GitHub Pull Request with the fix—all in under 10 seconds. Updates the Jira ticket with the root cause, confidence score, and link to the fix PR.

Mode 2: Compliance Guard (The Protector) When a page is updated in Confluence or a comment is posted in Jira: Scans content in real-time using hybrid Regex + AI detection. Identifies sensitive PII/PHI (SSNs, Credit Cards, Medical Records). Redacts the data automatically (or flags it for removal) to prevent data leaks before they happen. Logs the event in a secure audit trail for compliance reporting.

How we built it

We architected Sentinel-9 as a "Headless Agent" rather than a chatbot, focusing on speed and autonomy. Core Platform : Built on Atlassian Forge (Node.js runtime) to leverage its secure infrastructure, Async Events (avi:jira:created:issue), and Storage API.

The Brain : We integrated Groq's LPU (Language Processing Unit) running Llama-3.3-70B. This gives us an inference speed of ~800 tokens/second (20x faster than GPT-4), allowing the agent to read code diffs and write fixes in near real-time

The Hands : We utilized the GitHub REST API v3 extensively. We didn't just read code; we built a complex "Git-over-HTTP" engine that manipulates Blobs, Trees, and Commits to create valid Pull Requests programmatically without cloning the repo.

The Shield : For compliance, we implemented a dual-layer detection system: fast Regex patterns for immediate flagging, followed by an LLM verification step to reduce false positives.

Challenges we ran into

The "Empty Branch" Dilemma : GitHub's API rejects creating a branch without a commit, and you can't create a commit without a parent. We had to reverse-engineer the Git internal workflow (Blob → Tree → Commit → Ref) to allow our agent to create "Ghost PRs" from scratch.

Token Economics : Sending full file diffs to an LLM quickly hits context limits. We built a smart "Diff Truncator" that summarizes large files while preserving the critical changed lines, reducing token usage by 70% while maintaining 90% fix accuracy.

Environment Constraints : Working with Forge's runtime environment meant we couldn't rely on traditional server-side secrets management in the early stages, forcing us to be creative with configuration management for our specialized API keys.

Accomplishments that we're proud of

True Autonomy: We achieved a Zero-Touch Workflow. From the moment a Jira ticket is created to the moment a Fix PR is ready for review, no human intervention is required.

Speed: We reduced the Mean Time to Resolution (MTTR) for code-based incidents from an industry average of 4.5 hours to ~6 seconds.

Accuracy: In our rigorous testing (including memory leaks and DB pool exhaustion bugs), Sentinel-9 achieved a 90% confidence rate, correctly identifying the culprit commit and generating valid code fixes.

Cost Efficiency: By using Groq's efficiency, the cost per incident analysis is approximately $0.0003, compared to hundreds of dollars in engineering time.

What we learned

Agents > Chatbots: We learned that for DevOps, "chatting" with an AI is too slow. The real value unlocks when the AI can act on events in the background.

Structured AI is King: We mastered the art of forcing LLMs to output strict JSON schemas. Without this, integrating the AI's "thoughts" into the Jira API would have been impossible.

The Power of Forge: We gained deep appreciation for Forge's Async Events system, which allowed us to decouple the heavy AI processing from the user's UI experience, keeping Jira snappy.

What's next for Sentinel-9

Native Forge Intelligence: Our immediate next step is migrating our inference engine from Groq to Atlassian Intelligence (Forge LLM) once the EAP APIs are fully available for our use case, ensuring data never leaves the Atlassian ecosystem.

Multi-Repo Support: Extending our "SRE Detective" to scan across microservices and multiple repositories to find cross-service breaking changes.

Rovo Agent Integration: We have designed a "Phase 2" architecture to integrate Atlassian's Rovo, allowing developers to interactively query Sentinel-9's findings via natural language in chat.

Compass Integration : We designed Sentinel-9 with Compass integration in mind for enterprise deployments where you have hundreds of services. For this demo, we're using a direct GitHub configuration, but the architecture supports auto-discovery through Compass.

Proactive Chaos Engineering: Future versions will not just fix bugs but suggest architectural improvements to prevent them, closing the loop on reliability.