Field reports from the ACE team on GPU fleet reliability, goodput economics, and autonomous cluster efficiency.
A versioned, sourced catalog of the models on the market today — per-token in/out prices, cache-read rates, context, modalities, capability evidence, and the Artificial Analysis Intelligence Index — grouped by family so you can compare price against performance at a glance.
The v1 scorecard for ACE's request router: two in-house trained heads over a shared embedder plus a priced model catalog. Measured baseline — 0.975 held-out macro-F1 on category, sub-10ms median classification latency on CPU, and an 86.7% cost reduction over a single-flagship baseline on a 798-prompt eval, with the unsafe routes declined by construction.
Every cost-saving layer in ACE — cache, router, compaction — is a claim until you can see it happen. Here's what the built-in dashboard shows, where the numbers come from, and why the whole point is that you never have to take our word for it.
A gateway that sits in front of every model call is the one place that sees all of it — every prompt headed to a third-party provider, every document a RAG pipeline pulls in. That makes it the natural place to stop two very different problems in the same pass: PII leaking out, prompt injection sneaking in.
Most providers bill you per input token, and most prompts are carrying dead weight — repeated instructions, verbose tool schemas, rambling context — that the model doesn't need verbatim to do the job. ACE prunes that weight out before the request ever leaves the gateway.
Most requests hitting your most expensive model don't need it. ACE's router classifies each request's actual difficulty and sends routine work to a cheap model — with a quality gate that catches it when the cheap model isn't good enough, so cheapening the default never means degrading.
How ACE's semantic cache short-circuits repeat and near-duplicate prompts before they ever reach a model — and why a hit has to save 100% of that call's real tokens, not an estimate.
A semantic cache tuned for a stateless support macro is the wrong cache for a multi-turn agent, and the wrong cache again for a RAG pipeline juggling retrieved context. Here are the three tiers of semantic caching sophistication, and ACE's roadmap to support all three.
Why standard GPU monitoring misses Silent Data Corruption in AI clusters, and how Sticky SDC Detection isolates mercurial nodes before they poison a training run.
The most dangerous line of code in a reliability system is the one that evicts a node. During a correlated fault storm, an automated evictor that can't say "no" will shed your fleet into the ground. Safety is the ability to hold.
You can't crash a 16K-GPU training run to test your recovery policy. So the interface to the failure process becomes the product — a distribution-driven, non-memoryless fail-stop simulator whose only external dependency is the data itself.
Owned GPUs, reserved third-party, spot, and pay-as-you-go APIs are four different supply curves priced in four different currencies. Here's how ACE stacks them into one merit order — and never lets a cost optimizer spill into a non-compliant cloud.
What ACE is for, the six principles it's built on, and the phased, safety-gated path from a read-only savings analyzer to an autonomous utilization brain.
Notes from the team on GPU fleet reliability, goodput economics, and the road to autonomous cluster efficiency.
A synthetic fleet eval found ~63% of GPU-time idle — 30× larger than the reliability ceiling we'd been optimizing, and 0% of it captured today. Here's how we measured it and why "stranded" is the safe first slice.
How gate-level micro-faults cripple multi-thousand GPU clusters, and how telemetry-driven automation reclaims lost Model Flops Utilization.
A third-party efficiency layer only earns a security team's trust if raw workload identity never crosses the boundary. Here's how ACE tiers, guards, and charges back on salted-masked identifiers computed inside the customer VPC — and why that's pseudonymization, not magic.
A power grid never asks 'where does this electron go?' — it stacks every generator by marginal cost and fills from the bottom. ACE runs your whole compute fleet — in-house, reserved, spot, PAYG — as one merit order. Here's the mental model and the mechanism.