Hardware-aware token spend governance. Prove what was computed, on what silicon, at what cost.
Enterprise AI inference spend is on track to exceed $40 billion in 2027 (IDC Worldwide AI Spending Guide). It is already the fastest-growing line item in most cloud budgets, and it is the least auditable.
Here is a scenario you have probably lived through: your team ran 12 million tokens through three providers last month. The consolidated bill says $34,200. You reconcile it against your internal tracking and the numbers are... close. Close enough? Maybe. But if your CFO asks "how do you know Azure billed us correctly for 4.1M GPT-4o tokens versus the 3.8M GPT-4o-mini tokens that should have been cheaper?" -- what do you show them?
The honest answer: you show them the invoice. The provider's invoice. The provider who has every incentive to bill you more, not less.
That is the gap. Not cost optimization (you have dashboards for that). Not budgeting (you have alerts for that). The gap is evidence. Independent, timestamped, cryptographic evidence of what was actually computed, on what hardware, at what cost, that your auditor can verify without calling Azure support.
Cloud bills aggregate. They tell you "you used X tokens in region Y." They do not tell you:
SWT3's AI-COST.1 procedure creates an independently verifiable record for each of these. Not a log entry that lives on the provider's infrastructure. A cryptographic anchor with a fingerprint you can check on swt3.ai/verify right now.
At its simplest, witnessing token spend is one method call with three required fields:
from swt3_ai import Witness
witness = Witness() # local mode, no API key needed
witness.witness_resource_consumption(tokens_in=33000, tokens_out=12000, api_calls=47)That is enough to create a tamper-evident record. For full FinOps value, add provider, model, and cost. Here is a realistic enterprise example -- a customer support bot that ran 45,000 tokens through OpenAI at $28.50:
from swt3_ai import Witness
witness = Witness(api_key="your-key")
witness.witness_resource_consumption(
tokens_in=33000,
tokens_out=12000,
api_calls=47,
cost_cents=2850, # $28.50
provider="openai",
model_id="gpt-4o-2024-11-20",
compute_seconds=14.2,
)import { Witness } from '@tenova/swt3-ai';
const witness = new Witness({ apiKey: 'your-key' });
await witness.witnessResourceConsumption({
tokensIn: 33000,
tokensOut: 12000,
apiCalls: 47,
costCents: 2850, // $28.50
provider: 'openai',
modelId: 'gpt-4o-2024-11-20',
computeSeconds: 14.2,
});That produces an anchor like this:
The fingerprint (4f8a2c91e037) is a SHA-256 hash of the token counts, provider, model, cost, and timestamp. Anyone with those original values can recompute the hash and verify the anchor was not tampered with. The provider cannot change the record after the fact. Neither can you. That is the point.
| Anchor Field | FinOps Meaning |
|---|---|
tokens_in / tokens_out | Exact token counts for cost calculation. Compare against provider bill. |
cost_cents | Your recorded cost at time of inference, sealed into a tamper-evident anchor. Once minted, neither you nor the provider can revise it. |
provider | Which provider processed the request (openai, anthropic, bedrock, vertex, azure). |
model_id | Exact model version. Proves which pricing tier applied. |
compute_seconds | Wall-clock inference time. Correlates cost to latency for optimization. |
timestamp | Unix epoch. Proves when the inference happened, not when the bill arrived. |
fingerprint | SHA-256 proof. Independently verifiable. Tamper-evident. |
The problem: Your team uses Azure OpenAI, AWS Bedrock, and Google Vertex. Each bills differently. Monthly reconciliation is manual and error-prone.
With SWT3: Every inference is anchored with the provider name and cost. At month-end, sum all AI-COST.1 anchors by provider. Compare against each provider's invoice. Discrepancies are immediately visible -- and you have cryptographic evidence to dispute them.
The problem: You migrate inference from Nvidia GPUs to a provider's custom silicon. The provider says pricing stays the same. But does it?
With SWT3: AI-COST.1 records cost per inference. AI-HW.1 records the hardware that processed it. Both anchors share the same epoch timestamp, so you can join them: "inference at 14:32 UTC cost $0.003/token on an H100" vs "inference at 14:33 UTC cost $0.003/token on Maia 300." If the provider's silicon cost dropped 40% but your per-token price stayed the same, the anchors show the gap -- not 30 days later on the invoice, but the same day.
The problem: A multi-agent workflow delegates across 5 agents. Each makes API calls. The total cost is buried across multiple billing line items with no attribution to the workflow that triggered them.
With SWT3: Each hop in the chain mints an AI-COST.1 anchor with a shared cycle_id. Query by cycle_id to get total cost per workflow. No agent-level billing from the provider required -- you built the attribution layer yourself.
The problem: A misconfigured routing rule sends traffic to GPT-4 instead of GPT-4o-mini. You do not notice until the monthly bill arrives. $18,000 wasted.
With SWT3: AI-COST.1 anchors include model_id and cost_cents in real time. A daily dashboard query shows cost-per-token by model. When the average jumps 4x on day 3, you see it on day 3. The anchors prove when the misconfiguration started and when you fixed it.
The problem: Your team evaluates three models for a summarization task. Cost is a factor, but the comparison is apples-to-oranges because each model uses different token counts for the same input.
With SWT3: Run the same test set through each model. Each inference gets an AI-COST.1 anchor with exact token counts and cost. The comparison is now evidence-backed: Model A used 12,400 tokens at $0.31. Model B used 8,900 tokens at $0.08. Model C used 15,100 tokens at $0.42. Same input, different economics, cryptographic proof.
The inference hardware landscape is fragmenting fast. NVIDIA dominates today, but the next 18 months bring:
When your inference runs on a mix of these -- potentially within the same cloud provider, potentially within the same day -- the FinOps question changes. It is no longer "what did we spend?" It is "what did we spend on which silicon, and did the pricing reflect the hardware that actually ran?"
SWT3's hardware attestation currently supports auto-discovery for NVIDIA (pynvml/nvidia-smi), Google TPU (JAX), AMD (rocm-smi), AWS Trainium (neuron-ls), and Intel Gaudi (hl-smi). Custom silicon like Maia maps to the generic other category until vendor-specific discovery is added. The witness anchor records the hardware regardless -- the fingerprint does not change when new silicon types are added. See the Cross-Silicon Compliance Guide for full implementation details.
FinOps evidence is not just a nice-to-have. Multiple regulatory frameworks now require demonstrable resource monitoring for AI systems:
| Framework | Requirement | What SWT3 Proves |
|---|---|---|
| EU AI Act Art. 40 | Standards for AI resource monitoring | AI-COST.1 anchors prove resource consumption was monitored at inference time, not reconstructed from billing |
| ISO 42001 A.7.4 | Resource management for AI systems | Per-inference cost records demonstrate active resource governance, not passive billing acceptance |
| NIST AI RMF MANAGE 2.4 | Resource allocation monitoring | Hardware + cost anchors show which resources were allocated to which AI workloads |
| SR 11-7 / SR 26-2 | Model risk includes operational cost | Cost-per-inference evidence supports model risk assessments -- a model that costs 4x more is a different risk profile |
| EU DORA Art. 11 | ICT incident management | Cost anomaly detection via AI-COST.1 time series. A 10x cost spike is an incident indicator. |
Not all cost data should be equally visible. SWT3's clearing levels control what survives in the witness record:
| Level | What is Recorded | FinOps Use Case |
|---|---|---|
| L0 (Analytics) | Full detail: provider, model_id, tokens_in, tokens_out, cost_cents, compute_seconds | Internal dashboards, cost optimization, model comparison |
| L1 (Standard) | Same as L0, persisted to clearing house | Auditor review, regulatory evidence, billing reconciliation |
| L2 (Sensitive) | Provider category only (e.g., "llm_provider"). No model_id, no exact cost | Cross-team reporting where model selection is confidential |
| L3 (Classified) | Hashed model_id, no context. Fingerprint only. | Environments where AI usage itself is sensitive (defense, intelligence) |
Most FinOps teams operate at L0-L1. The cost data is not sensitive -- it is operational. If your organization treats model selection or provider choice as confidential (competitive intelligence, for example), L2 strips the specifics while preserving the fingerprint for later verification by authorized parties.
# Python
pip install swt3-ai
# TypeScript
npm install @tenova/swt3-ai
# MCP Server (works with Claude, ChatGPT, any MCP client)
npx @tenova/swt3-mcpThe SDK is free and open source (Apache 2.0). Local mode requires no API key and no account -- anchors stay on your machine. Connected mode (persisted evidence with auditor access) starts at the free OPEN tier (100 anchors/day). For high-volume production workloads, Pro and Enclave tiers remove limits and add higher clearing levels. See pricing.
Start with witness_resource_consumption() on your highest-spend model. One integration point, immediate visibility. Expand to other models and providers as you see the value in the data.
Full SDK documentation: sovereign.tenova.io/docs
Protocol specification: swt3.ai/spec
Verify any anchor: swt3.ai/verify