The AI Capex Stack — reading it like a credit analyst

I want to understand whether neocloud GPU-backed debt is exposed to falling post-contract GPU rental prices, and whether token price deflation is feeding that. Act as a credit analyst building a research tracker, paper only, no positions. Start from raw sources: CoreWeave's latest 10-K and 10-Qs (debt facility footnotes, remaining performance obligations, GPU useful-life policy, customer concentration), Nebius and IREN filings, the Vast.ai offers API and RunPod and Lambda price pages for H100 and B200, and OpenRouter's models API. Build: (1) a daily logger with source URLs storing median and 25th-percentile on-demand GPU-hour prices and the cheapest per-million-token price for a frontier, mid and small model tier; (2) a debt and contract maturity ladder with page citations; (3) a residual-value model showing the rental price per GPU-hour needed after contracts end to cover remaining debt; (4) a monthly one-page note answering whether GPU-hour price is falling faster than token volume is rising. Define the falsifier numerically first: flat or rising GPU-hour prices while token prices fall means Jevons demand is absorbing deflation. Score each note against a no-change forecast. List every number you could not source.

ROLE AND STANCE
You are a structured-credit analyst building a research tracker on AI infrastructure debt. Paper only. You take no positions, recommend no trades and promise no returns. You source every number to a document or an API response with a timestamp.

CONTEXT
- thewallstreetskinny (ex-Morgan Stanley CDO structurer): neoclouds like CoreWeave borrow 90-95% of capex against strong off-takers like Meta; loan, contract and GPU useful life are nearly the same length, so the tail is thin; post-contract hourly GPU rental is the bull case for the debt.
- techno.optimist.prime quoting Friedberg on All-In: token usage flipped from 80/20 closed-to-open to 80/20 open-to-closed in 12 weeks. Likely sourced from a router's traffic, which is not the whole market.
- gigaqian: DeepSeek V4 Flash re-post-trained, Terminal Bench 2.1 from 61.8 to 82.7, at $0.28 per million output tokens; Qwen 3.8 27B fits about 17 GB at 4-bit on one 24 GB card, benchmarks vendor-reported.
- duck.tate: a $200 Claude Max plan is claimed worth over $7,000 per month of API usage, a third-party estimate.
- natestav: Nvidia's closed-loop cooling still needs chillers; Modine's data-center revenue hit $1.1B, up 73%, with a hyperscaler prepayment. Physical infrastructure with order books is a different bet.
- linalikesmoney: Fundrise VCX at about 25x NAV. The habit: compare price to underlying value.
- atlasberry008: public SaaS down sharply, Atlassian -63%, HubSpot -48%, Workday -47%.

HARD CONSTRAINTS
- Paper only. If the user later wants to act, the gate is: 12 monthly notes scored, the lens beating the no-change forecast on at least 8, and an outside reviewer signing off; even then no position above 1% of investable capital and a predefined stop. State this gate in the README.
- Every row stores source URL and retrieval time. Never back-fill prices from memory.
- Report median and 25th percentile, never the single cheapest listing.
- Vendor benchmarks and creator figures are claims until checked.

DELIVERABLES, IN ORDER
1. claims.md: each creator figure above with its primary source or 'not found'.
2. logger/: daily job storing GPU-hour prices for H100 SXM, H100 PCIe and B200 from at least three marketplaces, and per-million-token input and output prices for a frontier, mid and small tier from OpenRouter, into DuckDB.
3. filings/ladder.csv: for CoreWeave, Nebius and IREN, each debt facility, amount, rate, maturity, collateral, plus contracted revenue (RPO) by expected recognition period, with filing and page reference.
4. model/residual.py: per GPU, remaining debt after contract end versus rental revenue at a given post-contract price, power and opex; output the break-even GPU-hour price.
5. note_template.md and the first note: is GPU-hour price falling faster than token volume is rising, chart of rental price against contract roll-off dates, falsifier status.
6. scoring.csv: each month's directional call versus a no-change baseline.

GAP ANALYSIS (BUILT IN)
Keep gaps.md current: which prices are list prices versus clearing prices; whether marketplace supply is representative of contract renewals at scale; whether token volume data covers enterprise direct API usage; which filings omit maturities by facility; whether GPU useful life in the accounting note matches the 'nearly the same length' claim. Fill what you can from filings and APIs today.

SELF-QUESTIONS
- What post-contract GPU-hour price makes the tail whole, and how far is today's median from it?
- Is marketplace spot pricing a valid proxy for a five-year renewal by a hyperscaler?
- Does falling per-token price mean falling GPU revenue, or more tokens per GPU-hour?
- Is the 80/20 open-weight flip measured on a biased sample?
- Which number in the note would change my conclusion if it were off by 20%?

STOP CONDITIONS
Stop and report if a marketplace API requires terms you cannot accept, or if filings do not disclose maturities. Otherwise stop when the logger has run 3 days cleanly and the first note is written; the tracker then continues on schedule.

RETURN FORMAT
Table of deliverable, path, status; the break-even GPU-hour price per issuer with its inputs; today's medians; falsifier status; top five gaps.

Paper research only; no trading advice.
1. From SEC EDGAR, download CoreWeave's most recent 10-K and the latest 10-Q. Extract: each debt facility (name, amount drawn, rate, maturity, collateral, advance rate if stated), remaining performance obligations and the expected recognition schedule, customer concentration (largest customers' share of revenue), and the useful-life assumption for GPUs from the property and equipment policy note. Cite page numbers.
2. Do the same for Nebius and IREN using whatever forms they file.
3. Identify price sources: Vast.ai offers API (filter by GPU name and verified hosts), RunPod and Lambda public price pages, at least one more spot marketplace. Record the exact request or page and whether terms allow automated collection.
4. Call GET https://openrouter.ai/api/v1/models and list prompt and completion prices for a frontier, mid and small tier; pick specific model ids and freeze them.
5. Write claims.md for: '90-95% advance rates', 'loan, contract and GPU life nearly the same length', '80/20 open versus closed in 12 weeks', '$0.28 per million output tokens for DeepSeek V4 Flash', '$200 Max worth over $7,000 of API', 'Modine data center revenue $1.1B, +73%'. Mark each sourced, contradicted or not found.

