Training clusters.
Pre-wired multi-node GPU clusters with scheduling, checkpointing and fault tolerance.
Turnkey distributed-training clusters — fast interconnect, scheduling, checkpointing and fault tolerance already wired — so a long run survives hardware failure and you bring a job, not a cluster-ops team.
- Category
- AI & ML
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
The cluster that trains Aether, available for your runs.
Standing up a distributed-training cluster — fast interconnect, scheduling, checkpointing, fault tolerance — is a project before the first epoch, and operating it is a team. Aether's training clusters are the same turnkey infrastructure used to train the model itself: meshed multi-node GPUs come up ready, and you bring a job, not a cluster-ops function.
Gang scheduling, checkpointing, fault tolerance — wired in.
Multi-node runs are gang-scheduled so a job gets all its GPUs at once on a shared fabric, RDMA interconnect keeps scaling near-linear, and automatic checkpointing means a node failure on a multi-day run costs minutes. Throughput, utilisation and loss curves stream into observability, so you watch the run rather than babysit the cluster.
On the same data, no copy out to a training cloud.
Training reads the lakehouse directly, so the features a pipeline computed are trainable in place, and the resulting model serves on the same platform with version pinning. There's no export to a separate ML cloud and no second copy of the data to govern. It runs managed or fully air-gapped, for the training that can't leave the building.
Submit a distributed run against lakehouse data, resilient to node failure — no cluster to build first.
aether train submit \
--nodes 16 --gpus-per-node 8 --interconnect rdma \
--data lake.training_set \ # read in place, no copy
--checkpoint every=10m --resume-on-failureThe cluster is meshed and the run checkpoints and resumes through failures on its own, reading the lakehouse in place. On a raw GPU cloud the fabric, scheduler, fault tolerance and a copy of the data are all yours to assemble.
Three steps to running.
Pre-wired multi-node GPUs with RDMA interconnect come up ready.
Gang scheduling and priorities across a shared pool; bring a job, not ops.
Automatic checkpointing means a node failure costs minutes.
Training clusters, in full.
RDMA-interconnected GPUs for near-linear scaling.
Automatic checkpointing so failures cost minutes, not days.
Gang scheduling and priorities across a shared pool.
Throughput, utilization and loss curves wired in.
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";
// Training clusters on Aether Cloud
const res = await aether.ai.training_clusters({
model: "aether-40b",
input,
stream: true,
});
for await (const token of res) process.stdout.write(token);At a glance.
- Interconnect
- RDMA, near-linear scaling
- Scheduling
- Gang + priorities
- Resilience
- Auto checkpoint/resume
- Observability
- Throughput + loss curves
- Scale
- Multi-node, large runs
Built for real work.
Foundation-model pretraining
Large fine-tuning runs
Distributed RL and simulation
On one model, not stitched together.
The usual stack runs training clusters 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 — training clusters sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your training clusters — 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.
Turnkey distributed-training clusters — the same infrastructure that trains Aether, for your runs.
No — scheduling, checkpointing and fault tolerance are wired in; you bring the job.
Automatic checkpointing resumes the run with minutes, not days, lost.
Your boundary, your choice.
Pairs well with.
The simulation-native foundation model itself, served as an API — the core every other service builds on.
Low-latency, streaming inference for every model size, with pinned versions and structured output.
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 Training clusters on Aether Cloud.
Pre-wired multi-node GPU clusters with scheduling, checkpointing and fault tolerance. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.