Odin: Multi-Signal Graph Intelligence for Autonomous Discovery in Knowledge Graphs

Odin is the first production-deployed autonomous graph intelligence engine that utilizes the novel COMPASS multi-signal scoring metric to guide efficient, traceable, and hallucination-free pattern discovery in knowledge graphs, successfully addressing local community entrapment in regulated industries like healthcare and insurance.

The Gist

Imagine you are a detective trying to solve a massive mystery in a city that never sleeps. This city is a Knowledge Graph—a giant web connecting millions of people, places, events, and facts.

In the past, if you wanted to find something in this city, you had to ask a specific question like, "Show me all the people who live on 5th Avenue." This is like using a standard map search. It's great if you know exactly what you're looking for, but it's terrible if you're trying to find a hidden pattern you didn't even know existed.

Odin is a new kind of detective engine designed to do something different: Autonomous Discovery. Instead of waiting for you to ask a question, Odin wanders through the city on its own, looking for interesting clues, hidden connections, and surprising stories that no one has ever noticed before.

Here is how Odin works, explained through simple analogies:

1. The Problem: The "Echo Chamber" Trap

Imagine your detective is walking through a very crowded neighborhood. Everyone knows everyone else there. If the detective just follows the most popular paths (like a standard map), they will keep walking in circles within that same neighborhood, never leaving to see what's happening in other parts of the city.

In data science, this is called the "Echo Chamber" problem. The system gets stuck in dense clusters of data and misses the big picture.

2. The Solution: The COMPASS Score

Odin doesn't just walk randomly; it uses a special tool called the COMPASS (Composite Oriented Multi-signal Path Assessment). Think of this as a high-tech compass that points the detective in the right direction by weighing four different types of "magnetic signals":

• Signal 1: Popularity (Structural Importance)

  • Analogy: "How many people are talking about this?"
  • Odin checks if a path is well-connected. If a fact is linked to many other important facts, it gets a higher score. This is based on a math trick called PageRank (the same logic Google uses to rank websites).

• Signal 2: Common Sense (Semantic Plausibility)

  • Analogy: "Does this make sense?"
  • Just because two things are connected doesn't mean the connection is real. For example, a graph might say "Patient diagnosed with a broken leg" and "Patient treated with Antibiotics." While the graph has these links, common sense says antibiotics don't fix broken legs.
  • Odin uses a "Common Sense Filter" (called NPLL) to say, "Wait, that path is nonsense. Don't go there." This prevents the system from finding fake or silly patterns.

• Signal 3: Freshness (Temporal Relevance)

  • Analogy: "Is this news or old history?"
  • In the real world, old news is less useful than breaking news. Odin gives a higher score to recent events and lets older connections fade away, ensuring the discoveries are relevant to now.

• Signal 4: The Bridge (Community Awareness)

  • Analogy: "The Bridge Builder."
  • This is Odin's secret weapon. It knows which people or places act as bridges between different neighborhoods (communities).
  • If the detective is stuck in the "Claims Processing" neighborhood, Odin sees a bridge to the "Hospital Outcomes" neighborhood and says, "Go across that bridge! That's where the real mystery is!" This stops the "Echo Chamber" trap and forces the system to explore new territory.

3. How It Moves: The "Beam Search"

Imagine you are sending out a team of 64 scouts (instead of just one) to explore the city.

• Exhaustive Search: Sending out a million scouts to check every single street. This is too slow and expensive.
• Random Walk: Sending one scout to wander aimlessly. They might find something cool, but they might also get lost for hours.
• Odin's Beam Search: Sending out 64 scouts. At every intersection, they check the COMPASS score. If a path looks boring or nonsensical, the scouts drop it. If a path looks promising, they keep it. They only keep the top 64 best paths at any given time.

This makes the search incredibly fast (taking less than half a second) but still very smart. It's like having a team of elite detectives who only follow the most promising leads.

4. Why It Matters: The "No Hallucination" Rule

