CONSEQUENCE

Before you change one thing, see what else breaks. CONSEQUENCE uses AI and dependency graphs to simulate cascading real-world impacts before a change happens.

Comment

Inspiration

Real-world decisions rarely change just one thing.

A clinic relocation, facility change, policy update, service reroute, or operational change can trigger consequences across accessibility, capacity, transportation, safety, logistics, staffing, and other connected dependencies.

The problem is that these dependencies are often scattered across different documents, plans, policies, schedules, and reports. A decision-maker may understand the immediate change without seeing what happens several steps downstream.

We wanted to build a system that could answer a simple question before a decision is made:

Before you change one thing, what else breaks?

That idea became CONSEQUENCE.

What it does

CONSEQUENCE is an evidence-grounded AI system for change impact analysis.

A user provides evidence such as plans, reports, policies, schedules, or other structured and unstructured information, then describes a proposed change.

CONSEQUENCE:

  1. Extracts entities, facts, and relationships from evidence using AI.
  2. Builds a machine-readable model of the system and its dependencies.
  3. Interprets a natural-language change into structured mutations.
  4. Simulates the proposed change through the dependency graph.
  5. Identifies cascading consequences beyond the directly changed component.
  6. Ranks consequences by impact, severity, and confidence.
  7. Shows the propagation path and supporting evidence.
  8. Generates prioritized mitigation actions.

The key idea is that AI is not simply being used to summarize documents or generate a chatbot response.

AI helps understand messy evidence, discover possible dependencies, interpret changes, and explain consequences. The deterministic engine handles graph traversal, change propagation, scoring, and ranking so the simulation remains inspectable and reproducible.

For our demonstration, CONSEQUENCE analyzes a community clinic relocation from Building A to Building B.

The system identifies consequences such as reduced appointment capacity, accessibility problems, longer ambulance access time, uncertain pharmacy cold-chain support, delivery conflicts, increased transit burden, and reduced waiting capacity.

How we built it

The system follows this pipeline:

Evidence → AI Extraction → World Model → Change Interpretation → Dependency Propagation → Consequences → Risk Ranking → Action Plan

We built a typed dependency graph that represents entities and relationships extracted from evidence.

We separate:

  • Evidence-grounded relationships that can participate in the executable world model.
  • AI-generated hypotheses that represent possible hidden dependencies and require validation before becoming executable relationships.

Natural-language changes are converted into explicit mutations such as removing an existing relationship, adding a new relationship, or updating a property.

After the mutation is validated, the deterministic simulation engine traverses the affected dependency graph, calculates propagation paths and depths, and ranks the resulting consequences.

This hybrid architecture lets us combine the flexibility of AI reasoning with the reproducibility of deterministic computation.

Challenges we ran into

The hardest part was not generating text with an AI model. It was making AI reasoning useful without allowing unsupported assumptions to silently affect the simulation.

We had to solve several challenges:

  • Turning heterogeneous evidence into structured entities and relationships.
  • Keeping evidence references attached to extracted information.
  • Separating confirmed relationships from uncertain AI hypotheses.
  • Converting natural-language changes into safe, explicit mutations.
  • Detecting cascading effects across multiple dependency levels.
  • Handling uncertainty and conflicting evidence.
  • Making the final consequences explainable rather than producing unexplained AI predictions.

We addressed these with strict schemas, evidence references, validated mutations, typed dependency relationships, bounded graph traversal, deterministic scoring, and explicit confidence handling.

Accomplishments that we're proud of

We are proud that CONSEQUENCE goes beyond a conventional document chatbot or summarization tool.

For our clinic relocation scenario, the system builds a structured world model, interprets the proposed relocation, simulates the counterfactual state, traces cascading effects, ranks the consequences, and produces mitigation actions.

Most importantly, the result is inspectable.

A judge can follow a consequence backward through its propagation path and see the evidence and dependencies that contributed to it.

That led us to our core principle:

Don't just tell people what changed. Show them what changes because of it.

What we learned

We learned that effective AI decision-support systems need a clear boundary between reasoning and execution.

Language models are powerful at interpreting unstructured information and discovering possible relationships, but deterministic systems are better suited for graph traversal, propagation, validation, and reproducible scoring.

Combining both gave us a system that is flexible enough to understand messy real-world evidence while remaining structured enough to inspect how a consequence was reached.

What's next for CONSEQUENCE

The current system demonstrates the core change-impact engine using a clinic relocation scenario.

Next, we want to expand CONSEQUENCE to support more real-world domains such as facilities, logistics, infrastructure, operations, compliance, and organizational planning.

We also want to improve evidence ingestion for richer document and image inputs, expand the dependency model, and make counterfactual simulations more powerful across larger systems.

The long-term vision is simple:

Before making a change, understand its consequences.

Built With

Share this project:

Updates

Submission history