Vector 1
Organizations & Work

The Data Cap Rate: Valuing Corporate and Organizational Data as an Equity Asset

Brian J. Curry
Brian J. Curry
October 14, 2026 · 29 min read

A practical model, with math and runnable Python, for measuring an organization’s data stock, valuing it the way an appraiser values income property, and reporting it as a metric that boards and investors can track.

Every balance sheet has a line for land and buildings. Almost none has a line for data, even at firms whose pricing, underwriting, routing or recommendations run on it. I have argued for years that the gap is in the measurement. Economically, a firm’s data is a component of its equity value in the same way its real estate is: it was built with spending, it wears out, it earns a cash yield, and its value depends on where it sits.

The accounting rules have not caught up, but the rest of the measurement world is moving. The 2025 System of National Accounts, adopted by the UN Statistical Commission in March 2025, treats data as a produced asset, values own-account data at the sum of its production costs, and builds stocks with the perpetual inventory method. Statistics Canada’s experimental estimates put Canadian investment in data, databases and data science at up to C$40 billion in 2018, about 12 percent of non-residential investment. Markets already pay for data when it changes hands. When Reddit filed to go public in 2024, it disclosed data licensing agreements with an aggregate contract value of $203 million.

Earlier in my Returns to Data series, in Data Is Worth Half of AI. It’s Paid Two Percent., I estimated that data accounts for roughly 40 to 51 percent of AI output while its owners are paid about 2 percent. When an input earns far more than it is paid, the difference accrues to whoever controls the input. For corporate data, that is the shareholder. That is the economic reason data shows up in equity value, and the reason it deserves a number.

This piece builds that number. It proposes a cap-rate model that values a data stock the way an appraiser values income property, with replacement cost for the structure and capitalized excess rent for the land. It shows how to measure the stock and its yield, places data in a sum-of-the-parts equity bridge next to real estate, stress-tests the result against agentic AI and data royalties, and ends with a scorecard of metrics a board can track. Two Python scripts do the arithmetic. The model is my own proposal, the firm in the worked example is hypothetical, and I flag where the inputs are hard to measure.

1. Why data sits on the equity bridge next to real estate

An appraiser values an office building three ways. The cost approach asks what it would take to rebuild the structure, less depreciation, plus the value of the land. The sales comparison approach looks at what similar buildings sold for. The income approach divides net operating income by a capitalization rate. The three rarely agree, and the gaps are informative. A building that is worth far more on income than on cost is sitting on valuable land.

Corporate data maps onto each piece of that framework. The structure is the replicable part of a dataset: the cost of collecting, cleaning, labeling, storing and governing it, which anyone with the budget and the access could spend. The land is the part only this firm can have, because the data comes from its own operations, customers, assets or decisions. Net operating income is the cash flow the data produces after charging for the other assets used to exploit it. Maintenance capital spending is the refresh work needed to offset decay. Obsolescence is what happens as the world changes, models change and rivals collect better data of their own.

The analogy strains in four places, and each one matters for the model. First, data is nonrival. As Jones and Tonetti show, many users can exploit the same data at once without using it up, so its private value comes from exclusivity rather than from possession. Second, there is no title registry and only a thin transaction market, so the sales comparison approach is weak for most corporate data. Third, data decays far faster than buildings, with half-lives measured in years rather than decades. Fourth, data’s value is private and depends on complementary assets. In a worked example summarized in Veldkamp’s research digest, the same financial data was worth anywhere from $10 to $1.2 million depending on the investor using it.

One warning before the math. It is tempting to read a firm’s data value off the gap between its market value and its tangible assets. That assumes the answer, because the gap also holds brand, software, organization capital, the knowledge in people and growth options. Birch, Cochrane and Ward found that Big Tech firms’ own disclosures say very little about personal data as an asset and talk instead about users and engagement. The model below builds the value of data from the bottom up and uses the market value gap only as a cross-check.

2. Measuring the stock

The structure value of a data stock is its replacement cost, and the practical way to estimate it is the one national accountants now use: add up what the firm spent producing data each year and accumulate it with depreciation. The 2025 SNA guidance points to a sum-of-costs method for own-account data and the perpetual inventory method for stocks, and it notes that identifying the occupations involved is a key step. For a firm, the cost lines are the labor of the people who collect, engineer, label and govern data, purchased data, labeling vendors, and an allocated share of storage and pipeline infrastructure.

