Our Secret Sauce: Refractive Graph Propagation

At the heart of ACinch lies a technology we call Refractive Graph Propagation (RGP). It's a fundamentally new approach to understanding relationships in connected data—and it's what allows us to do things that traditional integration platforms simply cannot.

The Problem with Traditional Approaches

Traditional vector similarity systems (like those powering most AI search) provide fast nearest-neighbor lookups, but they have critical limitations:

• No multi-hop reasoning: They can't follow chains of relationships
• No directional context: "A relates to B" is treated the same regardless of how you arrived at A
• Static results: The same query always returns the same neighbors, regardless of context

Graph databases solve some of these problems but introduce others—they perform literal traversal without computing influence or similarity, and they have no concept of directional compatibility.

Enter Refractive Graph Propagation

RGP introduces a physics-inspired model where influence propagates through your data like light passing through optical materials. It's deterministic, explainable, and captures relationships that other approaches miss entirely.

The Core Metaphor: Light Through Materials

Imagine your data as a network of interconnected optical materials. Each piece of information—a task, a message, a contact, a document—is a node with three properties:

• Luminance: How much influence it emits (think: importance or activity level)
• Reflection: How much incoming influence it passes along to connected nodes
• Refraction Index: How much it penalizes directional changes (more on this below)

The connections between data points are edges with their own properties:

• Attenuation: How much influence is lost along this path
• Angle Bin: The semantic direction of the relationship

Why "Refractive"?

Here's where it gets interesting. In physics, light bends when it passes from one medium to another—that's refraction. The angle changes based on the properties of the materials, governed by Snell's Law.

RGP is to graph propagation what Snell's Law is to geometric optics: a rule determining how direction changes across interfaces.

In RGP, we discretize semantic space into directional "angle bins"—typically 16 orientations on a circular manifold. When influence propagates from node A to node B, the system considers whether the direction of that relationship is compatible with how you arrived at A. If you were exploring "sales opportunities" and suddenly the path veers toward "engineering documentation," that directional mismatch creates refraction—the influence bends and attenuates according to an exponential decay function.

This means the same data looks different depending on your context. Query from a sales perspective, and sales-relevant connections light up. Query from an engineering perspective, and different paths illuminate.

Multi-Hop Contextual Reasoning

The real power emerges over multiple hops. Traditional systems can tell you that Customer X is connected to Project Y. RGP can tell you:

• How strongly Customer X influences Project Y
• Through which paths that influence flows
• How that influence changes based on your starting context
• What other entities are illuminated along the way

The algorithm propagates a "frontier" of influence outward from your query point, with each hop applying reflection, attenuation, and refraction calculations. Paths with compatible directionality deliver more intensity. Paths that twist and turn through incompatible semantic directions fade quickly.

Room-Based Partitioning: Lessons from DOOM

Here's something unexpected: our architecture borrows concepts from classic video game engines.

Early first-person shooters like DOOM and Wolfenstein 3D faced a problem—how do you efficiently determine what's visible to the player without checking every single wall and object? Their solution: divide the world into "rooms" connected by "portals," and precompute which rooms can potentially see which other rooms from different angles.

We apply the same principle to data graphs:

• Rooms: Logical partitions of your data (by team, project, time period, etc.)
• Portals: Connections that cross room boundaries
• Potentially Visible Sets (PVS): For each room and angle bin, a precomputed list of rooms that could receive influence

This allows us to prune irrelevant regions of the graph before propagation even begins. The result: queries that would take seconds in a naive implementation complete in milliseconds, even across massive datasets.

How This Powers ACinch

When you look at your ACinch dashboard, RGP is working behind the scenes:

Contextual Activity Feeds

Your feed isn't just a chronological list. RGP determines which activities are most relevant to your current context—what you've been working on, who you've been communicating with, what direction your work is heading.

Intelligent Notifications

Not every update deserves your attention. RGP calculates influence scores to surface what matters and suppress what doesn't, based on your unique position in the organizational graph.

Predictive Surfacing

Before a meeting with a client, RGP propagates influence from that client node outward, illuminating all the connected information: recent communications, open projects, pending invoices, support tickets. It surfaces what you need before you know you need it.

Cross-Tool Discovery

A mention in Slack, a task in Asana, and an email thread might all relate to the same initiative—but live in different systems with no explicit links. RGP finds these implicit connections through multi-hop propagation and directional compatibility.

Comparison to Other Approaches

How does RGP stack up against existing technologies?

Vector Databases (FAISS, Pinecone, etc.)

• Multi-hop reasoning: No
• Direction-aware similarity: No
• Context-dependent results: No
• No training required: Yes

Vector databases excel at fast nearest-neighbor search but are inherently single-hop and global. They can't follow chains of relationships or adapt results based on query context.

Graph Databases (Neo4j, etc.)

• Multi-hop reasoning: Limited
• Direction-aware similarity: No
• Context-dependent results: No
• No training required: Yes

Graph databases perform literal traversal but don't compute influence or similarity. They have no concept of directional compatibility between edges.

Graph Neural Networks (GAT, GraphSAGE, GCN)

• Multi-hop reasoning: Yes
• Direction-aware similarity: No
• Context-dependent results: Partial
• No training required: No

GNNs are powerful but require training, tuning, and retraining when your data changes. Their message-passing steps are fixed per architecture, not per query.

Refractive Graph Propagation

• Multi-hop reasoning: Yes
• Direction-aware similarity: Yes
• Context-dependent results: Yes
• No training required: Yes

RGP is fundamentally different: it's a non-parametric, deterministic propagation model. It performs context-dependent inference without training, batching, or backpropagation—and it gives you different results based on where you start your query.

RGP doesn't replace vector databases or GNNs—it complements them, adding multi-hop reasoning and contextual awareness that embeddings alone can't provide. It represents a new category of contextual similarity computation.

The Technical Foundation

For those curious about the implementation:

• Graph Storage: Compressed Sparse Row (CSR) format with struct-of-arrays layout, memory-aligned for direct GPU upload via mmap
• Propagation: Frontier-based expansion using double-buffered queues, with configurable depth and minimum intensity thresholds
• Angle Bins: 16 discrete orientations on a circular 2D semantic manifold
• Refraction Calculation: Exponential decay based on angular distance and node refraction index
• Distance Metric: Negative log of accumulated influence (a quasi-distance—non-symmetric and may violate triangle inequality, but highly useful for contextual ranking)
• Bounded Attenuation: Propagation naturally decays, guaranteeing termination without explicit depth limits

The Room/PVS system typically reduces edge visits by 5-20x compared to naive traversal. Combined with GPU parallelization where each frontier entry is processed by a thread, the result is a system that can propagate influence across millions of nodes in real-time.

See It In Action

The math is elegant, but what matters is the experience: information that finds you, context that appears when you need it, connections you didn't know existed.

Ready to see it for yourself? Request a demo to experience Refractive Graph Propagation powering ACinch and understand why we believe it's the future of how work tools communicate.