Vector 1
AI Strategy & EconomicsEnergy & Grid

The Future of AI in Kansas City: Gigawatts, Models and the Math of Who Gets Paid

Brian J. Curry
Brian J. Curry
October 23, 2026 · 26 min read

Kansas City’s main utility has signed 2.5 gigawatts of data center load. Here is the power, model, adoption and labor math that decides whether the metro captures the value of AI or only hosts the hardware, with runnable Python for every model.

In February 2026 Google confirmed Project Mica, a data center campus on roughly 500 acres in the Northland, financed with up to $10 billion in Port KC revenue bonds. Six months later Evergy told investors it had signed energy service agreements with five data center projects totaling about 2.5 GW of steady-state peak load. Lambda is filling a 2009-built data center in Kansas City, Missouri with more than 10,000 NVIDIA Blackwell Ultra GPUs. Patmos turned the old Kansas City Star printing plant downtown into AI colocation.

Kansas City has become one of the places where the AI economy physically sits. That is a different thing from Kansas City capturing the value of AI. A data center is one of the most capital-intensive buildings an economy can put up, and it employs very few people once it is running. The metro has about 1.18 million jobs. Most of the money AI will make or move here comes from what those workers and their employers do with models, not from the racks humming next to I-435.

I have spent years in this community, first by founding the Kansas City Augmented Intelligence Lab and now through econometrics and causal modeling work at Vector1 Research. This is the quantitative version of the argument I make at meetups. You get one framing model, four Python models you can run in a notebook (a large-load tariff stress test, a self-hosted inference cost model, an adoption diffusion model and a regional productivity model), the math behind each, and an honest list of where the math breaks. Public figures are sourced at the end. Every assumption is labeled as one.

The framing model: host value versus use value

A metro gets paid by AI through two channels. The host channel is what a region earns from housing compute: permanent payroll, property tax actually collected after abatements, and the contribution large loads make to a utility’s fixed costs. The use channel is what a region earns from applying models: productivity gains spread across its whole wage bill. I propose a simple accounting identity to keep them separate.

V = H + U

H = J × w + τ × K

U(t) = E × w̄ × [ (1 + g × a₁)(1 + g × a₂) ··· (1 + g × aₜ) − 1 ]

In the host term, J is permanent jobs on site, w is their average wage, K is the capital invested and τ is the effective property tax rate after abatements. In the use term, E is metro employment, w̄ is the average wage, g is the annual productivity growth AI delivers to a firm that has adopted it, and aₜ is the share of the economy that has adopted by year t. The product compounds, because a productivity gain in year one is still there in year two.

The use term borrows its logic from Hulten’s theorem: the aggregate gain from a technology is roughly the share of the economy it touches times the gain where it touches. Anthropic used that approach in November 2025 to estimate that current models could add about 1.8% a year to U.S. labor productivity over a decade under universal adoption. The authors are explicit that this is a scenario, not a forecast. I use it as g and let adoption do the scaling.

Here is the worked example, with the assumptions labeled. Meta’s Kansas City data center represents more than $1 billion of investment and supports more than 100 jobs at full operation, so I use 100 permanent jobs per billion dollars. For a $10 billion campus at a $90,000 average wage (assumption) and a 0.2% effective tax rate after abatement (assumption), H = 1,000 × $90,000 + 0.002 × $10 billion = $110 million a year.

For the use channel, the Kansas City MSA had 1,175,300 nonfarm jobs in September 2026 (preliminary). At a $65,000 average wage (assumption), the wage bill is $76.4 billion. At Missouri’s 17.5% business AI adoption rate, one year of the 1.8% gain is worth $241 million. That single year already beats the host channel of a $10 billion campus. Let adoption diffuse for five years, which I model below, and the use channel reaches $3.24 billion a year.

The ratio is the argument of this piece. Hosting is worth having, for reasons I will quantify. But a Kansas City AI strategy that is mostly a data center strategy is optimizing the smaller term.