D_t is the data stock at the end of year t, measured at replacement cost. I_t is that year’s data investment on a sum-of-costs basis. δ is the annual rate at which the stock loses economic usefulness, and t_1/2 is the matching half-life.

Take a hypothetical specialty insurer whose data spending has grown 8 percent a year for twelve years to $60 million today, with δ = 0.25. The stock comes to $193.9 million and the half-life is 2.41 years. Holding the stock constant takes δ × D = $48.5 million a year, which is 81 percent of this year’s data budget. Most data spending is maintenance. Like an old building that needs most of its capital budget just to stay leasable, a data estate with a fast decay rate has to run to stand still, and a budget review that treats all of it as growth investment will overstate what the firm is building.

The depreciation rate deserves real work, because it drives both the stock and the cap rate in section 3. Veldkamp’s digest notes that data depreciates at a rate set by Bayes’ law: faster when the process being predicted is volatile, and faster for larger stocks. The practical estimate is a decay backtest. Train the production model on data from one vintage, score it on each later period, and measure how quickly its lift erodes relative to a model retrained on fresh data. As rough illustrations rather than measured values, claims histories for long-tail commercial lines might decay slowly, while clickstream data for a fashion retailer could lose half its value in a season. For comparison, Peters and Taylor depreciate R&D capital at 15 percent and organization capital at 20 percent. Data often sits at or above the top of that range.

The national totals are large. Statistics Canada’s experimental estimates put the Canadian stock of data, databases and data science at up to C$217 billion in 2018, roughly equal to the stock of all other intellectual property products combined.

3. Valuing the stock: the data cap rate

Replacement cost tells you what the data cost. The income approach tells you what it is worth. The proposed model capitalizes the cash flow the data produces at a cap rate that reflects how fast the stock decays.

C is the annual cash flow attributable to the data after contributory asset charges, meaning a fair return on the models, software and people needed to use it. This is the same discipline appraisers use in the multi-period excess earnings method. y is the data yield, cash per dollar of replacement cost. r is the discount rate for data cash flows, and g is the growth rate of cash per unit of data. k is the data cap rate. The formula follows from discounting a cash flow of y × D that shrinks by (1 — δ) and grows by (1 + g) each year, and it is the yield at which the data is worth exactly what it cost. q_D is a Tobin’s q for data. F is the franchise value of future data investment: each dollar invested over a competitive advantage period of T years is worth q_D — 1 above its cost, and nothing once q_D falls to 1 or below, because a firm should stop investing there.

The in-place value splits cleanly. The first term is the structure, worth its replacement cost. The second is the land, the capitalized excess of the data’s yield over its cap rate. Portable data in a competitive market drifts toward q_D = 1, all structure and no land, because anyone can rebuild it at cost. Land comes only from data rivals cannot rebuild.

Back to the insurer. Use r = 10 percent, δ = 0.25 and g = 3 percent. The data cap rate is k = 1.10–0.75 × 1.03 = 0.3275, or 32.75 percent. Suppose the data produces $90 million a year after contributory charges (section 7 shows how hard that number is to pin down). Then y = 90 / 193.9 = 0.464 and q_D = 1.417. The in-place value is $274.8 million: $193.9 million of structure and $80.9 million of land. With a 10-year advantage period and $60 million of annual investment, the franchise value is $177.5 million. The data is worth $452.3 million in total.

Now apply the same formula to the firm’s owned real estate, a headquarters and claims centers producing $30 million of net operating income. With r = 7.5 percent, δ = 1 percent and g = 2 percent, the real estate cap rate is 6.52 percent and the property is worth $460.1 million. The data and the buildings are worth about the same. The difference is the cap rate, which for the data is five times higher. Data is a high-yield, short-duration asset. It throws off a lot of cash per dollar of value, and it stops doing so quickly if the firm stops reinvesting. That profile is part of why data is hard to price from the outside.

4. The land is specificity

If the land is the part of the data rivals cannot rebuild, its value depends on one property: how specific the data is to this firm. A new working paper by Andrea Eisfeldt, Aria Liu and Gregor Schubert, The Great Codification: GenAI and Intangible Capital, makes the same point for intangible capital in general. Its abstract reports that intangible-intensive firms gained value when ChatGPT was released and lost value in early 2026 as agentic AI capabilities were priced in. The authors explain the reversal with a model in which agents let codifiable knowledge move from people into firm-owned software, which creates value when the resulting artifact is firm-specific and destroys it when the artifact is portable. The market payoff to codifiability rises with firm-specificity. Data is the purest case of a codified artifact, so the result applies directly.

