Finance still doesn't have a proper data layer — and an ontology can fix it.

Your data pipeline broke again — not because of the feed, but because vendor A calls it adjusted_close, vendor B calls it close_adj, and your intern called it price. This is not a naming problem. It is an ontology problem — and the difference matters, because a naming problem is fixed once and an ontology problem compounds until you fix the architecture.

The global financial data services market reached $29.5 billion in 2024 and is on track to exceed $63 billion by 2032. Yet a significant portion of every quant team's working time is consumed not by alpha generation, but by identifier mapping, schema reconciliation, and corporate-action normalisation. A pricing quant developer once put it bluntly: data retrieval, storage, cleaning, and normalisation was "about 80% of my job." The alpha model — the intellectual product the firm actually pays for — was the remaining 20%.

This is not a resource problem, and it is not a talent problem. It is a structural problem rooted in the absence of a shared semantic layer. Financial data exists in parallel semantic universes that were never designed to converge. Each failure mode is well understood in isolation; together they compound into a productivity catastrophe. The solution has existed in computer science for decades — the financial industry has simply failed to adopt it at infrastructure scale.

Bloomberg's own survey of more than 150 quants and data scientists confirmed that progress with AI in quantitative research "is increasingly shaped by data readiness rather than experimentation alone." The firms with clean, semantically consistent data are pulling ahead. The rest are running faster on a treadmill.

An instrument exists simultaneously under five or more identifiers with no formal cross-reference standard, and that is only the first of five compounding failures. The defining property of all five is that they are silent: none produces a runtime error, all produce plausible-looking data.

Consider a quant PM at a mid-size macro fund backtesting a cross-asset equity–rates strategy. In week one the equity universe join fails because one feed uses FIGI and another internal RIC codes; split factors are applied inconsistently between two equity vendors; earnings dates diverge by 1–3 days on pre-market vs after-hours conventions; the macro indicator uses final-revised figures rather than real-time release vintage, injecting look-ahead bias; and rates data joins on identifiers with no formal link to the equity issuer model.

An ontology, in the W3C technical sense, is a formal specification of the concepts, relationships, and constraints within a domain, expressed in a machine-interpretable language. The substrate is RDF (Resource Description Framework) — a graph model of subject–predicate–object triples — and the vocabulary layered on top is OWL (Web Ontology Language), which defines classes, properties, restrictions, and axioms, enabling automated reasoning.

Crucially, an ontology is not a database schema (structure, not meaning), a data dictionary (human-readable, not machine-inferrable), a taxonomy (hierarchy without axioms), or a knowledge graph. A knowledge graph is the populated instance of an ontology — the distinction is precisely that between a class definition and an object instance in OOP. Bloomberg runs one of the most sophisticated financial KGs in production; the KG holds the instances, the ontology defines what those instances mean.

The three working parts are classes (fin:Instrument, fin:Equity, fin:CorporateAction, fin:PriceObservation, fin:LegalEntity), properties — object properties like fin:issuedBy and fin:listedOn, datatype properties like fin:hasISIN and fin:closePrice — and axioms, the constraints instances must satisfy: cardinality (an Equity has at most one ISIN per jurisdiction), domain/range (fin:adjustedBy requires a fin:CorporateAction), and temporal validity. A database schema can encode classes and properties. Only an ontology encodes the axioms.

# Minimal Equity definition in Turtle / OWL 2
fin:Equity        a owl:Class ; rdfs:subClassOf fin:Instrument .
fin:hasISIN       a owl:DatatypeProperty ;
    rdfs:domain fin:Instrument ; rdfs:range xsd:string ;
    owl:cardinality 1 .                # exactly one ISIN per jurisdiction
fin:adjustedBy    a owl:ObjectProperty ;
    rdfs:domain fin:PriceTimeSeries ;
    rdfs:range  fin:CorporateAction .  # adjusted series ↔ triggering CA

fin:AAPL              a fin:Equity ;
    fin:hasISIN  "US0378331005" ; fin:hasFIGI "BBG000B9XRY4" ;
    fin:hasRIC   "AAPL.O" ; fin:hasPriceSeries fin:AAPL_AdjClose_USD .
fin:AAPL_AdjClose_USD a fin:PriceTimeSeries ;
    fin:priceType fin:AdjustedClose ; fin:currency "USD" ;
    fin:adjustedBy fin:AAPL_SplitEvent_2020_08 .

What that encodes is class hierarchy plus identifier carriers plus adjustment provenance plus cardinality constraints. A relational schema covers the first two slots. The third and fourth are what make it an ontology, not a table.

The industry has not been idle. Multiple standards address fragments of this problem. The honest assessment is that each solves its assigned problem well and fails to integrate with any of the others.

The critical observation is structural. FIGI identifies instruments. LEI identifies entities. ACTUS models cash flows. FIX transmits orders. FIBO conceptualises everything. Nothing links them. The gap between "we use FIBO as our data dictionary" — which many large banks genuinely do — and "our quant data stack is semantically consistent across vendors" is not a small implementation gap. It is an architectural chasm. FIBO grew out of the 2008 crisis into a comprehensive but operationally difficult artefact whose full OWL corpus times out basic consistency checking in standard DL reasoners.