The power layer: 2.5 GW and who carries the risk

The first constraint on AI in Kansas City is electricity, and the numbers moved fast in 2026. On its second-quarter call in August, Evergy reported five data center projects with signed agreements under its large-load power service tariffs, totaling about 2.5 GW of steady-state peak load. Add about 500 MW from other large customers, including the Panasonic battery plant in De Soto, and large-customer load reaches about 3 GW. Evergy says the signed projects support 7% to 8% annual retail load growth through 2030, and it reports a remaining pipeline of more than 10 GW.

To serve that, Evergy’s 2026 integrated resource plan adds more than 5 GW through 2032: about 3.9 GW of natural gas, nearly 800 MW of solar and 450 MW of batteries. It also added about $1 billion of generation capex tied directly to the signed customers. Utilities earn a return on what they build, so the economic question for every other ratepayer in the metro is simple: if a data center leaves, who pays for the plant built to serve it?

Regulators on both sides of State Line answered with tariff design. The Kansas Corporation Commission approved Evergy’s large-load settlement on November 6, 2025. It covers new facilities over 75 MW, allows a ramp of up to five years, requires at least 12 years of service after that, and sets a minimum monthly bill at 80% of contract demand whether or not the customer uses it. Missouri’s Public Service Commission approved a parallel Evergy tariff in November 2025 with the same 12-year commitment, the optional five-year ramp, the 80% demand floor, collateral equal to two years of minimum bills, and exit fees for customers who leave.

That floor is the mechanism that protects households, and it is easy to stress test. New capacity carries an annual revenue requirement of return plus depreciation:

CC = K × (r + 1/L)

d* = CC / (m × D × 12)

K is capital, r is the utility’s cost of capital, L is the asset life in years, m is the minimum-bill share, D is contract demand in kW, and d* is the demand charge per kW-month at which the guaranteed floor alone covers the carrying cost. With K = $1 billion, r = 7.5% and L = 30 (both assumptions), CC = $108.3 million a year. Evergy reports about 1.7 GW under agreements with minimum monthly billing, so with m = 0.8, d* = $108.3M / (0.8 × 1,700,000 kW × 12) = $6.64 per kW-month.

Staying customers are covered once the floor clears d*. The harder case is a customer that exits. Suppose the effective exit protection is X years of minimum bills (I use two, the size of Missouri’s collateral requirement), and stranded capacity takes R years to be absorbed by other load growth. Everyone else is made whole when X × F ≥ R × CC, where F is the annual floor. That gives a clean rule:

d ≥ (R / X) × d*

With R = 3 and X = 2, the demand floor needs to be about 1.5 × $6.64 = $9.96 per kW-month. Below that, an early exit leaves a hole in the rate base. The Monte Carlo below puts a 3% annual exit hazard on each project (an assumption) and measures what lands on other customers.

"""Minimum-bill coverage for large-load tariffs (proposed model, vendor-neutral)."""
import numpy as np

def carrying_cost(capex, wacc=0.075, life_years=30):
    """Annual revenue requirement for new capacity: return on capital plus straight-line depreciation."""
    return capex * (wacc + 1.0 / life_years)

def breakeven_demand_charge(annual_cost, contract_kw, min_bill_share=0.80):
    """$/kW-month the minimum bill must carry so the guaranteed floor covers annual_cost."""
    return annual_cost / (min_bill_share * contract_kw * 12)