Agents threaten data value through two channels, and both hit only the portable share. They make collecting, cleaning and labeling cheaper, which deflates the replacement cost of anything a rival could also assemble. They also make it easier for rivals and vendors to offer the same capability, which competes away the excess yield on portable data. Let φ, between 0 and 1, be the share of the excess yield that is firm-specific, and h the deflation of replacement cost on the portable share.

The first line is the agentic stress test. The normal return k is earned only on the part of the stock that still costs what it used to, and only the specific share of the excess survives. The second line is the royalty stress test from section 5.

For the insurer, set φ = 0.6 and h = 0.5. The data yield falls from 0.464 to 0.344, q_D falls from 1.417 to 1.05, and total data value falls from $452.3 million to $225.1 million, a 50.2 percent drop worth $2.84 a share. The franchise value takes most of the hit, because a q_D barely above 1 leaves little reason to keep investing. Run the same test across φ. At φ = 0, fully portable data, value falls 78.6 percent to $96.9 million. At φ = 0.5, q_D drops to 0.959, the franchise value disappears, and value falls 58.9 percent. At φ = 0.75 the loss is 31.4 percent. At φ = 1 nothing changes.

This leads to an uncomfortable implication for the market approach. If a firm can license its data to many buyers at a good price, the data is portable by definition. Reddit’s licensing contracts, with terms of two to three years, put a price on the structure of a very large public corpus. The land is the part a firm cannot license without giving it away. A licensing market is useful evidence for valuing the structure. Treat it as a warning sign about the land.

In practice, φ is estimated with judgment, and a short set of questions does most of the work. Was the data generated by your own operations, customers or assets, so that no one can buy it? Does it only produce value when joined to your systems, schemas or physical assets? Would a competent outside team need more than a year to rebuild it? Does it improve with use in ways only you observe, because errors and corrections stay inside your workflow? Each yes pushes φ up. A data estate that answers no to all four is mostly structure, and the agentic stress test is its base case.

5. Human data and the unpaid factor

Much of what sits in a corporate data estate was generated by people the firm does not pay for it. Customers generate transaction histories, claims, clicks and support conversations. Employees generate the decisions, overrides and corrections that turn raw records into training labels. The firm pays for the pipelines and the storage, which is the structure. It typically pays nothing for the underlying behavior, which is where much of the land comes from.

That is the firm-level version of the gap I measured in the Returns to Data series. There, data’s share of AI output came out at roughly 40 to 51 percent, against a paid share of about 2 percent, so data owners receive roughly four cents per dollar of value their data creates. Inside a firm, the same wedge shows up as excess yield. When an input is paid less than it produces, the difference becomes a rent, and in a corporation the residual claimant on that rent is the shareholder. The land value in section 3 is, in large part, capitalized unpaid factor income.

That makes it an equity component with a specific risk: the price of the input can change. Licensing deals, copyright litigation, consent requirements and proposals for data dividends all push in the same direction. Jones and Tonetti show that giving consumers property rights over their data can move outcomes closer to the social optimum, which is an economic argument for exactly that shift. The real estate analogy is a ground lease. You still own the building, but you now pay rent on the land.

The royalty stress test in section 4 models this as a share τ of the data’s cash flow paid to data subjects. At τ = 10 percent, the insurer’s data yield falls to 0.418, q_D falls to 1.276, and total data value falls 19.4 percent to $364.6 million, or $1.10 a share. The two parts move very differently. The in-place value falls 10 percent, one for one with the royalty. The franchise value falls 34 percent, because a royalty comes straight out of the excess return that justifies new investment. A firm whose data strategy rests on unpaid human data should expect its growth case, more than its current earnings, to carry the risk.

6. A worked valuation: data in the equity bridge

Put the pieces together for the hypothetical insurer. It has 80 million shares at $40 and $400 million of net debt, so its enterprise value is $3.6 billion. Value each component with its own method and leave the rest as an explicit residual.

Data accounts for 12.6 percent of enterprise value, about $5.65 of the $40 share price, or 14.1 percent of equity value. That is roughly the same as the firm’s real estate, which every analyst covering the stock already models line by line. Data usually gets no line at all. The residual is deliberately labeled as what it is: brand, software, organization capital, distribution and the knowledge held by people. Nothing in the model assigns that residual to data, which keeps the estimate clear of the circular reasoning described in section 1.

