Dealcharts: Turning Model Outputs Into Explainable Data Infrastructure
Most hedge funds already have models. What they don't have is lineage.
Cashflow engines, prepayment models, macro frameworks — they all generate projections, but once a run finishes, the assumptions, data, and provenance disappear. Analysts see outputs, not context. Teams can't easily trace why a number moved, or what input caused it.
Dealcharts was designed to solve that — first for CMBS, but the model applies to any structured or high-value dataset. It turns data and model runs into a live, explainable graph, where every entity, variable, and outcome carries provenance. The concept generalizes far beyond real estate: it's a blueprint for how hedge funds, asset managers, and data-driven firms can make their internal data explainable, auditable, and agent-ready.
The Core Problem: Data Without Context
Quant funds spend millions on data ingestion and model engineering — yet much of their data layer is still flat. CSVs and Parquet tables lack memory. The same dataset might exist in ten versions across different analysts' folders. Worse, when regulators, LPs, or PMs ask, "Where did that number come from?", the answer involves Slack threads, not lineage graphs.
Across domains — credit, rates, equities, alternatives — the pattern is the same:
- Fragmented sources: Vendor feeds, APIs, filings, and internal marks live in silos.
- Ephemeral models: Scenario runs are disposable; no persistence of assumptions or outputs.
- Lost provenance: Data lineage is manual or nonexistent.
- Unverifiable outcomes: No audit trail ties model outputs to their sources.
The result: slow backtesting, weak explainability, and expensive data reconciliation.
The Concept: "Model-in-Context"
Dealcharts' prototype for structured finance introduced a universal pattern called Model-in-Context:
Every dataset, fact, and model output should exist as a node in a context graph that records where it came from, when it was last updated, and how it relates to other data.
That means:
- Every model run can be rehydrated, compared, or audited later.
- Every dataset carries its lineage: source → transformation → output.
- Every analyst query is explainable — down to which filing, trade, or input parameter influenced it.
Applied to CMBS, this context graph connected EDGAR filings, rating-agency presales, computed pool metrics, and scenario outputs. Applied to hedge-fund research, it can connect:
- trade-level risk exposures to source models,
- pricing curves to vendor datasets,
- portfolio P&L to data versions and assumptions,
- or even ESG signals to underlying filings.
The specific domain doesn't matter — the architecture does.
Architecture: From Static Tables to Living Graphs
The implementation revolves around three ideas: identifiers, facts, and provenance.
1. Stable Identifiers
Each entity — whether it's a deal, bond, fund, portfolio, or instrument — gets a deterministic ID:
dcid:deal/<shelf><year>-<series>dcid:fund/<lei>dcid:portfolio/<uuid>
Identifiers anchor relationships and enable cross-domain joins. For quant systems, this becomes the key that links internal risk data, external sources, and historical versions.
2. Machine-Readable Facts
Every page, dataset, or model output has a corresponding JSON endpoint (
) that exposes the structured representation of the data, complete with:/facts/<slug>.json
- inputs and assumptions,
- outputs and metrics,
- timestamps and sources,
- and version hashes for change tracking.
3. Provenance as a First-Class Field
Every record carries:
{"isBasedOn": ["source_url_1", "source_url_2"],"updated_at": "2025-10-03T12:00:00Z","curated_by": "system|analyst","confidence": 0.98}
This transforms any dataset — pricing, liquidity, credit, ESG, or macro — into an explainable object.
Practical Impact for Hedge-Fund Data Teams
Think of this as data infrastructure for explainable speed. Instead of rebuilding one-off pipelines for each model or strategy, teams can run their analytics against a consistent graph that understands:
- What changed (data diffing at source level)
- When it changed (temporal lineage)
- Why it changed (explicit provenance)
- Who changed it (curator attribution)
This enables:
- Faster re-runs of models when inputs update.
- Deterministic backtests that reflect historical state.
- Automatic compliance logs for audit and model validation.
- AI-readiness — context that large models can consume directly.
From Structured Finance to Structured Everything
Dealcharts started with CMBS because it was tractable: clear identifiers (CIK, ISIN), structured filings, and observable updates. But the same pattern applies to:
| Domain | Example of Entity Graph | |--------|-------------------------| | Credit & Loans | loan → borrower → collateral → servicer | | Equities | issuer → filings → corporate actions → index memberships | | Rates / Macro | curve → data source → policy event → derived metrics | | Alt Data | dataset → provider → transformation → output variable | | Fund Data | position → security → source feed → model version |
Wherever there's data with relationships, a context graph can make it durable and explainable.
Transparency and Trust as Competitive Advantages
Hedge funds are private by design — but data transparency doesn't mean disclosure; it means internal trust.
Dealcharts' roadmap focuses heavily on publisher strength and data assurance:
- Documenting validation methods.
- Tracking freshness and coverage.
- Publishing machine-readable lineage for every dataset.
That same playbook works for internal quant infrastructure:
- Expose datasets as verifiable objects with metadata.
- Publish internal
endpoints or JSON mirrors./facts - Version model outputs automatically.
- Tie every variable back to its source.
This internal transparency reduces reconciliation risk, supports regulators and LP reporting, and enables LLM agents or automation to reason over your data safely.
Temporal Authority: Time as Metadata
Markets evolve hourly, but most data warehouses flatten time. Dealcharts' "temporal authority" layer solves this by attaching "valid_from", "valid_to", and "updated_at" fields to every record.
For funds, this makes it trivial to:
- Recreate the exact state of data as of any date,
- Detect drift between versions,
- Audit signals used in historical backtests, and
- Align research timelines with data reality.
Temporal lineage turns static analytics into verifiable history.
From Datasets to Agents
The endgame is not just transparency — it's agency. Dealcharts' roadmap introduces the concept of Agentic Readiness: preparing datasets so that autonomous systems — LLMs, research assistants, or trading agents — can query, interpret, and trust them.
To do that, every entity must carry:
- a stable ID,
- machine-readable context,
- and attested provenance.
This is how quant systems evolve from reactive dashboards to proactive agents — querying, alerting, and deciding based on verifiable facts.
Quantitative Advantages
For hedge funds, the payoff is immediate and compounding:
- Faster model iteration – rebuild or backtest instantly from stored context.
- Explainable outputs – trace every prediction or scenario back to data.
- Cross-domain joins – unify credit, macro, and alt-data layers through shared IDs.
- Lower data latency – no more manual scraping or reconciliation.
- Audit readiness – built-in lineage meets compliance requirements.
When every number has a source, models stop being black boxes. They become explainable, testable, and composable across teams.
The Road Ahead
Dealcharts' roadmap breaks the buildout into clear phases that apply universally:
- MVP: establish canonical identifiers and JSON endpoints.
- Scale: expose all datasets in structured, documented form.
- Authority: publish lineage, validation, and provenance openly.
- Optimization: measure freshness, trust, and LLM citation performance.
Replace "CMBS" with "portfolio," "loan," or "macro dataset," and the architecture still holds.
The pattern is universal: Run → Store → Contextualize → Publish → Explain.
Conclusion
Model-in-Context isn't about real estate — it's about data that can explain itself. Dealcharts just happened to prove it first in structured finance.
For hedge funds and quantitative research teams, this approach defines the next frontier of data infrastructure: live, versioned, and explainable; agent-ready by design; and fast enough to turn every run, trade, or update into a reusable outcome.
In a world where explainability is alpha, this isn't just better data engineering — it's how you turn your internal data into a competitive advantage.
Last updated October 30, 2025 • Sources: Dealcharts GEO Playbook & CMD+RVL Signals