def stranded_cost_sim(capex, contract_kw, demand_charge, years=17, n=100_000,
                      p_exit=0.03, min_bill_share=0.80, exit_fee_years=2,
                      reabsorb_years=3, seed=7):
    """Monte Carlo of carrying cost left with other customers when a large load exits early.

    Each year the customer leaves with probability p_exit. While it stays, the minimum bill
    guarantees at least `floor` per year. If it leaves, it pays `exit_fee_years` of minimum
    bills, and the idle capacity takes `reabsorb_years` to be absorbed by other load growth.
    The shortfall is the carrying cost of that idle period not covered by the exit fee.
    """
    rng = np.random.default_rng(seed)
    cc = carrying_cost(capex)
    floor = min_bill_share * contract_kw * demand_charge * 12
    exit_year = rng.geometric(p_exit, size=n)           # year of exit, 1-indexed
    left_early = exit_year <= years
    remaining = np.clip(years - exit_year + 1, 0, None)  # contract years left at exit
    idle_years = np.minimum(reabsorb_years, remaining)
    shortfall = left_early * np.clip(idle_years * cc - exit_fee_years * floor, 0, None)
    # in-contract years are covered whenever the floor clears the carrying cost
    under_recovery = max(cc - floor, 0.0) * np.minimum(exit_year - 1, years)
    total = shortfall + under_recovery
    return total.mean(), np.percentile(total, 95), left_early.mean()

if __name__ == "__main__":
    capex = 1.0e9          # Evergy's added generation capex tied to signed customers
    contract_kw = 1.7e6    # 1.7 GW under agreements with minimum monthly billing
    cc = carrying_cost(capex)
    d_star = breakeven_demand_charge(cc, contract_kw)
    print(f"annual carrying cost: ${cc/1e6:,.1f}M")
    print(f"break-even demand charge: ${d_star:,.2f}/kW-month")
    for d in (d_star, 10.0):
        mean, p95, share = stranded_cost_sim(capex, contract_kw, d)
        print(f"d=${d:,.2f}: mean shortfall ${mean/1e6:,.1f}M, p95 ${p95/1e6:,.1f}M, "
              f"share exiting early {share:.1%}")

Output:

annual carrying cost: $108.3M
break-even demand charge: $6.64/kW-month
d=$6.64: mean shortfall $39.6M, p95 $108.3M, share exiting early 40.3%
d=$10.00: mean shortfall $0.0M, p95 $0.0M, share exiting early 40.3%

Two things stand out. A 3% annual hazard sounds small, but over a 17-year contract it means a 40.3% chance the customer leaves early, which is why the exit terms matter as much as the headline 80%. And the difference between a floor at break-even and a floor at $10 is the difference between a $39.6 million expected bill for other customers and none. The geometric draw is used because each year’s exit decision is modeled as independent; if you believe exits cluster in a downturn, replace it with a correlated draw across projects and the tail gets fatter.

The early evidence points the right way. In Evergy’s Missouri Metro rate case, data center revenue cut the initial revenue requirement by $25 million, about 15%. That is the host channel working as intended: big loads spreading fixed costs across more kilowatt-hours. The tariff is the reason that can stay true if the AI buildout cools.

The host channel: $10 million per permanent job

The capital intensity of a hyperscale data center is the single most useful number for a Kansas City voter or council member to carry around. Meta’s Kansas City data center, now operational, represents more than $1 billion in Missouri and supports more than 100 jobs at full operation, after about 1,500 skilled trade workers at construction peak. That is about $10 million of capital per permanent job.

K / J = $1,000,000,000 / 100 = $10,000,000 per permanent job

Construction is the big local payroll, and it is temporary. Google says its data center projects typically support about 1,200 construction jobs at peak; Project Mica’s first phase is expected to take about 18 months of a five-building build-out. Google also committed $1.75 million upfront for workforce programs, $1.5 million to the Smithville School District and $250,000 to the Northland Career Center. Spread over Mica’s planned 500 MW at full capacity, that is $3,500 per megawatt, a useful benchmark for what the next campus should be asked for.

The property tax line is where the incentives fight is. Project Kestrel, a reported $100 billion campus of six data centers on 379 acres in the KCI-29 industrial area, received a 35-year tax abatement from Port KC, and Platte County’s presiding commissioner publicly opposed it, citing how little information was disclosed. On the Kansas side, SB 98 created a 20-year sales tax exemption for data centers that invest at least $250 million by their fifth year and create at least 20 jobs, effective July 1, 2025. Each of these lowers τ in the host equation. The trade can still be worth it, but only if the use channel is part of the deal.