The script below reproduces every number in this section and in sections 2 through 5. It needs only the Python standard library.Data as an equity asset: a proposed cap-rate model (mine, not an
accounting standard). Values a firm's data stock the way an appraiser values
income property, then places it in a sum-of-the-parts equity bridge.
All money in $ millions. The firm and every input are hypothetical.

from dataclasses import dataclass, replace
import math

def perpetual_inventory(spend: list[float], delta: float) -> float:
    """Sum-of-costs stock: D_t = (1 - delta) * D_{t-1} + I_t, oldest year first."""
    stock = 0.0
    for investment in spend:
        stock = (1 - delta) * stock + investment
    return stock

def cap_rate(r: float, delta: float, g: float) -> float:
    """k = (1 + r) - (1 - delta)(1 + g): the yield at which an asset that
    decays at delta, with cash per unit growing at g, is worth exactly cost."""
    return (1 + r) - (1 - delta) * (1 + g)

def half_life(delta: float) -> float:
    return math.log(2) / -math.log(1 - delta)

@dataclass(frozen=True)
class DataAsset:
    D: float            # replacement cost of the stock (sum-of-costs, PIM)
    cash: float         # data-attributable cash flow after contributory charges, per year
    I: float            # current annual data investment
    r: float = 0.10     # discount rate for data cash flows
    delta: float = 0.25 # annual economic decay of the stock
    g: float = 0.03     # growth in cash per unit of data
    phi: float = 0.60   # firm-specificity of the excess yield, 0 to 1
    h: float = 0.50     # replacement-cost deflation on the portable share under agents
    tau: float = 0.10   # royalty share of data cash paid to data subjects, if required
    T: int = 10         # competitive advantage period for new data investment, years

    @property
    def y(self) -> float:
        return self.cash / self.D

    @property
    def k(self) -> float:
        return cap_rate(self.r, self.delta, self.g)

    @property
    def q(self) -> float:
        return self.y / self.k

    def in_place(self, y: float | None = None) -> float:
        return (self.y if y is None else y) * self.D / self.k

    def split(self) -> tuple[float, float]:
        """Structure (replacement cost) and land (capitalized excess yield)."""
        land = (self.y - self.k) * self.D / self.k
        return self.D, land

    def franchise(self, q: float | None = None) -> float:
        """NPV of the next T years of data investment, each dollar worth (q - 1)
        above cost; zero once q <= 1 because the firm should stop investing."""
        q = self.q if q is None else q
        a = (1 + self.g) / (1 + self.r)
        annuity = a * (1 - a ** self.T) / (1 - a)
        return max(0.0, (q - 1) * self.I * annuity)

    def agentic_yield(self) -> float:
        """Portable excess yield competed away; portable replacement cost deflates."""
        return self.k * (1 - self.h * (1 - self.phi)) + self.phi * (self.y - self.k)

    def royalty_yield(self) -> float:
        return self.y * (1 - self.tau)

    def total(self, y: float | None = None) -> float:
        """In-place plus franchise value; zero if the data loses money (abandon it)."""
        y = self.y if y is None else y
        return 0.0 if y <= 0 else self.in_place(y) + self.franchise(y / self.k)

