Model serving.
Low-latency, streaming inference for every model size, with pinned versions and structured output.
Production inference for Aether and your own models — autoscaling endpoints with streaming, batching and pinned versions, so behaviour is fast, reproducible and cost-controlled.
- Category
- AI & ML
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Serving a model is easy. Serving it the same way twice is the hard part.
Standing up an inference endpoint takes an afternoon. Keeping it reproducible takes a platform. The moment a model version silently rolls forward, a prompt template changes, or autoscaling cold-starts a slightly different runtime, behaviour shifts and the bug report says "it used to work." Aether's serving layer pins the model version to the endpoint, so a request today produces what it produced last quarter — and an audit can replay any past response from the version hash, the input and the prompt. Reproducibility isn't a feature you add later; it's the difference between a demo and production.
Streaming and batch on one endpoint, autoscaled to zero.
The same endpoint streams tokens for an interactive copilot and runs high-throughput batched inference for an offline scoring job — you don't operate two systems for two latency profiles. Endpoints autoscale with traffic and down to zero when idle, so a low-traffic internal tool costs nothing overnight and a launch-day spike doesn't queue. You serve Aether or your own fine-tuned models the same way, with the same pinning, batching and observability.
Structured output and tools enforced at the boundary — and the data is already here.
An app that has to parse free-form model text is one bad generation away from an outage. Aether enforces JSON schemas and tool-call formats at the serving boundary, so what reaches your code is valid by construction, not by hope. And because serving runs on the same platform as your data and the rest of the catalog, an endpoint can retrieve from the vector store and read governed tables inline — the model and the data it needs never cross a vendor boundary to meet, and the whole path deploys managed or fully air-gapped.
A pinned endpoint that returns schema-valid JSON — no parsing free text, no version surprises.
import { aether } from "@aether/sdk";
const res = await aether.serving.generate({
model: "aether-40b@2026-05", // pinned version, reproducible
input: ticket.body,
schema: { // enforced at the boundary
type: "object",
properties: {
category: { type: "string", enum: ["bug", "billing", "other"] },
urgency: { type: "integer", minimum: 1, maximum: 5 },
},
required: ["category", "urgency"],
},
});
routeTicket(res.category, res.urgency); // valid by constructionThe version is pinned, so the same input gives the same output and an auditor can replay it. The output is schema-valid at the boundary, so your code never parses a free-form string. On a generic endpoint both of those are your problem to solve in application code.
Three steps to running.
Aether or your own; pin a version for reproducible behaviour.
Autoscaling, streaming or batched, with structured-output enforcement.
Drift and cost monitoring wired in; scale to zero when idle.
Model serving, in full.
Token streaming for chat, batched throughput for offline jobs.
Lock a model version for reproducible, auditable behaviour.
Scale endpoints with traffic, down to zero when idle.
Enforce JSON schemas and tool-call formats at the boundary.
Provision it in a few lines.
Every service is reachable from the same SDK, CLI and infrastructure-as-code — one identity, one bill, one audit trail across the whole catalog.
import { aether } from "@aether/sdk";
// Model serving on Aether Cloud
const res = await aether.ai.model_serving({
model: "aether-40b",
input,
stream: true,
});
for await (const token of res) process.stdout.write(token);At a glance.
- Modes
- Streaming + batch
- Versions
- Pinned, reproducible
- Scaling
- Autoscale to zero
- Output
- Schema-enforced JSON / tools
- Models
- Aether + your own
Built for real work.
Production model endpoints
Batch scoring jobs
Multi-model routing
On one model, not stitched together.
The usual stack runs model serving in one product, the model in another and the data in a third — and the seams between them are the cost. Aether Cloud runs it on the same platform that serves the model, governs your identity and deploys into your boundary, with the rest of the catalog one hop away.
No stitching a vector DB to one place, a warehouse to another and a model to a third — model serving sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your model serving — so the data and the model never leave the same governed boundary to talk to each other.
Need a capability that isn’t here yet? The model writes and deploys it into the same boundary — the catalog is a starting point, not a ceiling.
Good to know.
Production inference for Aether and your models — on the platform where the data and the model already live.
Yes — lock a version for reproducible, auditable behaviour.
Yes — JSON schemas and tool-call formats enforced at the boundary.
Your boundary, your choice.
Pairs well with.
The simulation-native foundation model itself, served as an API — the core every other service builds on.
Pre-wired multi-node GPU clusters with scheduling, checkpointing and fault tolerance.
Customer-controlled fine-tuning and adapters on data that never leaves your boundary, with eval gates.
Managed notebooks wired to the data platform and GPU compute for exploration and analysis.
Model and prompt registry, evals, deployment and drift monitoring — versioned and auditable.
Build a working app, agent or simulation by describing it, deployable in a click. See Aether Studio.
Run Model serving on Aether Cloud.
Low-latency, streaming inference for every model size, with pinned versions and structured output. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.