Hermetic Valuation: Everything a Price Depends On, in One Document

Most valuations are black boxes that leak: they read from databases, caches and clocks nobody sees, so their numbers cannot be reproduced, moved or shared. OTCStreaming introduces hermetic valuation. All the reference data and market data are handed to the pricing engine in one document, the OTCStreaming correlation, and the engine reads nothing else. Two things follow: every variable of the valuation function is exposed, and the computation can be distributed on isolated compute nodes, with the same answer to the last digit. Valuation becomes portable and auditable, and far larger tensors of analytics, securities × scenarios × greeks, can be produced on the fly.

Valuations That Leak

Every price is the answer to a question nobody writes down: which security, under which conventions, against which curve, calibrated on which quotes, rolled on which holidays, at what moment? In most systems the answer is scattered across databases, caches, reference tables and the server clock, and that leak costs three things:

• You cannot reproduce it. Rerun last month's price and the curves have been recalibrated, a reference record has changed, and nobody can say exactly why the number moved.
• You cannot move it. A computation runs where its data lives, so end-of-day risk, scenario sweeps and Value-at-Risk queue on the same servers as real-time pricing.
• You cannot share it. A server that can reach one client's data cannot safely compute for another, so every private installation must be sized for its heaviest night.

A Glass Box, Not a Black Box

Hermetic does not mean opaque. A valuation can only be closed to the outside if every value it uses is written down inside it: every curve, quote, convention, calendar and model parameter. Nothing may hide in a cache or a default. A hermetic valuation is a glass box, closed to the outside world and transparent to anyone who opens it.

OTCStreaming did not set out to build this, but its design made it possible. At the heart of its pipeline sits the correlation, a single JSON document that brings together the reference data of a security, the market data that prices it and the model parameters that connect the two. Each stage of the pipeline reads it and enriches it, and leaves every addition visible.

Classic software design would object: keep one source of truth, and pass references, not values. That rule is right for systems that update shared data. A valuation does the opposite: it reads a fixed set of inputs and computes. For that kind of work, functional programming and distributed computing chose values long ago: pure functions of immutable inputs, and share-nothing messages that carry their own data. For valuation it buys trust: a correlation that carries its own curves replays to the last digit after the database has moved on, and prices on a node that has no database at all. AI makes it modern: a language model keeps nothing between calls, so a document that holds everything is exactly what it can write, and what a person can check.

On a single server there was no need to go further: the data sat next to the engine. Distributing valuation changed that, and this release switches the option on.

The Self-Contained Correlation

One field added to any latentModel, run or valuation request asks OTCStreaming to do all the knowing — identification, conventions, market snaps, calibration of every latent model — and to stop one step before the arithmetic.

Example: Preparing a Self-Contained Correlation for a Tranche Valuation

{
    "mode": "PrepareCorrelation",
    "stage": "valuation",
    "correlation": {
        "portfolioQueries": [
            {
                "type": "citQuery",
                "query": {
                    "creditIndexSeriesName": "Main Series 46",
                    "attachment": 0,
                    "detachment": 3,
                    "initialMaturity": "5Y"
                }
            }
        ]
    }
}

What comes back is a self-contained correlation: the reference data (securities and models as patched, index compositions, conventions, scenario definitions), the market data (snaps, reference quotes, ISDA rate curves), the calibrated models (survival curves, skew models, base correlation smiles, volatility surfaces) and time itself (the stamped as-of date and every business calendar). It is a large document, a megabyte or two of JSON for a tranche. You do not need to read it to use it. You can, whenever a number looks wrong or an auditor asks how it was produced.

What Hermetic Valuation Gives You

Every number comes with its proof. Store the correlation next to the price and reproduce it to the last digit next week, next year or in front of an auditor. A live request is frozen at the moment it was prepared: the market may move, the answer to that question will not.

Every "what if" runs on a frozen market. Take this morning's correlation, add a scenario — a BEAR shock, a spread widening, a thousand VaR draws — and price it on exactly this morning's market, without preparing again.

Isolated compute nodes. A self-contained correlation runs on an OTCStreaming compute node: the same pricing engine, stripped of every data connection. It holds no data and keeps no state, so adding computing power means adding nodes, with no database to replicate and no cache to warm.

Private instances, pooled computing. Each client keeps its private instance and its data. On top of it, OTCStreaming runs a pooled computing service: instead of a bigger machine for one client, processors drawn from the pool for the time of a calculation. A node never connects to any instance, keeps nothing after it answers, and sees only the correlation it is sent.

The numbers do not move. On the iTraxx© Europe Series 46 tranches, valuations and a base correlation run were priced on the instance and on two compute nodes.

Example: Hermetic Valuation Measured on iTraxx© Europe Series 46 Tranches, October 2026

Larger Tensors of Analytics, on the Fly

A risk report is a tensor: securities × scenarios × greeks. On a single server its size is capped by one machine, so analytics are rationed. When every cell can be computed on any node from the same self-contained correlation, the size of the tensor is set by the number of nodes. Tranche runs under twenty scenarios, i-Scenarios that reprice every index constituent one by one, scenario grids intraday instead of at the close: they become questions you can ask on the fly.

The largest of them is Value-at-Risk: thousands of revaluations of the same book, each under a different joint move of the risk factors. In OTCStreaming each draw is simply a scenario on the latent models, and blocks of draws spread over the nodes, so the time of a VaR is set by the number of nodes, not by the number of draws. The objective is a full Monte Carlo VaR of the book in a few minutes; how to build one will be the subject of a coming post.

One Call, Activated on Demand

Clients do not orchestrate anything. A new endpoint of the pipeline API takes the usual request, prepares the self-contained correlation on the client's instance, hands it to the first free node of the pool and returns the result. The service is activated on the client's demand, and there is nothing to install. The two underlying calls stay open for those who want the correlation itself, to keep it as the record of a valuation or to add their own scenarios.

The correlation was always OTCStreaming's way of keeping reference data, market data and models together. Self-contained, it becomes a unit of computation you can scale, a record you can replay and a market you can question, anywhere, with the same answer every time.

Hermetic valuation is activated on demand on private instances. Contact contact@otcstreaming.com to switch it on.