if __name__ == "__main__":
    # Twelve years of data spend, growing 8% a year to $60M today (sum of costs:
    # data engineering labor, acquisition, labeling, storage share, governance).
    spend = [60 / 1.08 ** t for t in range(11, -1, -1)]
    delta = 0.25
    D = perpetual_inventory(spend, delta)
    a = DataAsset(D=D, cash=90.0, I=60.0, delta=delta)

    print(f"Data stock D (PIM)        = {a.D:7.1f}")
    print(f"Half-life                 = {half_life(a.delta):7.2f} years")
    print(f"Maintenance spend delta*D = {a.delta * a.D:7.1f}  ({a.delta * a.D / a.I:.0%} of annual spend)")
    print(f"Data yield y              = {a.y:7.3f}")
    print(f"Data cap rate k           = {a.k:7.4f}")
    print(f"Data q = y / k            = {a.q:7.3f}")
    s, land = a.split()
    print(f"In-place value            = {a.in_place():7.1f}  (structure {s:.1f} + land {land:.1f})")
    print(f"Franchise value           = {a.franchise():7.1f}")
    print(f"Total data value          = {a.total():7.1f}")

    # The same formula prices the firm's owned real estate.
    k_re = cap_rate(r=0.075, delta=0.01, g=0.02)
    re_value = 30.0 / k_re
    print(f"\nReal estate cap rate      = {k_re:7.4f}, value of $30M NOI = {re_value:.1f}")

    # Sum-of-the-parts equity bridge
    shares, net_debt, price = 80.0, 400.0, 40.0
    ev = shares * price + net_debt
    tangible = 500.0
    data_total = a.total()
    residual = ev - tangible - re_value - data_total
    print(f"\nEV = {ev:.0f}: tangible {tangible:.0f}, real estate {re_value:.1f}, "
          f"data {data_total:.1f}, other intangibles and goodwill {residual:.1f}")
    print(f"Data share of EV = {data_total / ev:.1%}, data value per share = ${data_total / shares:.2f}")

    # Stress tests
    for label, y_new in (("agentic", a.agentic_yield()), ("royalty", a.royalty_yield())):
        v = a.total(y_new)
        print(f"{label:8s}: y {y_new:.3f}, q {y_new / a.k:.3f}, data value {v:6.1f} "
              f"({v / data_total - 1:+.1%}), per share ${(v - data_total) / shares:+.2f}")

    print("\nphi   q_post  value_post  change")
    for phi in (0.0, 0.25, 0.5, 0.75, 1.0):
        b = replace(a, phi=phi)
        y_new = b.agentic_yield()
        v = b.total(y_new)
        print(f"{phi:4.2f}  {y_new / b.k:6.3f}  {v:10.1f}  {v / data_total - 1:+.1%}")

Two design choices are worth explaining. The franchise value uses a finite competitive advantage period rather than a perpetuity, because data advantages erode as rivals build their own estates, and a perpetuity of excess returns would let a small change in q_D swamp the rest of the valuation. Data value is also floored at zero. A dataset that loses money after contributory charges is something the firm can stop maintaining, so its value cannot go negative, even though the spending already made is gone. Save the script as data_value.py, because the next one imports it.

7. Measuring the yield: holdouts and a valuation range

Every input in section 6 is easier to measure than the $90 million of data cash flow. Spending can be tagged and decay can be backtested, but the yield requires a counterfactual: what the firm would earn without the data. Veldkamp’s digest calls this the revenue approach and notes that it needs a model that computes counterfactuals. The cleanest counterfactual is a holdout. Route a random slice of the business through a process that uses only data any competitor could buy, and compare.

The script below simulates that for the insurer. It writes 100,000 policies in each arm. Treatment policies are underwritten with the full proprietary data, and control policies use bureau and public data only. In the simulation, the true effect of the data is a 5 percent cut in claim frequency, worth $120 per policy, or $90 million a year across a million policies after $30 million of contributory charges. That is the cash flow used in section 6. The data is simulated.

import numpy as np
from data_value import DataAsset, perpetual_inventory

rng = np.random.default_rng(11)

# 1. Holdout: policies randomly routed to underwriting with the full proprietary
#    data (treatment) or with bureau and public data only (control).
N_ARM = 100_000
PREMIUM, EXPENSE = 4_000.0, 1_200.0
FREQ, SEV_MEAN, SEV_SIGMA = 0.08, 30_000.0, 1.0
TRUE_FREQ_CUT = 0.05                     # data cuts claim frequency 5% (truth in the sim)

def simulate(n: int, freq: float) -> tuple[np.ndarray, np.ndarray]:
    mu = np.log(SEV_MEAN) - SEV_SIGMA ** 2 / 2
    hit = rng.binomial(1, freq, n)
    claims = hit * rng.lognormal(mu, SEV_SIGMA, n)
    return hit, PREMIUM - EXPENSE - claims

def estimate(hit_c, m_c, hit_t, m_t) -> tuple[float, float, float]:
    """Naive margin gap, and the frequency gap priced at pooled severity."""
    naive = m_t.mean() - m_c.mean()
    claims = np.concatenate([PREMIUM - EXPENSE - m_c[hit_c == 1],
                             PREMIUM - EXPENSE - m_t[hit_t == 1]])
    sev = claims.mean()
    return naive, (hit_c.mean() - hit_t.mean()) * sev, sev