Water is the physical constraint people underestimate. KC Water’s Briarcliff plant can treat 240 million gallons a day and currently produces about 100 to 120 million. Meta’s site alone is expected to use 9.5 million gallons a day once fully complete. That is about 4% of Briarcliff’s capacity, but 7.9% to 9.5% of what the city actually produces today. The city has floated a second treatment plant at $600 million to $2 billion; KC Water says it is not driven by data center demand and that it will seek grants rather than use customer rates to build it.

Kansas City also changed the rules of the game. On January 15, 2026, the City Council unanimously gave data centers their own zoning categories. Facilities under 500,000 square feet now need a special use permit, larger “large format uses” face district limits, and every project must bring a letter from water and energy providers confirming they can meet its demand. That is good policy because it turns capacity into a visible, negotiable term instead of an assumption.

None of this makes hosting bad. The $25 million rate case reduction is real money for households, the tax base is real when it is collected, and local GPU capacity matters for the model layer below. The point is narrower: at $10 million per job, a data center is an infrastructure asset and a fiscal asset. It is not a jobs program.

The model layer: what Kansas City companies will actually run

Kansas City’s employer base is unusually heavy in regulated data. Oracle Health runs the former Cerner campus in North Kansas City. Children’s Mercy runs one of the country’s larger pediatric genomics programs. H&R Block, UMB, Commerce Bank and the Federal Reserve Bank of Kansas City hold tax and financial records. Garmin, Burns & McDonnell and Black & Veatch hold engineering IP. For these firms the model question is not only which model is smartest. It is where the model runs, who sees the data, and what each answer costs.

That makes local GPU capacity strategically interesting. Lambda’s Kansas City site starts at 24 MW with room to scale past 100 MW. Patmos offers colocation in 2.5 MW increments at power densities above 100 kW per rack. A Kansas City hospital or insurer can now put open-weight models on hardware a few miles from its own data center. Whether it should is an arithmetic problem.

The cost of a self-hosted model per million output tokens is:

c = h × n × (1 + o) / (3600 × T × u) × 1,000,000

u* = h × n × (1 + o) / (3600 × T × P / 1,000,000)

h is the cost per GPU-hour, n is GPUs per model replica, o is operating overhead as a share of GPU spend (engineering, monitoring, storage, networking), T is aggregate output tokens per second for the replica at full batch, u is utilization, P is the API price per million tokens you are comparing against, and u* is the utilization at which self-hosting breaks even.

Mid-2026 neocloud on-demand pricing for B200s ran about $3.99 to $5.50 per GPU-hour, so take h = $4.50 and an 8-GPU replica. Assume T = 12,000 tokens per second for a mid-size open-weight model with heavy batching, o = 25%, and u = 35% (all three are assumptions you should replace with your own measurements). Then c = $4.50 × 8 × 1.25 / (3600 × 12,000 × 0.35) × 1⁰⁶ = $2.98 per million tokens. Against an illustrative $2.00 API price, break-even utilization is 52.1%.

"""Self-hosted inference cost per million tokens versus an API price (vendor-neutral)."""
from dataclasses import dataclass

@dataclass
class Deployment:
    gpu_hour_usd: float        # rented or amortized cost per GPU-hour
    gpus: int                  # GPUs serving one model replica
    tokens_per_sec: float      # aggregate output tokens/s for the replica at full batch
    utilization: float         # share of hours the replica is doing useful work
    ops_overhead: float = 0.25 # engineering, monitoring, storage, networking as share of GPU spend

    def cost_per_million(self) -> float:
        hourly = self.gpu_hour_usd * self.gpus * (1 + self.ops_overhead)
        useful_tokens = self.tokens_per_sec * 3600 * self.utilization
        return hourly / useful_tokens * 1e6

    def breakeven_utilization(self, api_price_per_million: float) -> float:
        hourly = self.gpu_hour_usd * self.gpus * (1 + self.ops_overhead)
        return hourly / (self.tokens_per_sec * 3600 * api_price_per_million / 1e6)