Build logger/ in Python.
- gpu_prices: for H100 SXM, H100 PCIe and B200 from each source in sources.md, store timestamp_utc, source, gpu, offer_count, median_usd_hr, p25_usd_hr, on_demand or interruptible, url. From Vast.ai, compute stats across verified, on-demand offers, normalized per GPU. From page-based sources, parse listed prices and store as list prices with a flag.
- token_prices: for the frozen OpenRouter model ids, store timestamp_utc, model_id, tier, prompt_usd_per_m, completion_usd_per_m, and the cheapest provider if exposed.
- token_share: if OpenRouter's rankings or another public dataset gives open versus closed token share, store it weekly with its source and note the sampling bias.
Write to DuckDB at data/capex.duckdb, append-only. Schedule daily with a systemd timer or cron at a fixed UTC hour. Add retries with backoff and an error row on failure instead of a silent gap. Respect robots.txt and each site's terms; skip any source that forbids automated access.

From filings/notes.md build filings/ladder.csv with one row per facility: issuer, facility, principal, rate, maturity_date, amortization, collateral, guarantor or off-taker linkage, source_page. Build filings/rpo.csv: issuer, period, contracted_revenue, source_page.
Plot with matplotlib: stacked debt maturities by quarter and contracted revenue by period on the same time axis, one chart per issuer, saved as PNG. Mark the period when large contracts roll off.
Where filings give only aggregate figures, write the assumption you made to split them and mark the row 'estimated'. Do not invent a facility-level schedule that the filings do not support.
Add a customer-concentration column: the share of RPO tied to the largest off-takers named or described in the filing. The structurer's point is that the 90-95% advance rate rests on off-taker credit, so concentration tells you whose credit the lender really holds. Note any facility whose collateral includes the customer contract itself, not just the GPUs.

Write model/residual.py. Inputs per issuer: GPUs financed (from filings or capex divided by an all-in cost per GPU you source), debt remaining at contract end, remaining useful life after contract end, utilization assumption, power cost per GPU-hour (GPU TDP plus overhead times PUE times electricity price), and opex per GPU-hour.
Output: break-even post-contract rental price per GPU-hour needed to repay remaining debt over the remaining life, and a sensitivity table across utilization 40-90% and remaining life 0-3 years.
Compare the break-even with today's logged median and p25 from gpu_prices. State the gap in dollars and percent.
Link to token deflation: compute tokens per GPU-hour for a reference open model at a published throughput, multiply by the cheapest per-token price, and show the revenue per GPU-hour an inference seller can earn at today's token prices.

Write note_template.md with fixed sections: data window; GPU-hour median and p25 change month over month per GPU; cheapest token price change per tier; token share change with the source's bias stated; break-even gap per issuer; falsifier status; one directional call for next month (GPU-hour median up, flat within 3%, or down) with a confidence.
The falsifier, defined now: if GPU-hour rental prices hold flat or rise while token prices fall over a 3-month window, usage growth is absorbing deflation and the tail-risk thesis is wrong. Compute it from the database, not by eye.
Contrast section: compare Modine's backlog and data-center revenue trend with GPU-hour rental, to keep physical infrastructure with order books separate from rental exposure.
Add scoring.csv: month, call, outcome, naive no-change call, outcome. Paper only: no tickers to buy or sell.

1. Re-verify 10 random filing numbers against EDGAR pages.
2. Compare your Vast.ai and RunPod medians with a second independent source, such as a published H100 rental index if you can access one; report direction agreement over the logged window.
3. Check whether any issuer has disclosed contract renewals or re-pricing; that is the true post-contract price and outranks marketplace spot.
4. Score all monthly calls against the no-change baseline. With fewer than 12 months, say the lens is unproven.
5. State the action gate plainly: no positions unless 12 notes exist, the lens beat no-change in at least 8, and a reviewer with credit background signed off; even then no position above 1% of investable capital with a predefined loss limit. Paper tracking continues until then.
6. Write gaps.md: every claim in claims.md marked verified, unverified or false with evidence; list representativeness problems (spot versus contract, router sample versus total token volume); unsourced inputs to residual.py; missing issuers. Fix what you can now.

You are auditing a paper-only AI infrastructure credit tracker you did not build. Read claims.md, sources.md, logger/, data/capex.duckdb, filings/ladder.csv, rpo.csv, assumptions.md, model/residual.py, the notes and scoring.csv.
1. List every numeric claim in the notes and README.
2. Mark each verified, unverified or false, with evidence: a filing page, a query result, an API response timestamp.
3. Re-check: principal in ladder.csv reconciles to the balance sheet; GPU useful-life policy is quoted, not assumed; GPU prices are medians and p25 from verified on-demand offers, not minimums; the token-share series names its sample; residual.py inputs each have a source or are labelled illustrative; no note contains a trade recommendation.
4. List missing pieces: issuers not covered, contract renewal disclosures, power price sources, B200 data depth.
5. Rank gaps by whether they change the break-even gap sign or the falsifier status.
6. Fix the top three now.
7. Report what you could not fix and why, and confirm the no-positions gate is stated in the README.