Product surface
Diff -> callsites -> scenario pair -> PR comment -> policy verdict.
- Python AST scanner
- TS/JS tree-sitter scanner
- estimate_pr pure core
- GitHub Action glue
Platform
The PR comment is the wedge. The platform underneath is the moat.
103 Python modules span cost simulation, callsite takeoff, data ledgers, actuals, footprint, and a self-maintenance loop.
Pure cost-risk math
No DB, no GitHub, no UI. Just the deterministic engine behind the forecast.
- Monte Carlo with CRN
- AACE estimate class
- risk drivers
- model recommendation
- cloud, capex, commitment
- carbon, water, materials
Ledger and basis
The reference data and actuals layer that makes estimates reproducible and calibratable.
- price medallion
- spec sheet
- SWE-Bench capability
- OTel and FOCUS ingest
- actuals pairing
Self-development organism
A dry-run-first loop that proposes and verifies improvements against the same cost controls.
- health score
- scout sanitizer
- budget governor
- metered provider
- hash-chain evidence
Architecture depth
The internal boundary is a product feature, not an implementation detail.
The cost engine is pure math. It does not know about GitHub, databases, UI, or billing. That boundary makes the forecast testable, portable, and usable from local demos, CI, future web demos, or private pilot installs.
The takeoff layer owns product context: it reads code changes, finds AI callsites, builds baseline and PR scenarios, and renders a report reviewers can understand. The Blue Book owns the basis: prices, structures, specs, capability grades, actuals, and provenance. The split keeps the model honest: the engine calculates, the ledger substantiates, and the product surface explains.
Autobuild is included because it proves the recursive idea. Class1 can meter its own development loop with the same pricing basis it uses for customer workloads, then feed self-calibration into the actuarial table. That does not replace human judgement, but it shows the platform can govern AI work, including its own.
The thesis
AI cost is not only tokens.
Class1 models the fully loaded bill: token rates, cache structures, model capability, MCP/tool schemas, cloud services, committed capacity, owned GPUs, carbon, water, materials, and estimate decay.
Token billinput, output, cache, reasoning, batch, tiers
Cloud sideFOCUS service categories, vector DB, storage, egress, endpoints
CapExAPI vs self-host vs hybrid, utilization and idle waste
Governancepolicy gate, estimate class, BOE, actuals loop
Platform proof points
The value is in the joined system, not any single widget.
Risk band plus estimate classAleatory uncertainty and epistemic uncertainty are kept orthogonal. The buyer sees both the P50/P90 spread and how mature the inputs are.
Events versus pairsProvider events can measure retry and usage shapes, but estimate class only improves from estimate-actual pairs. This prevents fake maturity.
Frozen basis plus decayA reproducible snapshot makes estimates auditable. If the basis ages, the class decays instead of silently drifting.
Fully loaded AI costTokens are one line item. Cloud services, committed capacity, owned hardware, MCP schemas, and footprint all change the real decision.
Monte Carlo
Month-level systemic risk, p50/p90 lognormals, paired common random numbers.
Contingency
Tornado sensitivity ranks who owns the P90 tail.
Escalation
Price decline, volume growth, and structural drift separated instead of called inflation.
Capability
Ranks by cost per completed task using task-specific benchmarks.
Structured pricing
Cache, batch, context tiers, reasoning effort, and effective dates.
MCP overhead
Tool schemas as recurring input tokens; architecture break-even analysis.
Actuals
FOCUS and provider usage become estimate-actual pairs.
Evidence
Basis status, hash chains, and reproducible snapshots.