if __name__ == "__main__":
    d = Deployment(gpu_hour_usd=4.50, gpus=8, tokens_per_sec=12_000, utilization=0.35)
    api = 2.00  # illustrative blended API price per million tokens for a comparable model
    print(f"self-hosted cost: ${d.cost_per_million():.2f} per million tokens at {d.utilization:.0%} utilization")
    print(f"break-even utilization vs ${api:.2f} API: {d.breakeven_utilization(api):.1%}")
    for u in (0.10, 0.35, 0.70):
        d.utilization = u
        print(f"  utilization {u:.0%}: ${d.cost_per_million():.2f}/M")

Output:

self-hosted cost: $2.98 per million tokens at 35% utilization
break-even utilization vs $2.00 API: 52.1%
  utilization 10%: $10.42/M
  utilization 35%: $2.98/M
  utilization 70%: $1.49/M

Utilization dominates everything else in this model. A replica that sits idle overnight and on weekends, which is what a single department’s assistant does, costs $10.42 per million tokens at 10% utilization, five times the API. The same hardware at 70% costs $1.49. The overhead term is deliberately explicit because it is the one finance teams forget: the people who keep a GPU cluster patched, monitored and evaluated cost real money.

This points to a regional idea I think Kansas City should take seriously. Single firms rarely keep GPUs busy, but a pool of hospitals, insurers and banks with complementary load curves could. Tax season peaks for one employer, open enrollment for another, overnight batch genomics for a third. A shared, compliance-reviewed inference pool on local hardware would push u toward the range where self-hosting wins, and it would turn the host channel’s GPUs into an input for the use channel. That is a proposal, not a plan anyone has announced. GPU prices also move quickly: H100 rental rates rose about 40% from October 2025 into early 2026, so rerun the numbers before you sign anything.

The adoption layer: Kansas trails, and community is the lever

The best public measure of business AI use is the Census Bureau’s Business Trends and Outlook Survey. Averaged over six releases from January 15 to March 26, 2026, 17.5% of Missouri businesses and 15.0% of Kansas businesses reported using AI, against 18.2% nationally. Colorado led at 23.2%; West Virginia trailed at 10.8%. By the May 3, 2026 collection period the national rate was 19.8%, with information firms at 39.7% and finance and insurance at 33.9%. Firms with 250 or more employees reported 37%, while firms under 20 employees showed no significant change between December 2025 and May 2026.

One caution on those numbers. The survey broadened its AI question in late 2025, from use in producing goods and services to use in any business function. The Minneapolis Fed notes that adoption roughly doubled to 20% on the broader question, so the jump is partly a definition change. Compare states within the same question window, as above, and treat long time series with care.

Diffusion has a classic model. The Bass model splits adoption into innovators, who adopt on their own at rate p, and imitators, who adopt because peers already have, at a rate proportional to q times the share already using it:

dA/dt = (p + q × A) × (1 − A)

A is the share of firms that have adopted. The (1 − A) term is the pool still left to convert. I have not fitted p and q to Kansas City data, because the question change makes a clean fit impossible today. I use p = 0.02 and q = 0.40 as illustrative values in the range the diffusion literature usually reports, and start each state at its BTOS rate.

"""Bass diffusion of AI adoption among Kansas City firms (illustrative parameters)."""
import numpy as np

def bass_path(a0, p, q, years, steps_per_year=12):
    """Discrete Bass model: dA/dt = (p + q*A) * (1 - A), starting from adoption share a0."""
    dt = 1.0 / steps_per_year
    a = [a0]
    for _ in range(int(years * steps_per_year)):
        A = a[-1]
        a.append(A + (p + q * A) * (1 - A) * dt)
    return np.array(a)