A production-grade implementation does not require deploying full OWL 2 DL reasoning over a tick database. The architecture that eliminates 80–90% of wrangling is a layered semantic model with clear separation of concerns — built from canonical identity up to point-in-time semantics.

A worked sketch makes the identity layer concrete. Two vendor dataframes — one keyed on FIGI, one on RIC — each map their identifiers to a canonical internal node by walking the connected component of an identity graph, then join on the canonical ID. Vendor schemas become irrelevant, and a semantic validation step flags any instrument where the two vendor prices diverge by more than five basis points.

import networkx as nx, pandas as pd

def resolve_canonical(identifier, graph):
    """Walk the connected component; return the 'internal' node."""
    if identifier not in graph:
        return None
    for node in nx.node_connected_component(graph, identifier):
        if graph.nodes[node].get("id_type") == "internal":
            return node
    return None

prices_bbg["canonical"] = prices_bbg["figi"].map(lambda x: resolve_canonical(x, id_graph))
prices_ref["canonical"] = prices_ref["ric"].map(lambda x: resolve_canonical(x, id_graph))

# Join on canonical ID — vendor schemas are now irrelevant
merged = prices_bbg.dropna(subset=["canonical"]).merge(
    prices_ref.dropna(subset=["canonical"]),
    on=["canonical", "date"], how="inner")

# Semantic validation: flag divergence > 5 bps before it reaches the model
merged["price_divergence_bps"] = (
    (merged["close_adj"] - merged["adjusted_close"]).abs()
    / merged["adjusted_close"] * 10_000).round(1)

In a naive pd.merge() the price discrepancy is invisible. In an ontology-aware pipeline the mismatch surfaces before it reaches the model. A production implementation would swap networkx for a property graph database or an rdflib RDF store, and the columnar price store retrieves history for the resolved canonical ID.

The most direct consequence of missing temporal semantics is look-ahead bias — a backtest using information that was not available at the simulated decision. It is the most common mistake in quantitative backtesting and the hardest to detect, because it throws no error, only inflated results. It enters through restated fundamentals, backdated index additions, and vendor timestamp errors. Survivorship bias alone inflates annual S&P 500 backtest returns by 1.5–2.0%, and using final-revised GDP figures instead of real-time vintages produces systematic Sharpe inflation. A point-in-time layer makes this class of error structurally impossible: a query at a given transaction_time cannot return records added afterwards.

Reliability improves the same way. With semantic validation at the identity layer, a price observation without a typed methodology is invalid by schema, and an instrument without a canonical ID cannot enter the pipeline. The failure mode shifts from "silently wrong output" to "loud, early rejection." In production systems ingesting from 10+ vendors daily, silent errors compound faster than loud ones — loud failures are fixed once; silent errors are discovered during performance review.

Cross-asset development and regulatory reporting come along for free. When equities, rates, and FX share one ontological identity and a traversable graph, multi-asset joins become path queries — the same architecture Bloomberg built to "link data across different domains," and that JPMorgan has referenced for counterparty networks. MiFID II and EMIR already mandate LEI-linked transaction reporting; firms that maintain a proper LEI → instrument → counterparty graph generate those reports as a by-product of normal operations. The semantic layer converts compliance from periodic firefighting into a standing query.

The technical implementation is tractable — rdflib handles OWL 2 RL reasoning, Apache Jena serves SPARQL, Neo4j deploys the property graph. The hard problem is organisational. Converging four teams with four vendor contracts, four naming conventions, and four existing pipelines on a shared schema is a political challenge, not a technical one: the transition cost is immediate and certain, the benefit deferred and shared. The successful implementations start small — one asset class, one vendor pair, one pain point. Prove value, expand incrementally.

The performance answer is separation of concerns. Full SPARQL over an RDF triplestore is expressive but not fast over tick-level data — a SPARQL query over 100 billion price observations is the wrong architecture. The resolution is hybrid: the graph layer for identity resolution, relationship traversal, and event normalisation; a columnar time-series store (ClickHouse, ArcticDB, kdb+) for price history. The two communicate through the canonical identity system. Equally, full OWL 2 DL reasoning is overkill: OWL 2 RL, designed for data-intensive Horn-clause reasoning over large triple stores, is the correct profile for enforcing cardinality, validating temporal consistency, and inferring cross-identifier equivalence.

In building Nyquist's data layer we confronted every one of these problems in sequence and in combination. Our approach was to build an identity resolution graph at the core of the API layer — so that regardless of which vendor feed a user queries, instruments, events, and prices resolve to a consistent semantic model.

It is not a full OWL ontology; a full OWL 2 DL deployment would be over-engineered for the use cases we currently serve. What we built is a typed identity graph with bidirectional cross-reference resolution, normalised corporate actions with point-in-time flags, and price observations typed by methodology rather than column name. Semantic consistency is enforced at ingestion — not at query time, and certainly not at analysis time.

The relevant question for quant practitioners in 2026 is not whether to invest in a semantic data layer — the firms with clean, ontology-aware data are already pulling ahead. The question is whether the investment is disciplined: is the identity layer first or bolted on; are price observations typed by methodology or by column name; is bi-temporality enforced for fundamentals or treated as a nice-to-have; is the ontology versioned like an API or maintained by tribal knowledge. A naming problem is fixed once. An ontology problem compounds until you fix the architecture.