hit_c, m_c = simulate(N_ARM, FREQ)
hit_t, m_t = simulate(N_ARM, FREQ * (1 - TRUE_FREQ_CUT))
true_uplift = FREQ * TRUE_FREQ_CUT * SEV_MEAN

# The naive estimator lets heavy-tailed claims swamp the signal. The decomposed
# one uses the fact that the data changes which risks are written (frequency);
# it assumes the data does not change severity, which you should test separately.
naive, uplift, sev = estimate(hit_c, m_c, hit_t, m_t)
naive_se = np.sqrt(m_t.var(ddof=1) / N_ARM + m_c.var(ddof=1) / N_ARM)
boot = np.empty(2_000)
for b in range(boot.size):
    boot[b] = (rng.choice(hit_c, N_ARM).mean() - rng.choice(hit_t, N_ARM).mean()) * sev
se = boot.std(ddof=1)
lo, hi = np.percentile(boot, [5, 95])

print(f"True uplift per policy:     {true_uplift:7.1f}")
print(f"Naive margin difference:    {naive:7.1f}  (se {naive_se:.1f})")
print(f"Frequency x severity:       {uplift:7.1f}  (se {se:.1f}, 90% CI [{lo:.1f}, {hi:.1f}])")

# Replication check: rerun the whole holdout 300 times.
reps = np.array([estimate(*simulate(N_ARM, FREQ), *simulate(N_ARM, FREQ * (1 - TRUE_FREQ_CUT)))[:2]
                 for _ in range(300)])
print(f"Across 300 holdouts: naive mean {reps[:, 0].mean():.1f}, sd {reps[:, 0].std():.1f}; "
      f"decomposed mean {reps[:, 1].mean():.1f}, sd {reps[:, 1].std():.1f}")

# 2. From uplift to data cash flow: scale to the book, subtract contributory
#    charges (compute, MLOps, the share of software and staff that run the models).
POLICIES, CONTRIB = 1_000_000, 30.0      # policies per year; $M per year
cash_hat = uplift * POLICIES / 1e6 - CONTRIB
print(f"Data cash flow estimate: ${cash_hat:.1f}M per year")
print(f"Cost of the holdout: ${N_ARM * uplift / 1e6:.1f}M of uplift forgone in the control arm")

# 3. Monte Carlo valuation range over the yield estimate and the assumptions.
DRAWS = 20_000
values, qs = np.empty(DRAWS), np.empty(DRAWS)
for i in range(DRAWS):
    delta = rng.uniform(0.18, 0.35)
    spend = [60 / 1.08 ** t for t in range(11, -1, -1)]
    a = DataAsset(
        D=perpetual_inventory(spend, delta),
        cash=rng.normal(uplift, se) * POLICIES / 1e6 - CONTRIB,
        I=60.0,
        r=rng.uniform(0.08, 0.12),
        delta=delta,
        g=rng.uniform(0.01, 0.05),
    )
    values[i], qs[i] = a.total(), a.q

p10, p50, p90 = np.percentile(values, [10, 50, 90])
print(f"Data value $M: P10 {p10:.0f}, P50 {p50:.0f}, P90 {p90:.0f}")
print(f"Probability data q < 1: {np.mean(qs < 1):.1%}")

The naive estimator, the difference in average margin between the arms, comes back at $6.0 per policy with a standard error of $60.9. Insurance losses are heavy-tailed, and a few large claims swamp a $120 effect. The decomposed estimator uses the structure of the problem. The data changes which risks get written, so the script measures the gap in claim frequency, a 0/1 outcome with far less variance, and prices it at the pooled average severity. It returns $70.7 per policy with a standard error of $37.3 and a 90 percent interval of $10.4 to $131.6. Rerunning the whole holdout 300 times shows that both estimators are centered on the truth, at $120.7 and $119.6, but the decomposed one has a spread of $37.0 against $60.5, about 39 percent tighter.

That particular holdout still came in about 1.3 standard errors low, which happens. Its point estimate implies $40.7 million of data cash flow against a true $90 million. Carry the uncertainty through instead of the point estimate, and the Monte Carlo gives a data value of $0 at the 10th percentile, $120 million at the median and $444 million at the 90th, with a 72.3 percent chance that q_D is below 1. The holdout also has a price. The control arm gave up an estimated $7.1 million of uplift.

Data value can be measured, but one holdout of this size cannot pin it down, and a single number reported to a board would hide that. In practice, pool holdouts across quarters, use variance reduction such as stratification or pre-period covariates, measure on the lowest-variance outcome the data actually moves, and report the yield as a range.

