The Aether model.
The simulation-native foundation model itself, served as an API — the core every other service builds on.
The foundation model at the centre of the platform — trained on simulation, not scraped text, and able to forward-roll a system in time. Served as an API, in three sizes, with a 1M-token context.
- Category
- AI & ML
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Most foundation models describe the world. This one computes it forward.
The frontier chat models are trained on scraped text. They are extraordinary at describing, summarising and reasoning over language — and fundamentally, that is what they do: predict the next token of a description. Aether is trained on simulation trajectories, instrument data and design history, so its native act isn't describing a system but rolling it forward in time. Ask a chat model what happens to a turbine under load and it recalls what's been written; ask Aether and it computes the trajectory. That difference — describing versus simulating — is the whole reason the platform exists, and why one model can do engineering, chemistry, silicon and robotics instead of just talking about them.
Three sizes, a million-token context, one set of weights across disciplines.
Aether ships in three sizes — 7B dense, 40B dense and a 280B sparse mixture-of-experts — so you trade cost against capability without changing APIs. All carry a one-million-token context with streaming rollouts and structured output. The same weights serve a drug-discovery team, a chip-design house and a robotics lab; specialisation lives in the agents and the data, not in a different model per domain. Cross-domain transfer — physics learned in one discipline improving another — is the empirical result of training on simulation, not a marketing line.
Native tool use and structured output, capability-gated by construction.
Agents are only as safe as the actions they can take. Aether's tool use and function calling are native and gated: every external action requires an explicit grant, the refusal corpus is versioned alongside the weights and red-teamed each release, and structured output is enforced so what reaches your code is valid. This is the substrate the agent runtime, the disciplines and Studio are all built on — one model, one safety story, one audit trail.
Served where your data is allowed to live.
Frontier models live behind a public API in someone else's cloud. Aether deploys into the boundary your data requires — managed, in your VPC, on-prem, or fully air-gapped with zero bytes leaving the perimeter and an export-control posture for sovereign work. The weights serve from inside your boundary, customer-controlled fine-tuning trains on data that never leaves, and the model sits next to your warehouse and vector store rather than across a wire from them.
The capability a chat model doesn't have: ask Aether to roll a physical system forward in time and return the trajectory, not a description of one.
import { aether } from "@aether/sdk";
// Forward-roll a system, don't describe it
const rollout = await aether.simulate({
model: "aether-40b",
system: "heat-exchanger-v3", // geometry + materials from your data
conditions: { inlet_K: 360, flow_kg_s: 4.2, hours: 8 },
report: ["wall_temp", "fouling", "pressure_drop"],
});
console.log(rollout.timeseries.wall_temp); // computed, with uncertaintyA text model can tell you how a heat exchanger behaves in general; it cannot compute this one's wall-temperature trajectory under these conditions. Aether returns the forward-rolled result with calibrated uncertainty — because simulating systems is what it was trained to do, not an add-on.
Three steps to running.
Send prompts, tools and context to a pinned model version; stream tokens or rollouts back.
Wire retrieval, functions and your data so answers are grounded and actions are capability-gated.
Run managed or fully air-gapped — the weights serve from inside your perimeter when required.
The Aether model, in full.
Computes the world forward across physics, chemistry, biology and code.
7B dense, 40B dense and 280B sparse-MoE for cost and capability trade-offs.
Million-token context with streaming rollouts and structured output.
Native function calling and capability-gated tool use.
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";
// The Aether model on Aether Cloud
const res = await aether.ai.the_aether_model({
model: "aether-40b",
input,
stream: true,
});
for await (const token of res) process.stdout.write(token);At a glance.
- Sizes
- 7B dense · 40B dense · 280B MoE
- Context
- 1M tokens
- Modalities
- Text, structured, simulation rollouts
- Tool use
- Native function calling, gated
- Training
- Simulation, instrument & design data
Built for real work.
Agents and copilots
Simulation and digital twins
Cross-discipline reasoning
On one model, not stitched together.
The usual stack runs the aether model 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 — the aether model sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your the aether model — 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.
Those are trained on scraped text and describe the world; Aether is trained on simulation and computes it forward — and it deploys into sovereign and air-gapped boundaries.
Yes — the weights serve from inside your perimeter with zero bytes leaving the boundary.
Three: 7B dense, 40B dense and a 280B sparse-MoE, all with a 1M-token context.
Your boundary, your choice.
Pairs well with.
Low-latency, streaming inference for every model size, with pinned versions and structured output.
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 The Aether model on Aether Cloud.
The simulation-native foundation model itself, served as an API — the core every other service builds on. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.