Object storage.
Exabyte-scale, eleven-nines-durable object store with lifecycle tiering and presigned access.
An S3-compatible object store built for scale — eleven nines of durability, automatic tiering and fine-grained access — the default home for training data, artifacts and backups.
- Category
- Storage
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Object storage is a solved problem. The bill and the lock-in aren't.
Durable, scalable object storage is a commodity — every cloud has it, and they're all good. What isn't commodity is what it costs to get your data back out, and whether the bytes you store are readable by anything other than that vendor's services. Egress fees and quiet format coupling are how a 'just storage' decision becomes a migration you can't afford. Aether's object store is S3-compatible and sits under an open lakehouse, so the data is portable by design and the engines that read it — warehouse, Spark, the model — read it in place.
S3-compatible, so your tools don't change.
It speaks the S3 API, so existing SDKs, CLIs and pipelines work unchanged — there's no rewrite to adopt it. Eleven nines of durability, lifecycle tiering to colder storage as data ages, versioning and write-once object lock for compliance, and presigned URLs for safe sharing. The table-stakes are all there; the difference is everything around them.
The store the lakehouse and the model read in place.
Most object stores are a destination; this one is the foundation of the data platform. Your training data, artifacts and lakehouse tables live here once, and the warehouse, Spark and the model read them directly — no copy into a proprietary engine's storage, no export to reach the model. It deploys managed or fully air-gapped, so the data lands where it's allowed to live.
Write an object with the S3 API you already use — and query it as a lakehouse table without moving it.
import { aether } from "@aether/sdk";
const store = aether.storage.object("training-data");
await store.put("events/2026-06.parquet", file); // S3-compatible
// Same bytes, queried in place as a governed table:
await aether.sql`SELECT count(*) FROM lake.events WHERE month = '2026-06'`;On a standalone object store, querying that file means loading it into a warehouse first. Here the object and the lakehouse table are the same bytes — written with the S3 API, queried in place, no copy and no egress to reach the model.
Three steps to running.
Encrypted and policy-scoped from the start, S3-compatible API ready.
Use existing S3 tools and SDKs unchanged; presign for safe sharing.
Lifecycle rules tier to colder storage; versioning and locks guard against loss.
Object storage, in full.
Drop-in API so existing tools, SDKs and pipelines work unchanged.
Automatic transition to colder, cheaper tiers as data ages.
Time-limited, scoped URLs for safe sharing without exposing keys.
Object versioning and write-once retention for compliance and recovery.
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";
const store = aether.storage.object_storage("training-data");
await store.put("run-42/weights.safetensors", file);
const url = await store.presign("run-42/weights.safetensors", { ttl: "1h" });At a glance.
- API
- S3-compatible
- Durability
- Eleven nines
- Tiering
- Automatic lifecycle
- Protection
- Versioning + object lock
- Scale
- Exabyte-class
Built for real work.
Training-data and model-artifact storage
Backups and archives
Static assets and data lakes
On one model, not stitched together.
The usual stack runs object storage 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 — object storage sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your object storage — 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.
S3-compatible API, so tools work unchanged — on the platform that also serves the model and trains on this data.
Eleven nines of durability with versioning and write-once object lock for compliance.
Yes — time-limited presigned URLs scope access without exposing keys.
Your boundary, your choice.
Pairs well with.
High-IOPS network block storage that attaches to any instance, with snapshots and encryption.
Managed shared file systems — POSIX and high-throughput parallel options for training data.
Low-cost archival tiers for compliance and long-term retention, with fast restore when you need it.
A governed lakehouse over object storage — open table formats, cataloged and query-ready.
Run Object storage on Aether Cloud.
Exabyte-scale, eleven-nines-durable object store with lifecycle tiering and presigned access. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.