8. The data scorecard

A valuation is useful once. A metric is useful every quarter. These ten measures turn the model into something a board, an audit committee or an investor can track, with the insurer’s values as a reference point.

  1. Data capital stock, D. Sum-of-costs investment accumulated with the perpetual inventory method. Insurer: $193.9 million.
  2. Data intensity. D divided by total capital, meaning physical plus intangible capital plus D. It shows how much of the firm’s capital base is data and whether that share is rising.
  3. Half-life and maintenance ratio. ln 2 / -ln(1 — δ), and δ × D divided by annual data spend. Insurer: 2.41 years and 81 percent. A rising maintenance ratio means the budget is running to stand still.
  4. Data yield, y. Data cash flow after contributory charges divided by D, always reported with its interval. Insurer: 0.464 at the assumed $90 million.
  5. Data cap rate, k. (1 + r) — (1 — δ)(1 + g). Insurer: 32.75 percent, against 6.52 percent for its real estate.
  6. Data q. y / k. Above 1, data investment creates value. Below 1, the firm should stop expanding that dataset. Insurer: 1.417.
  7. Land share. (V_in place — D) / V_in place, the share of in-place value rivals cannot rebuild. Insurer: 29.4 percent.
  8. Data share of enterprise value and data value per share. Insurer: 12.6 percent and $5.65.
  9. Agentic value at risk. The change in data value under the specificity stress test, with φ and h stated. Insurer: -50.2 percent at φ = 0.6 and h = 0.5.
  10. Royalty sensitivity. The change in data value per 10 points of τ. Insurer: -19.4 percent.

The first three need only an accounting system that tags spending by dataset. The next four need the holdout discipline from section 7. The last three need judgment about specificity and regulation, and they are where disclosure would do the most good, because they are where management knows far more than investors.

9. Accounting and disclosure

Under IAS 38, research costs are expensed, and development costs are capitalized only when a firm can show technical feasibility, intent and ability to complete and use the asset, probable future economic benefits, adequate resources and reliable measurement of cost. Internally generated brands, mastheads, publishing titles and customer lists are never recognized. In practice, almost everything the insurer spent building its data estate went through the income statement.

Acquisition accounting works differently. Under IFRS 3, an acquirer recognizes intangibles that are separable or arise from contractual or legal rights, at fair value. Customer lists qualify unless confidentiality terms or law prohibit their sale, while the assembled workforce never does and is subsumed into goodwill (IFRS 3.B37). The same database is invisible when a firm builds it and appears on the balance sheet when a rival buys the firm. The knowledge held by its people lands in goodwill either way, which is a theme for the follow-up to this piece.

The standard is under review. The IASB’s Intangible Assets project began in April 2024 and listed AI and data resources as a possible test case. A July 2026 staff paper on a rights-based model names AI-related data and data resources among the fact patterns to test, and staff expect the Board to decide on IAS 38 improvements in early 2027.

My view is that capitalizing data at cost would help less than it seems. Cost captures the structure and misses the land, which is exactly the part investors cannot see. A voluntary data note would do more. It would report the scorecard from section 8, with the stock, half-life, yield range, q and the two stress tests, under the same governance as other management performance measures. Firms whose data has real land would have every reason to publish it.

10. Where it breaks

The yield is the weakest input. Section 7 showed how wide the range is even with a well-designed holdout of 200,000 policies, and many datasets cannot be held out at all, because the business cannot run a control arm without them or because their effect shows up years later. Contributory asset charges are partly a matter of judgment, since data, models, software and people produce cash jointly and any split among complements is a convention. Different reasonable charges can move the yield a lot.

Double counting is a real risk. Spending on data engineers may already sit in capitalized software, and Peters and Taylor style organization capital is built from SG&A that includes some of the same costs. A firm that adds a data line to an existing intangible capital measure has to remove the overlap first.

Value depends on exclusivity, and exclusivity can change overnight. A breach, a regulatory ruling on data use, a lost data-sharing agreement or a rival’s new source can move φ faster than any annual review. The stress tests are a way to size that exposure, and they do nothing to prevent it.

The discount rate for data cash flows is not observable. I used 10 percent, above the 7.5 percent used for real estate, to reflect shorter duration and less certain cash flows, but there is no market that sets it. The Monte Carlo varies it from 8 to 12 percent, and a reader with a different view should change the range.