def years_to(path, target, steps_per_year=12):
    idx = np.argmax(path >= target)
    return idx / steps_per_year if path[idx] >= target else float("nan")

if __name__ == "__main__":
    p, q = 0.02, 0.40                        # innovation and imitation coefficients (assumed)
    for name, a0 in (("Kansas", 0.150), ("Missouri", 0.175), ("U.S.", 0.182)):
        path = bass_path(a0, p, q, years=10)
        print(f"{name:8s} start {a0:.1%}: 50% in {years_to(path, 0.5):.1f} yrs, "
              f"share in 3 yrs {path[36]:.1%}")
    # A one-year head start compounds: what does raising q from 0.40 to 0.55 buy Kansas?
    fast = bass_path(0.150, p, 0.55, years=10)
    print(f"Kansas with q=0.55: 50% in {years_to(fast, 0.5):.1f} yrs, share in 3 yrs {fast[36]:.1%}")

Output:

Kansas   start 15.0%: 50% in 3.8 yrs, share in 3 yrs 42.4%
Missouri start 17.5%: 50% in 3.4 yrs, share in 3 yrs 46.3%
U.S.     start 18.2%: 50% in 3.2 yrs, share in 3 yrs 47.3%
Kansas with q=0.55: 50% in 2.8 yrs, share in 3 yrs 52.8%

The monthly Euler step is accurate enough here because the dynamics are slow relative to a month; a daily step moves the years-to-50% figures by about a tenth of a year at most and the three-year shares by less than half a point. The result worth noticing is the last line. Kansas’s 3.2-point gap to the national rate costs it about 0.6 years to reach majority adoption. Raising q from 0.40 to 0.55 does more than close the gap: Kansas reaches 50% in 2.8 years, ahead of the national baseline.

q is the imitation coefficient, and imitation is a social process. It moves when a controller at a Lenexa manufacturer watches a peer automate month-end close, or when a clinic manager in Liberty sees a working prior-authorization assistant at a meetup. That is the economic case for the Kansas City AI Club, the Kansas City Augmented Intelligence Lab, university programs at UMKC, KU and K-State, and every founder who demos honestly. Community is not a soft input in this model. It is the parameter with the largest payoff.

There is also a structural headwind. Anthropic’s geographic analysis found that across U.S. states, 1% higher GDP per capita is associated with 1.8% higher per-capita Claude usage, and usage is converging slowly: the top five states’ share of per-person usage fell from 30% to 24% between August 2025 and February 2026, which Anthropic projects would reach rough parity in five to nine years. Kansas City is not a coastal income outlier, so it will not get adoption for free. It has to raise q on purpose.

The labor layer: the competitor is an AI-equipped back office somewhere else

The common story about AI and jobs is replacement. The evidence so far points somewhere more specific, and for Kansas City more important. The Minneapolis Fed reports that about 96% of U.S. firms using AI saw no change in headcount over the prior six months, and only 10% said AI now performs tasks employees used to do. The New York Fed’s regional survey found 61% of service firms using AI in 2026, but only 4% had laid off workers because of it.

The Kansas City Fed’s own Beige Book from May 2026 names the real local risk. Contacts in the Tenth District said faster AI adoption among offshore providers had made those providers more competitive with some domestic operations, naming accounting, medical transcription and database management. Firms cited labor availability and labor costs as reasons for moving back-office and professional work overseas.

That matters here because Kansas City is a back-office and professional services metro. In May 2025 the MSA had 180,800 jobs in professional and business services, 79,700 in financial activities and 16,100 in information: 276,600 jobs in the sectors where national AI use is highest. The math of the threat is a cost ratio. If a domestic team pays wage w_d and an offshore team pays w_o for the same task taking t hours, and only the offshore team adopts AI with time savings s, the domestic cost disadvantage becomes:

cost ratio = (w_d × t) / (w_o × t × (1 − s)) = (w_d / w_o) × 1 / (1 − s)

At s = 0.30, a conservative assumption well below the roughly 80% median time savings Anthropic measured inside Claude conversations, the existing wage gap widens by a factor of 1 / 0.7 = 1.43. A Kansas City accounting team that does not adopt ends up competing against the offshore price divided by 0.7. When the domestic team adopts too, the factor cancels and the contest returns to quality, trust, time zones and domain knowledge, which is where Kansas City firms win.

That is the labor case for the use channel, and it is the code behind the framing model:

"""Host value versus use value for a metro AI economy (proposed model)."""
from adoption import bass_path

def host_value(capex, jobs_per_billion, wage, effective_tax_rate):
    """Annual local value from hosting compute: permanent payroll plus property tax paid."""
    payroll = capex / 1e9 * jobs_per_billion * wage
    return payroll + capex * effective_tax_rate

def use_value_path(employment, avg_wage, adoption_by_year, gain=0.018):
    """Wage-bill-equivalent level gain by year. Each year the adopted share of the
    economy grows productivity by `gain`, and gains compound."""
    level, out = 1.0, []
    for a in adoption_by_year:
        level *= 1 + gain * a
        out.append(employment * avg_wage * (level - 1))
    return out

if __name__ == "__main__":
    H = host_value(capex=10e9, jobs_per_billion=100, wage=90_000, effective_tax_rate=0.002)
    print(f"host value of a $10B campus: ${H/1e6:,.0f}M per year")

    path = bass_path(a0=0.175, p=0.02, q=0.40, years=5)
    adoption = [path[12 * t] for t in range(1, 6)]
    for t, (a, g) in enumerate(zip(adoption, use_value_path(1_175_300, 65_000, adoption)), 1):
        print(f"year {t}: adoption {a:.1%}, use value ${g/1e9:,.2f}B per year")

Output:

host value of a $10B campus: $110M per year
year 1: adoption 25.7%, use value $0.35B per year
year 2: adoption 35.5%, use value $0.84B per year
year 3: adoption 46.3%, use value $1.49B per year
year 4: adoption 57.2%, use value $2.29B per year
year 5: adoption 67.4%, use value $3.24B per year

Save the Bass code from the previous section as adoption.py in the same folder and this runs as written. The use value is a level: by year five the metro’s output is $3.24 billion a year higher than it would have been, measured in wage-bill terms. That is roughly 29 times the host value of a $10 billion campus, and the gap is driven almost entirely by adoption speed. Drop q and the curve flattens; raise it and the curve steepens.

Who receives that $3.24 billion is a separate question the model does not answer. Productivity gains can show up as higher wages, higher profits, lower prices or fewer hours. The regional data so far is encouraging but thin: a BEA working paper published in August 2026 found that state industries with more worker-reported AI use had stronger real-output paths after 2020, with positive but imprecise employment effects, and the authors call the results descriptive rather than causal.

Where the models break

The 1.8% productivity figure is the softest number in this piece. It assumes universal adoption of current models, it rests on Claude’s own estimates of task time that have not been validated against real outcomes, and it counts time spent inside the chat window but not the time spent checking and fixing outputs afterward. Randomized trials have often found smaller savings, and at least one found none for end-to-end software features. If the true g is half as large, every use-value figure here halves. The ratio to the host channel still favors use, but by about 15 times instead of 29.

Firm adoption is not task adoption. A business that answers yes on the Census survey may use AI for one marketing email a week. Scaling the 1.8% gain by the share of firms using AI treats a yes as full use, which overstates the gain early and may understate it later as usage deepens inside firms that already said yes. The state estimates also carry sampling error, and the question change in late 2025 means no one can yet fit Bass parameters cleanly. My p and q are illustrative.

