Phoenix: Decision Intelligence for Software Delivery

Phoenix uses GitLab Orbit to build a Software Future Twin that simulates engineering decisions, discovers black swan risks, and coordinates mitigation before code reaches production.

Comment

Inspiration

Software teams make thousands of engineering decisions every day. A merge request may look safe because the pipeline is green, reviews are approved, and tests pass.

But incidents rarely happen because of a single file change.

They emerge from hidden relationships between services, dependencies, ownership structures, vulnerabilities, deployment history, work items, and business objectives.

Current developer tools are excellent at explaining what changed.

They are far less effective at explaining what happens next.

We wanted to explore a different question:

What if every meaningful engineering decision could be simulated before it was executed?

That idea became Phoenix.

What it does

Phoenix is a Decision Intelligence Layer for Software Delivery.

Using GitLab Orbit context, Phoenix builds a living Software Future Twin of the engineering organization.

The twin models:

  • Merge Requests
  • Services
  • Dependencies
  • Contributors
  • Pipelines
  • Vulnerabilities
  • Work Items
  • Incidents
  • Objectives
  • Ownership relationships

Instead of analyzing code in isolation, Phoenix reasons across the entire delivery system.

When a merge request arrives, Phoenix:

  1. Ingests GitLab Orbit context
  2. Builds a Software Future Twin
  3. Simulates multiple future delivery strategies
  4. Searches for black swan risks
  5. Explains causal chains
  6. Recommends mitigations
  7. Coordinates mitigation actions

The result is not a code review.

It is a forecast of the future consequences of an engineering decision.

How we built it

Phoenix combines several intelligence layers:

GitLab Orbit Context Layer

Phoenix ingests repository intelligence including:

  • Contributors
  • Labels
  • Issues
  • Milestones
  • Pipelines
  • Merge Requests
  • Repository signals

Software Future Twin

Phoenix builds a dynamic graph connecting:

  • Services
  • Teams
  • Objectives
  • Vulnerabilities
  • Incidents
  • Ownership structures

This creates a living model of the software organization.

Repository Intelligence Engine

Phoenix derives signals such as:

  • Contributor concentration
  • Ownership concentration
  • Pipeline stability
  • Release pressure
  • Engineering load
  • Issue pressure

Enterprise Memory Layer

Historical incidents, ownership knowledge, dependency risks, deployment history, and strategic objectives become structured memories that influence future predictions.

Simulation Engine

Phoenix evaluates multiple future delivery paths including:

  • Merge Now
  • Canary Rollout
  • Contract Validation
  • Additional Testing

Each strategy produces different outcomes across risk, confidence, deployment success, and incident probability.

Black Swan Detection

Rather than focusing only on average outcomes, Phoenix searches for low-probability high-impact futures.

These are the hidden risks that often escape traditional review processes.

Agent Operations

Phoenix can coordinate mitigations including:

  • Security Reviews
  • Contract Validation
  • Canary Gates
  • Work Item Creation
  • Review Escalations

Challenges we ran into

The hardest challenge was not generating recommendations.

It was building a believable system model.

We needed to connect repository activity, historical incidents, vulnerabilities, ownership structures, and business objectives into a single causal graph capable of supporting simulation.

Another challenge was balancing technical credibility with hackathon storytelling. We wanted Phoenix to feel like a future GitLab product while remaining understandable during a short demo.

Accomplishments that we're proud of

  • Built a dynamic Software Future Twin
  • Created Repository Intelligence scoring
  • Developed an Enterprise Memory layer
  • Implemented Black Swan detection
  • Integrated GitLab context ingestion
  • Created a mission-control style operational interface
  • Built a fully explainable decision engine
  • Implemented autonomous mitigation coordination

What we learned

We learned that software risk is rarely isolated to code.

Many of the most important failures emerge from interactions between people, systems, ownership structures, deployment processes, and business objectives.

By modeling those relationships directly, it becomes possible to reason about future outcomes rather than simply react to incidents after they occur.

What's next for Phoenix

Future development includes:

  • Real-time GitLab GraphQL integration
  • Persistent enterprise memory
  • Multi-repository Software Future Twins
  • Portfolio-level decision intelligence
  • Continuous simulation of delivery risk
  • Organization-wide black swan discovery

Our long-term vision is simple:

Every engineering decision should be simulated before it becomes reality.

Built With

Share this project:

Updates