Exact-match inference infrastructure

Verified cache hits for AI inference.

Aero reduces repeated deterministic inference cost by serving byte-verified cached responses, then proves the savings with latency, cost, and cache-hit evidence.

Open AeroBench Read the architecture

Deterministic requestsByte verificationFail-open

demo receipt / tier a

Repeated request trace

Summarize the cache correctness contract.

Verified

01MISSmodel calledcached

02HITbyte verified$0 compute

X-Aero-Cache

hit

X-Aero-Verified

true

X-Aero-Tier

Upstream calls

Cached response served without model compute

model calls on an exact hit

Byte

verification before serving

Direct vs cached

evidence for every run

The repeated-call problem

The same answer should not require the same compute twice.

Retries, eval reruns, classification jobs, extraction pipelines, and agent loops can send identical requests. If the request is deterministic, paying a model to reproduce the same bytes is avoidable waste.

Duplicate work

The same model, prompt, and settings reach the inference provider again.

Hidden cost

A provider invoice shows spend, but rarely proves which calls could have been skipped.

Unproven savings

A hit-rate claim means little without verification state, timing, and a comparable baseline.

How Aero works

Three checks between a request and a claim.

Aero only takes the exact path when it can preserve correctness. Everything else passes through.

Gate

Confirm the request is deterministic and safe to cache. Random requests bypass the exact path.

Verify

Look up the canonical key, then byte-check the stored request before any answer is served.

Prove

Return proof headers, latency, cost, and a receipt that AeroBench can inspect.

Correctness boundary: Tier A is exact and verified. Semantic matching and prefix-warmth heuristics are Tier B, opt-in, and never included in the exactness claim.

AeroBench

The claim has a proof surface.

Fire one deterministic request twice. AeroBench shows the miss, verified hit, cache tier, measured latency, estimated cost, and receipt headers.

AeroBench is not a chat product. It is a controlled, read-only demonstration of the cache and benchmark system.

Access live AeroBench Try the proof preview

AEROBENCH / PROOF RUN

CANNED DATA

Prompt

Return a JSON object with the request ID and status.

Fire once

Fire twice

Latest receipt

Cache: HIT
Verified: TRUE
Tier: A
Model compute: $0

Architecture

Public proof. Protected live bench.

The marketing site and proof preview work without a live backend. Real inference at bench.go-aero.net stays behind Google authentication and request limits.

Fail-open across every optional layer

go-aero.net

Public explanation

PUBLIC

go-aero.net/bench

Read-only proof preview

PUBLIC

bench.go-aero.net

Google-authenticated live bench

ACCESS

protected

api.go-aero.net

Rate-limited backend

PROTECTED

live request path

AeroCache

Determinism gate · canonical key · byte verification

TIER A CORRECTNESS

L1 memory

hot entries

L2 Valkey

shared cache

Future L3

object storage

verified miss only

AeroCore placement

Choose the cheapest healthy rung that can meet the request deadline.

Local model

Free, best-effort Mac worker

RUNG 1

Cloud provider

Paid fallback for heavy models

RUNG 2

AeroCache is the correctness layer. AeroCore decides where misses go. AeroRig measures what happened.

Benchmark evidence

Direct and cached, side by side.

AeroRig measures what happened. It records latency, time to first token, success, answer stability, and verified hit count. The table is an interface preview, not a production benchmark.

BENCHMARK ARTIFACT / PREVIEW

VALUES PENDING

Measure	Direct	Verified hit	Delta
p50 latency	pending	pending	—
p95 latency	pending	pending	—
Time to first token	pending	pending	—
Verified hit count	0	pending	—
Answer stability	baseline	byte compare	—
Success rate	pending	pending	—

Measured results will replace placeholders after the controlled benchmark study. Losses will be published alongside wins.

Build status

The proof path exists. The lab comes next.

AeroCachecomplete

AeroBenchcomplete

AeroCorecomplete

AeroRigcomplete

Lenovo server bootstrapnext

AeroEvidencequeued

Roadmap

Lenovo server bootstrap

Bring up the always-on cache, proof, and observability host.

AeroEvidence graph

Record what each backend can run, what is warm, and measured latency.

AeroFleet

Connect the Mac worker as the free, best-effort local inference rung.

AeroGate

Route heavy misses through protected cloud APIs with cost controls.

Context-anchor routing

Add a clearly labeled Tier B prefix-warmth heuristic.

Benchmark study

Publish the crossover: where exact caching wins, and where it does not.

See the exact path

One miss. One verified hit. Evidence for both.

Use the public demo without touching the live lab or spending inference budget.

Access AeroBench View proof preview