Capability · Relational

Relational intelligence

Relational intelligence treats the links between records as data in their own right. It resolves scattered records into real entities, builds the graph of how they relate, and reads that structure — communities, influence, dependencies and how signal propagates — to surface what attribute-only models never see. The result is a signal someone can act on, with the path from raw record to conclusion kept explicit.

The problem

Why attribute-only views miss the signal

Most systems store each record on its own row and reason about it in isolation: this account, this transaction, this device. But the same real-world entity shows up under slightly different data in a dozen places, and the behavior that matters lives between records, not inside one. When identities stay fragmented and relationships are never modelled, the structure that would explain a case — who connects to whom, through what, and in what order — is invisible. You end up reacting to isolated events instead of reading the pattern they form together.

At Pryma

What relational intelligence means here

Relational intelligence is the capability that turns connected data into an accountable signal. It is not a single model or a chart: it is the path from raw records to a conclusion you can trust. First we resolve entities — unify the records that refer to the same thing — then we build the graph of relationships between them, and then we run graph analytics over that structure. Every step keeps its lineage, so a conclusion can be traced back to the records and links that produced it, not accepted on faith.

How it works

From isolated records to actionable signal

The capability runs as an explicit pipeline. Scattered records are resolved into entities; the entities become a graph of relationships; graph analytics read the structure; and the structure yields a signal that feeds a decision or an action. Each stage names what it produces, so the output of one is the honest input of the next.

From records to signal
R1
Isolated recordsScattered rows from many sources — accounts, transactions, devices, events — each describing one thing in isolation.→ raw records
R2
Entity resolutionUnify the records that refer to the same real entity, resolving duplicates and near-matches into one resolved identity.→ resolved entities
R3
Relationship graphConnect the resolved entities by how they actually relate — shared attributes, transactions, references — into one graph.→ graph of relations
R4
Graph analyticsRead the structure: detect communities, rank influence, map dependencies and trace how signal propagates across links.→ structural signal
R5
Actionable signalTurn the structure into a signal a person or a process can act on, with the lineage back to the records that produced it.→ decision / action
The relational pipeline: isolated records are resolved into entities, connected into a graph, analysed for structure, and turned into an actionable signal.
What the graph reveals

Four reads on the structure

Once the graph exists, the same structure can be read in different ways. These are the four reads relational intelligence relies on most — each answers a different question about how the entities relate.

  • Communities

    Which entities cluster together more tightly than chance would explain — segments, rings or groups that behave as a unit rather than as individuals.

  • Influence

    Which nodes carry weight in the structure: the entities whose position means a change in them moves much of the rest of the graph.

  • Dependencies

    Which relationships a given entity or process actually relies on, so a single point of failure or a hidden chain of exposure becomes visible.

  • Signal propagation

    How an effect spreads along the links — a risk, a behaviour or an event moving from one entity to its neighbours and onward through the graph.

Example scenarios

What this looks like in practice

Illustrative examples — not case studies, clients or results.

  • The same customer appears under three slightly different records across systems: entity resolution unifies them into one identity, so the full relationship is read as a whole instead of three partial views.

  • A set of accounts looks ordinary one by one, but the graph shows them densely connected into a single community acting together — a structure that only appears once the relationships are modelled.

  • A dependency map traces how one entity's exposure propagates to the entities linked to it, so the chain of effect is visible before it reaches the end of the line.

How we deliver it

From scattered data to a graph you can read

We build the relational layer around your data: we define what counts as the same entity, model the relationships that matter, and choose the graph analytics that answer your actual question — then wire the lineage so every signal can be traced back to its source.

  • Define the entity resolution rules — what makes two records the same real thing.
  • Model the relationships that carry signal, and build the graph from your sources.
  • Choose the analytics per question: communities, influence, dependencies or propagation.
  • Keep lineage end to end, so every conclusion traces back to the records behind it.
Related capabilities

What relational intelligence feeds

Have connected data to read?

Tell us the records and the relationships that matter. We'll build the resolution and graph that turn them into signal.