In the world of AI, "hallucination" means making things up. If an AI says, "I found a secret link between two hospitals," but it's made up, that's dangerous in fields like healthcare or insurance.

Odin is built for regulated industries (like hospitals and insurance companies).

• Traceability: Every path Odin finds is backed by real documents. It can point to the exact paper or record that proved the connection.
• No Guessing: It doesn't invent new facts; it just finds hidden connections between facts that already exist.

5. Real-World Success

The paper shares two stories where Odin was actually used:

1. Healthcare: It found a hidden pattern where patients were being transferred between specific facilities and then getting readmitted, a pattern doctors hadn't noticed before.
2. Insurance Fraud: It discovered a fraud ring where five people with no obvious connection (different addresses, different names) were all using the same obscure service provider to file claims. A normal search would have missed this because the fraudsters didn't share "obvious" links. Odin saw the bridge between them.

Summary

Odin is like a super-smart, self-driving tour guide for a massive library of data.

• It doesn't wait for you to ask a question.
• It uses a multi-signal compass to know what's popular, what makes sense, what's new, and where the bridges to new ideas are.
• It moves efficiently, ignoring dead ends.
• Most importantly, it never lies. It only shows you connections that are proven by real evidence.

It turns the job of "finding a needle in a haystack" from a manual search into an automated, intelligent discovery process.

Technical Summary

1. Problem Statement

The paper addresses the critical limitation of current Knowledge Graph (KG) systems: they are primarily retrieval-based, requiring analysts to specify exact queries (e.g., SPARQL, Cypher) to find known patterns. This approach fails at autonomous discovery, where the goal is to identify unknown, meaningful, or emerging patterns without prior hypotheses.

The core challenges in autonomous graph exploration are:

• Coverage vs. Efficiency: Exhaustive multi-hop traversal has exponential complexity ($O(d^h)$), making it intractable for large graphs.
• Signal vs. Noise: Structural connectivity alone is insufficient; graphs contain spurious correlations and semantically implausible paths (e.g., a patient diagnosed with a fracture treated by antibiotics).
• Explainability vs. Performance: Black-box methods (like end-to-end GNNs) struggle in regulated industries (healthcare, insurance) where audit trails and evidence grounding are mandatory to prevent "hallucinations."

2. Methodology: The Odin Framework

Odin is a production-deployed graph intelligence engine designed as a "compass" for AI agents. It separates graph intelligence from natural language reasoning, operating in a two-phase architecture:

A. Architecture

1. Phase 1: Offline Extraction (Nightly):
   • Constructs the KG from source documents (using ArangoDB).
   • Runs Graph Attention Networks (GAT) to detect communities and identify bridge entities (nodes connecting distinct communities).
   • Computes inter-community affinity scores and stores them as metadata.
2. Phase 2: Online Intelligence (<500ms latency):
   • Takes seed entities and performs real-time exploration.
   • Trains Neural Probabilistic Logic Learning (NPLL) models on-demand (lazy reconstruction).
   • Executes Beam Search guided by the COMPASS scoring function.

B. The COMPASS Scoring Function

The core innovation is COMPASS (Composite Oriented Multi-signal Path Assessment), a multiplicative scoring metric that unifies four distinct signals. The multiplicative nature ensures a "veto" property: if any signal is low (e.g., semantic implausibility), the entire path score drops, ensuring safety.

$$COMPASS(p) = S_{edge} \cdot S_{struct} \cdot S_{bridge} \cdot S_{affinity} \cdot S_{prior} \cdot S_{temp}$$

1. $S_{edge}$ (Semantic Plausibility): Uses NPLL as a discriminative filter (not generative). It scores existing edges based on logical rules and neural embeddings. If an edge is medically or logically impossible, it is rejected.
2. $S_{struct}$ (Structural Importance): Uses Personalized PageRank (PPR) to measure the centrality of nodes relative to the seed set.
3. $S_{bridge}$ & $S_{affinity}$ (Community Awareness):
   • Bridge Scoring: Boosts paths passing through "bridge entities" (detected by GNNs) to prevent the "echo chamber" effect where exploration gets trapped in dense local clusters.
   • Affinity Scoring: Rewards edges that cross community boundaries based on inter-community edge density.