The host value is conservative by construction. It ignores construction payroll, local purchasing, the utility rate effects quantified in the power section, and induced spending. A full input-output analysis would raise H, possibly by a lot during build-out years. It would not change the order of magnitude of the permanent gap.

The tariff model assumes independent exits at a constant 3% hazard and a three-year reabsorption lag. Reabsorption depends on that more than 10 GW pipeline turning into real load, and pipelines evaporate in downturns, exactly when exits cluster. Tariff exit fees and collateral terms also differ in detail from my two-years-of-floor simplification, so read the filed tariffs before quoting a coverage ratio.

The inference model depends heavily on T, which varies by model size, context length, batch size and serving stack by a factor of several. Measure it on your own workload. GPU prices moved about 40% in a few months last winter.

Finally, the costs that do not fit in these equations still count. Evergy’s resource plan builds about 3.9 GW of new gas generation, which has carbon and fuel-price consequences for every customer. Water, noise, land use and the 35-year abatement horizon are long-dated commitments made on today’s information. Those are values questions as much as math questions, and the people of Clay and Platte counties are right to ask them.

The path forward for Kansas City

The future of AI in Kansas City will be decided less by how many gigawatts we sign and more by how fast 1.18 million workers and their employers learn to use what those gigawatts produce. The four models point to work that can start this quarter.

If you run a Kansas City business, measure adoption at the task level, not the license level. Pick three workflows in finance, operations or customer service, ideally the back-office work the Beige Book says offshore competitors are already automating, and time them before and after. The cost ratio above tells you what standing still costs: a 1.43 times wider gap against anyone who adopts first.

If you are an engineer or data leader, run the inference cost model on your own traffic before you choose between an API and self-hosting. Log real utilization for a month. If it sits below the break-even line, use the API and spend the savings on evaluation. If you work in health care, insurance or banking and your data cannot leave, talk to peers about pooling load, because pooled utilization is what makes local GPUs pay.

If you sit on a council, a port authority or a utility commission, tie incentives to the use channel. Ask each campus for workforce money at least at the $3,500 per megawatt benchmark Mica set, for compute credits that local universities and startups can actually spend, and for public reporting of water and power use against the capacity letters the new zoning code requires. Check that every large-load demand floor clears the R / X × d* rule, so a departure never lands on household bills.

If you are part of the Kansas City AI community, you are the q in the diffusion model. Share working case studies with numbers in them, including the failures. Bring a controller or a clinic manager to a meetup instead of another engineer. Every honest demo moves the imitation coefficient, and the model says that coefficient is worth a year of adoption.

Kansas City already won the argument about whether AI infrastructure can live in the middle of the country. The next argument is whether the middle of the country can be where AI gets used best. That is the one worth winning, and it is mostly up to us.

I write about applied AI, econometrics and the Kansas City tech economy at Vector1 Research. If you run any of these models on your own data, I would like to see what you find.

About the Author

Brian James Curry is a Kansas City AI researcher, applied scientist and data scientist working in machine learning, causal inference and healthcare intelligence. He is the founder of Vector1 Labs, an independent applied AI research lab, where his Causal Care series applies causal machine learning to health system decisions: which programs work, for whom, and what they are worth. He also founded KC AI Lab, which began in 2016 as the Kansas City Machine Learning Group and has grown to more than 1,500 members.

He has more than twenty years of experience leading analytics, data science and machine learning at Hallmark, Garmin, Koch Industries, Tractor Supply Company and Vail Resorts. His open-source research tools on GitHub include PyCausalSim (causal discovery through simulation), Papilon (marketing mix modeling and complex systems) and tincast (forecasting for AI-critical commodities), along with MeaningFlow and Daedalus. A Kansas State University alum from a small Kansas farming town, he writes about agentic AI, causal inference, healthcare AI and the economics of AI on Medium and Substack. Contact: brian@vector1.ai.

Sources

Related research