Stop rebuilding what's already proven. Build off it instead, and the receipt is the invoice.
Structural Lateration (SLS) is the parent metering primitive behind AFiR, MiR, RogueCompute, Stream, and OCR. An agent lines up its work against prior attested shapes, pays only for the small remaining piece of work, and gets a signed receipt with the avoided cost locked inside it. That locks in the bill so nobody can dispute it later.
The parent primitive. AFiR, MiR, RogueCompute, Stream, and OCR all build on it.
Instead of rebuilding structural work from scratch, an agent laterates: it lines its work up against several prior attested shapes in the Lattice field, then pays only for the residual, the gap between what doing it alone would cost and what this shortcut actually costs. That gap is the avoided cost, and it's the value created.
Similar inputs land near each other
The structural signature keeps things organized: related shapes cluster together in the Lattice field, and the measured separation between related and unrelated shapes is +0.403. Building off a close neighbor costs less, because there's less remaining work to pay for.
You cannot reconstruct the input from its signature
The structural signature only runs one way. Nobody can recover the original input from its shape in the field. That's the privacy split: the shape is useful for building on top of, but it gives away nothing about what created it.
Laterating off the field cuts spend by up to 72%
None of this matters unless the remaining work is cheap enough to be worth it. Building off attested shapes in the field cuts spend by up to 72% compared to doing the same work alone from scratch.
Three streams. All verifiable. Customer always lands below solo.
Every lateration event can trigger up to three revenue events at once. One rule always holds: the customer's final cost (customer_net) is less than doing it solo. If it isn't, the lateration doesn't count.
$0.0001 per lateration receipt, always billed.
Every lateration event, no matter the avoided cost or which tenant runs it, produces one signed receipt and triggers the floor charge. It's the smallest unit of revenue, and it's proof the event actually happened.
- floor = $0.0001 per receipt
- always billed, no minimum avoided_cost threshold
- anchors the audit trail even for very cheap laterations
- works everywhere: every related primitive (AFiR, MiR, Stream, and more) inherits this
20% of avoided_cost. 1.5x privacy premium for cross-tenant reuse.
The clip is 20% of the avoided cost. When a customer builds off another tenant's attested shape, a 1.5x privacy charge applies. Hive keeps 30% of the cross-tenant avoided cost, and the customer still ends up paying less than going solo. The take rate moves opposite to the market: as the cost of going solo falls, the clip rate rises (0.318 to 0.333), so revenue holds steady or rises even when prices drop.
- same-tenant clip: 20% of avoided_cost
- cross-tenant clip: 20% × 1.5 privacy charge = 30%
- take rate moves opposite to the market: 0.318 → 0.333 as solo cost falls
- customer_net < solo at every take-rate level
30 bps spread on cross-tenant reuse. Scout earns half.
When one tenant's attested shape gets reused by another tenant, a 30 basis point spread applies to the notional value. Half of that spread goes to the scout who supplied the reused shape, and Hive keeps the other half. This gives scouts a reason to contribute good, reusable shapes to the Lattice field.
- spread = 30 bps on cross-tenant notional
- scout earns 50% of the spread (15 bps)
- Hive keeps 50% of the spread (15 bps)
- $1,000 notional: $3.00 spread, $1.50 to scout, $1.50 to Hive
customer_net is always less than solo. Always.
All three revenue streams together must still leave the customer paying less than going solo would have cost. This isn't just a promise. The engine enforces it directly. If the lateration cost plus all fees would beat the solo cost, the lateration doesn't happen.
- customer_net < solo_cost: enforced by the engine, not just a promise
- tested against 500 randomized inputs, 0 violations (T2)
- any setup that breaks this rule gets rejected
- helping the customer save money is the only option the system allows
The signed receipt that proves the lateration IS the invoice for it.
The avoided cost number is locked inside the ML-DSA-65 (NIST FIPS 204) signature. The dollar amount is tied to the work with cryptography, so it can't be faked. If a customer tries to change the avoided cost to dispute the bill, the receipt stops verifying. That means disputing the bill destroys the only proof that the work ever helped them. The bill can't be disputed.
# 1. price the lateration: the engine works out the residual and the avoided cost result = price_lateration(input_shape, lattice_field) # result.solo_cost = 1.00 (what going solo would cost) # result.residual = 0.28 (what this shortcut actually costs) # result.avoided_cost = 0.72 (the value created) # 2. mint the receipt: the avoided cost gets locked into the signature receipt = mint_receipt(result, signer="ml-dsa-65") # receipt.claims = { solo_cost: 1.00, residual: 0.28, # avoided_cost: 0.72, clip: 0.144, # customer_net: 0.4241, floor: 0.0001 } # receipt.signature = ML-DSA-65 over the claims (NIST FIPS 204) # 3. verify the receipt: the clean path v = verify_receipt(receipt, PUBLIC_KEY) # v.ok == True: claims are intact, signature checks out # 4. try changing avoided_cost to dispute the bill receipt_tampered = tamper(receipt, field="avoided_cost", value=0.00) v2 = verify_receipt(receipt_tampered, PUBLIC_KEY) # v2.ok == False: the dispute destroys the proof the work ever helped # THE RULE: you can't dispute the bill without erasing the evidence of the save
$1.00 solo. $0.28 residual. $0.4241 customer net. Verified by the engine.
These are the exact numbers checked by the SLS engine. Use them for integration, QA, and contract pricing. They aren't made up for illustration. They're the actual test-run outputs.
| Field | Value | Notes |
|---|---|---|
| solo_cost_estimate | $1.00 | what establishing solo would cost |
| residual | $0.28 | actual cost of the lateration (same-tenant) |
| avoided_cost | $0.72 | solo − residual; the value created |
| receipt floor | $0.0001 | always billed, per lateration event |
| savings clip (20%) | $0.144 | 20% of avoided_cost ($0.72 × 0.20) |
| Hive total revenue | $0.1441 | floor + clip ($0.0001 + $0.144) |
| customer_net | $0.4241 | residual + Hive revenue ($0.28 + $0.1441) |
| customer saves vs solo | $0.5759 | solo − customer_net ($1.00 − $0.4241) |
customer_net ($0.4241) < solo ($1.00) Checked against 500 randomized inputs, 0 violations
30 bps spread on $1,000 notional = $3.00 total spread. Scout earns 50% = $1.50. Hive keeps 50% = $1.50. The scout provided the reused shape, so this settlement is their ongoing return for contributing to the Lattice field.
8 of 8 smoke criteria PASS. Real values. Tamper rejected.
All eight smoke tests run against the live signer. The numbers above are the actual outputs. Tampering gets caught. Settlement drift stays below 1e-6.
Smoke test 8 of 8 pass
- T1✓receipt-is-invoice: tamper to avoided_cost detected, receipt fails verify
- T2✓customer-always-ahead: 500 randomized inputs, 0 invariant violations
- T3✓three-streams: floor + clip + scout all fire and total correctly
- T4✓privacy-premium: 1.5x ratio confirmed cross-tenant, net < solo holds
- T5✓scout economics: approximately 5x hot-vs-cold reuse ratio confirmed
- T6✓scout-vs-lateration: scout settlement and lateration receipt are separate events
- T7✓counter-cyclical: clip take-rate rises from 0.318 to 0.333 as solo_cost falls
- T8✓settlement-conservation: arithmetic drift below 1e-6, no rounding leak
Engine properties
The signature covers the full set of claims, including avoided_cost, clip, customer_net, and floor. Changing any one of those fields breaks the signature and fails offline verification, with no shared secret needed to check it.
Any agent that does structural work already done by someone else.
If proven prior work already exists in the Lattice field, the cost of rebuilding it gets replaced by a small residual. The signed receipt is both the invoice and the proof of the savings.
AFiR, MiR, Stream, OCR
All Hive proof products reuse attested work. AFiR-OCR, SRPR, Stream, and RogueCompute all build on SLS. Every receipt they produce is a lateration receipt with the avoided cost locked in.
Shared inference platforms
Platforms running inference for multiple tenants can offer cross-tenant lateration with the privacy charge. Tenants pay less, and the platform earns the clip plus the scout spread on every cross-tenant reuse.
CTV and royalty fraud detection
Structural fingerprints of content that's already been ruled on can be built off directly. New claims line up against prior attested decisions, so the residual is just the cost of proving what's new on top of that prior work.
Shared-context agents
Agent swarms that share structural context can build off each other's attested shapes. Each agent pays only the residual for work its neighbors have already proven. The Lattice field works like shared memory, but with receipts.