The specificity and deflation parameters, φ and h, are judgments supported by a checklist rather than statistical estimates. The paper that motivates them is a new working paper, posted to SSRN in September 2026 and not yet peer reviewed. I could only access its abstract, so I rely on it for the direction of the effect, not for magnitudes.

Finally, the model is mine, the insurer is hypothetical, and every number in the worked example is illustrative. Use the structure, the formulas and the scorecard, and calibrate the inputs to your own business.

11. The path forward

A firm can produce a first version of the data scorecard within a quarter, and most of the work is plumbing.

Start with a data ledger. Tag every dollar of data spending to a named dataset: the labor of the people who collect, engineer, label and govern it, purchased data, vendors, and an allocated share of storage and pipelines. Run the perpetual inventory over the last five to ten years of that spending. This gives you D and the maintenance ratio, and it usually shows that a large share of the data budget is maintenance.

Estimate decay for the three to five datasets that matter most. A decay backtest, training on an old vintage and scoring forward, gives a defensible δ and a half-life the business can understand.

For the same datasets, set up or pool holdouts and measure the yield on the lowest-variance outcome the data actually moves. Report a range. Then compute q_D for each dataset and act on it. Where q_D is clearly below 1, stop expanding the dataset and keep only what the maintenance ratio requires. Where it is clearly above 1, invest, and spend the effort on what raises φ: joining the data to your own operations, closing the feedback loop so corrections stay inside your workflow, and securing the consent and contract terms that protect it from the royalty scenario.

Run the agentic and royalty stress tests once a year, and put the scorecard in front of the board next to the real estate schedule it already reviews. If data really is a component of equity value, it deserves the same discipline.

The residual in section 6, 60.8 percent of the insurer’s enterprise value, includes the knowledge held by its people: experience, tenure, breadth and depth, and the ability to put knowledge to work. That is the subject of my next piece, on valuing the knowledge in people as rigorously as the data they generate.

Sources

About the Author

Brian James Curry is a data science and AI leader, hands-on machine learning practitioner, and published applied researcher. He is the founder of Vector1 Labs, an independent lab working on causal inference, marketing economics, cognitive AI architecture, complex systems, and the economics of intelligent automation.

His career combines sustained business and technical leadership across media, retail, industrial markets, hospitality, and telecom. His responsibilities have spanned marketing, operations, finance, sales, product strategy, and organizational development, including director-level leadership at McClatchy and management roles at AT&T and YP. That commercial foundation informs his approach to building data and AI capabilities around business decisions.

At Koch Ag & Energy Solutions, part of Koch Industries, Brian established the data science and ML practice from scratch. He combined practice leadership with hands-on data engineering, modeling, experimentation, and MLOps, leading large-scale initiatives with CEO-level visibility. He evaluated emerging technologies and vendors, integrated new capabilities into existing systems, and developed proofs of concept, frameworks, and tools with technology and research partners, including AWS.

At Tractor Supply Company, he helped lead the development of AI, ML, experimentation, and advanced analytics capabilities across Azure, Databricks, Snowflake, and open-source technologies. At Vail Resorts, he leads the Advanced Analytics/ML capability and the architecture and implementation of app analytics, aligning teams around use cases while delivering solutions across large-scale datasets. Throughout these roles, he has combined future-state planning and technical direction with direct contributions to development and implementation.

His public open-source and private research portfolio includes Papilon, for causal modeling, marketing measurement, and complex-system simulation; PyCausalSim, for simulation-driven causal discovery and counterfactual analysis; OMNI Intelligence, for multi-model AI evaluation; and Memory-Node Encapsulation, for artificial episodic memory. Additional work explores semantic geometry, forecasting, emerging-signal detection, and the economic effects of intelligent automation.

In 2016, Brian founded KC AI Lab, originally the Kansas City Machine Learning Group. The community grew to more than 1,500 practitioners, supporting education, collaboration, and exploration of emerging AI technologies.

He holds a BS in Economics from Kansas State University, where he was a collegiate athlete. He is a musician, composer, and painter, has trained in Brazilian Jiu Jitsu, and is the father of two. He lives in Kansas City.

Vector1 Labs: https://vector1.ai
Substack: https://brianjamescurry.substack.com
Medium: https://medium.com/@brian-curry-research
GitHub: https://github.com/Bodhi8
LinkedIn: https://linkedin.com/in/brian-curry-research

Related research