AIracle: The Predictive Engineering Intelligence Platform

Inspiration

We realized that modern "AI Code Assistants" are addressing the wrong end of the pipeline. They help developers write code faster, but they don't prevent developers from writing the wrong code faster. Traditional CI/CD tools only catch errors after the work is done and the pipeline runs. We wanted to build a system that shifts everything leftpredicting outcomes, preventing architectural drift, and surfacing lost institutional memory before the code is even written.

What it does

AIracle is a predictive Engineering Intelligence platform powered by GitLab Orbit and GitLab Duo Custom Agents. It orchestrates a council of specialized AI agents that analyze code changes not just for syntax, but for business impact.

It answers the question: "What is likely to happen if we merge this?"

AIracle provides:

• Business Outcome Predictions: Translates technical signals into probabilities for merge conflicts, defects, review delays, rollbacks, and production incidents.
• Engineering Memory System: Surfaces the architectural rationale and lessons learned from the original authors of the code, preventing the repetition of past incidents.
• Shift-Left Sandbox (Future Simulator): Projects a "Shadow Graph" of the codebase during the Draft MR stage to prevent architectural drift before CI/CD even runs.
• Prediction Feedback Loop: An Evolution Engine that compares past AI predictions against actual post-deployment outcomes, allowing the system to continuously calibrate its own predictive models.
• Pre-Generation Prevention: Context Injection APIs that inject blast radius and legacy constraints into the developer's IDE before they start generating code.

How we built it

We built AIracle using a multi-agent orchestration architecture within GitLab:

1. GitLab Orbit Integration: We tapped into Orbit to generate relationship graphs, identifying who originally authored symbols and calculating the true blast radius of changes.
2. GitLab Duo Custom Agents: We designed a fleet of specialized agents (Oracle's Eye, Ghost Reviewer, Future Simulator, Evolution Engine, etc.), each with a distinct analytical role.
3. GitLab Workflow: A central 00-airacle-flow.yml orchestrates the execution of these agents, passing context between them and synthesizing their outputs into a final actionable business prediction.
4. Self-Evolving YAML: The Evolution Engine processes feedback loops and proposes surgical YAML patches to the other agents' prompts, opening human-reviewed MRs to self-improve the system.

Challenges we ran into

• Moving Beyond "Confidence Scores": It was challenging to shift the AI from giving a generic "75% confident" score to generating actionable business predictions (e.g., "30% chance of a rollback"). We solved this by mapping specific agent technical signals to business outcomes.

• Agent Orchestration: Coordinating 8+ specialized agents required a robust central workflow that could handle missing data gracefully and detect complex cross-signal amplifiers (e.g., risky author + overloaded reviewer + high blast radius).

Accomplishments that we're proud of

• The Prediction Feedback Loop: Building a system that actually learns from its mistakes by comparing its predictions to post-deployment reality and proposing MRs to update its own system prompts.
• Engineering Memory: Moving beyond git blame to use Orbit for tracking symbol-level authorship, allowing AIracle to channel the wisdom of developers who have long since left the company.

What we learned

• Context > Intelligence: A simpler LLM prompt with rich, graph based context (Orbit) vastly outperforms a complex prompt with no context.
• Preventative AI is the Future: The highest ROI for AI in software engineering isn't writing code for developers; it's providing developers with the systemic context they need to make the right architectural decisions from the start.

What's next for AIracle

• Deeper IDE Integration: Expanding the Context Injection API to proactively alert developers in their IDE when they touch a highly coupled component.
• Automated Architectural Refactoring: Allowing the Future Simulator to not just warn about architectural drift, but to propose refactoring MRs that align the codebase with the target architecture.

Built With

• antigravity
• gitlab
• gitlab-duo
• gitlab-orbit