4. $S_{temp}$ (Temporal Relevance): Applies exponential decay to older data, prioritizing recent evidence.
5. $S_{prior}$ (Edge Prior): Downweights trivially common relationships (e.g., "located_in").

C. Search Algorithm

Odin employs Beam Search rather than Monte Carlo Tree Search (MCTS).

• Why Beam Search? MCTS is stochastic (non-deterministic), violating audit requirements in regulated industries. Beam search is deterministic, offers $O(b \cdot h)$ complexity, and is fast enough for interactive use.
• Process: At each hop, the algorithm expands the top-$b$ candidates (beam width), scores them using COMPASS, and retains the best $b$ for the next step.

D. Self-Managing NPLL

To reduce operational overhead, Odin uses a "weights-only" storage strategy. It stores only rule weights ($w$) and reconstructs entity/relation embeddings on-demand from the graph, eliminating the need to store massive embedding matrices.

3. Key Contributions

1. Formalization of Autonomous Discovery: Defined the problem as finding a set of paths maximizing a utility function (novelty, significance) under a computational budget, without pre-specifying the target pattern.
2. COMPASS Metric: The first framework to unify structural (PPR), semantic (NPLL), temporal, and community-aware (GNN bridge) signals into a single, principled, multiplicative scoring function.
3. Bridge Scoring Mechanism: A novel method to mathematically compel exploration across community boundaries, solving the "echo chamber" problem where local PageRank traps algorithms.
4. Production Deployment: First autonomous discovery system deployed in regulated environments (Healthcare and Insurance), demonstrating that high-quality discovery is possible without hallucination.
5. Explainability: The system provides Shapley value decomposition for scores, allowing analysts to audit exactly why a path was selected (e.g., "42% due to structure, 35% due to semantics").

4. Experimental Results

The system was evaluated on two production datasets:

• Healthcare KG (HKG): 2.3M entities, 8.7M triples.
• Insurance KG (IKG): 1.8M entities, 6.2M triples.

Key Findings (vs. Baselines):

• Efficiency: Odin explored 65x fewer paths than exhaustive search while achieving 90% coverage (vs. 95% for exhaustive).
• Quality: Odin achieved a quality score of 4.2/5 (actionable insights), significantly outperforming:
  • PPR-only (3.1): Suffered from semantic noise.
  • GNN Embeddings (2.8): Failed to capture multi-hop patterns.
  • Random Walks (3.5): Inefficient and noisy.
• Ablation Study: Removing the NPLL semantic filter dropped quality from 4.2 to 3.1, proving semantic plausibility is the most critical signal. Removing Bridge scoring increased "redundant" insights by 23%, confirming its role in escaping local communities.
• Case Study (Insurance Fraud): Odin discovered a coordinated fraud ring involving 5 policyholders with no shared structured attributes. It identified a common service provider via a 6-hop path, a pattern missed by 127 existing rule-based alerts. This led to $437K in recovered funds.

5. Significance and Impact

• Paradigm Shift: Moves the industry from "Query-Driven" (answering known questions) to "Exploration-Driven" (discovering unknown patterns).
• Regulatory Compliance: By grounding every discovery in source documents and using a discriminative (filtering) rather than generative approach, Odin eliminates hallucinations, making it safe for healthcare and insurance.
• Scalability: The separation of offline GNN computation and online beam search allows the system to handle enterprise-scale graphs ($10^6$–$10^7$ entities) with sub-second latency.
• Agent Integration: The "Compass for Agents" architecture provides a reusable pattern for integrating LLMs with graph intelligence, allowing agents to navigate complex data landscapes autonomously.

In conclusion, Odin demonstrates that autonomous discovery in large-scale, regulated knowledge graphs is not only feasible but transformative, offering order-of-magnitude improvements in analyst efficiency and pattern discovery quality.