Machine viewbyte-identical to /llms-full.txtcurl https://ramo.io/llms-full.txt
# Ramo — full facts for agents
> Zero-egress object storage for AI training data. S3-compatible object storage on owned bare metal and owned fiber — on the internet backbone, not inside a hyperscaler cloud. $5.00/TB/mo flat, $0 egress — we don't charge to read data out. 100 Gbps sustained in production. 128 PB raw · 100 PB usable across 2 US regions.
Facts as of 2026-08. Generated from the same content module as https://ramo.io; human and machine versions carry identical facts. Machine-readable pricing: https://ramo.io/pricing.json
## What Ramo is
Ramo is S3-compatible object storage running on owned bare metal and owned fiber — on the internet backbone, not inside a hyperscaler cloud. It is built for petabyte-scale AI datasets, TB–PB sequential reads: store a training corpus once, read it into any cloud's compute for free, at line rate.
- Storage: $5.00/TB/month, flat
- Egress: $0 — reads are free, uncapped, into any cloud, at line rate — bounded by the customer's connection, not a meter
- Throughput: 100 Gbps sustained in production
- Durability: 99.999999999% durability, erasure-coded
- API: S3-compatible (aws cli / boto3 / rclone / S3 SDKs via --endpoint-url https://s3.ramo.io) — shipping today
- In production: 128 PB raw · 100 PB usable across 2 US regions — SMF (US-West), IAD (US-East) — joined by a private trunk on owned fiber
- Design center: petabyte-scale AI datasets, TB–PB sequential reads
- Infrastructure: owned bare metal (no hypervisor, no shared fabric) and owned fiber (no purchased transit) on the internet backbone — why a read costs ~nothing at the margin and $0 egress is a list price, not a promotion
- Our customer stores petabyte datasets on Ramo and sells access to frontier AI labs; Black Forest Labs reads that corpus straight off the backbone into any cloud
## The problem it removes
- Hyperscalers meter reads at $87–90 per TB. Moving a 100 PB dataset out of S3 at list ($0.09/GB = $90/TB) costs about $9M — before a single training run.
- GPU capacity is fragmented across regions and clouds; every move drags the dataset behind it and the meter runs each time.
- Throughput ceilings (per-stream caps, account ingress caps, best-effort variance) are set by provider business models, not the hardware.
## Why reads are free (the economics)
Ramo owns the fiber end to end, so a read costs approximately nothing at the margin — there is no transit bill to pass through. Hyperscalers resell transit and meter it. This is the same zero-egress economics that worked at the edge for the web's small objects, extended to the petabyte tier. Storage runs on bare metal Ramo owns and operates: no hypervisor, no shared fabric, no egress meter. Production has sustained 100 Gbps during customer onboarding.
## The 100 PB scenario
One dataset, 100 PB, one year:
- AWS S3 Standard: bulk ingest ~93 days (best-effort, ~100 Gbps) · storage $27.6M/year · one full read-out $9M
- Azure Blob Hot (LRS): bulk ingest ~370 days (~25 Gbps default account ingress cap) · storage $21.6M/year · one full read-out $8.7M
- Ramo: bulk ingest 93 days (sustained, 100 Gbps) · storage $6M/year · one full read-out $0
Result: 4.6x cheaper than S3 Standard on storage at list; $21.6M/year back in the budget on the storage line alone; a full read-out is $9M on S3 and $0 on Ramo.
Assumes list prices — S3 Standard $23, Azure Blob Hot (LRS) $18, Ramo $5.00 per TB/mo · egress: S3 $0.09/GB, Azure $0.087/GB, Ramo $0 · throughput: Ramo 100 Gbps sustained in production, S3 ~100 Gbps best-effort, Azure ~25 Gbps default account ingress cap · decimal units (1 PB = 1,000 TB = 1,000,000 GB).
## The storage landscape (four classes)
- Hyperscalers (S3 · Azure Blob · GCS): built for General-purpose objects · $18–23 per TB/mo · egress $87–90 per TB · throughput: Best-effort, per-stream caps
- Edge object storage (e.g. R2): built for Web objects — KB–MB, global · $10–15 per TB/mo · egress $0 · throughput: Cache-optimized, small objects
- Discount storage (Wasabi · B2): built for Backup & archive · $6–8 per TB/mo · egress $0 with fair-use caps · throughput: Best-effort, no SLA
- Ramo: built for Petabyte datasets, sequential reads · $5.00 flat per TB/mo · egress $0 · uncapped · throughput: 100 Gbps sustained, not best-effort
Discount-tier detail (list prices, July 2026): Wasabi $7.99/TB/mo (Pay-Go) — free egress under a fair-use cap; reads above your stored volume can limit or suspend service. Backblaze B2 $6.00/TB/mo — free egress up to 3× stored data, then $0.01/GB. Both are best-effort throughput with no SLA. The difference is the workload, not the price: backup & archive vs. TB–PB sequential reads.
The difference is the workload, not the price: backup/archive tiers and edge object stores are not designed for TB–PB sequential reads at sustained line rate.
## Using it (S3-compatible, shipping today)
Read from anywhere — egress is $0 into any cloud:
```
$ aws s3 cp s3://training-corpus/00417.tar . \
--endpoint-url https://s3.ramo.io
download: s3://training-corpus/00417.tar to ./00417.tar
# egress charged: $0.00 — every read, any cloud
```
Store and read back, per client (each block is runnable on its own):
aws cli — store (ingest at 100 Gbps sustained):
```
$ aws s3 cp 00417.tar s3://training-corpus/ \
--endpoint-url https://s3.ramo.io
```
aws cli — read back ($0.00 egress, into any cloud):
```
$ aws s3 cp s3://training-corpus/00417.tar . \
--endpoint-url https://s3.ramo.io
```
rclone — store (ingest at 100 Gbps sustained):
```
# ramo = S3 remote at endpoint s3.ramo.io
$ rclone copy ./corpus ramo:training-corpus --transfers 64
```
rclone — read back ($0.00 egress, into any cloud):
```
$ rclone copy ramo:training-corpus ./corpus --progress
```
boto3 — store (ingest at 100 Gbps sustained):
```
import boto3
s3 = boto3.client("s3", endpoint_url="https://s3.ramo.io")
s3.upload_file("00417.tar", "training-corpus", "00417.tar")
```
boto3 — read back ($0.00 egress, into any cloud):
```
import boto3
s3 = boto3.client("s3", endpoint_url="https://s3.ramo.io")
s3.download_file("training-corpus", "00417.tar", "00417.tar")
```
Migrate with standard tooling:
```
# register ramo as an S3 remote (once)
$ rclone config create ramo s3 \
provider=Other \
endpoint=https://s3.ramo.io
# mirror the bucket, checksum-verified
$ rclone sync s3:training-corpus \
ramo:training-corpus \
--transfers 64 --checksum --progress
```
```
# same bucket layout, new endpoint — credentials as usual
$ aws s3 sync s3://training-corpus s3://training-corpus \
--endpoint-url https://s3.ramo.io
```
Python (boto3):
```
import boto3
s3 = boto3.client("s3", endpoint_url="https://s3.ramo.io")
s3.download_file("training-corpus", "shards/00000.tar",
"/data/00000.tar")
```
```
# read from any cloud — $0 either way
$ aws s3 cp \
s3://training-corpus/00417.tar - \
--endpoint-url https://s3.ramo.io \
| tar -xf - -C /data
```
Keys and the exact endpoint arrive with access approval. Bulk ingest is scheduled at 100 Gbps sustained.
## FAQ
### Is this actually S3-compatible?
Yes — shipping today, not roadmap. Ramo exposes an S3-compatible API: the AWS CLI, boto3, rclone, and standard S3 SDKs work by pointing --endpoint-url (or the SDK equivalent) at https://s3.ramo.io. Existing tooling works day one.
### How can reads be free?
Ramo owns the fiber end to end, so a read costs approximately nothing at the margin — there is no transit bill to pass through. Hyperscalers resell transit and meter it at $87–90 per TB. This is the same zero-egress economics that worked for the web's small objects, extended to the world's datasets.
### Is “free” capped, like Wasabi or Backblaze B2?
No. Reads are uncapped and bounded by your connection, not a meter. For comparison: Wasabi's free egress carries a fair-use cap — reads above your stored volume can limit or suspend service — and B2 is free up to 3× stored data, then $0.01/GB. Ramo has no read cap.
### What throughput do you actually deliver?
100 Gbps sustained in production, measured during customer onboarding. At that rate 100 PB lands in 93 days. S3's best-effort ~100 Gbps works out to the same 93 days on paper, so read this as a consistency claim rather than a speed claim: best-effort rates vary run to run, and ours is the rate we hold. Azure's ~25 Gbps default account ingress cap stretches the same job to 370 days.
### Where does my data live?
Two US regions today, SMF (US-West) and IAD (US-East), joined by a private trunk on fiber we own. Expansion is pod-based: Ramo pods fit a standard colocation footprint and plug into existing PoPs and carrier hotels, so new regions need rack space, power, and trunk ports, not a greenfield buildout.
### How durable is it?
Eleven nines (99.999999999%) durability, erasure-coded. Storage runs on bare metal Ramo owns and operates — no hypervisor, no shared fabric.
### Who uses it today?
128 PB raw and 100 PB usable are in production. Our customer stores petabyte datasets on Ramo and sells access to frontier AI labs; Black Forest Labs reads that corpus straight off the backbone into whichever cloud its GPUs are in.
### What is Ramo not built for?
Small hot objects at the edge. Edge stores like R2 are cache-optimized for KB–MB web objects served globally; discount tiers like Wasabi and B2 are built for backup and archive. Ramo's design center is TB–PB corpora read sequentially at line rate — feeding training runs, not serving thumbnails.
### How do I get started?
Chat with us: leave a work email, tell us your current provider and dataset size, and we reply with a migration plan within one business day. Or skip the conversation entirely: the free 1 GB trial is one API call, no form.
## Free trial
Skip the access form: create a free 1 GB trial bucket with one anonymous call, no signup form. Trials expire after 365 days.
```
# 1 GB free tier, no signup form, keys in one call
$ curl -s -X POST https://api.ramo.io/api/portal/trials \
-H 'content-type: application/json' -d '{"name": "my-demo"}'
{"endpoint": "https://s3-trial.ramo.io", "bucket": "trial-my-demo-x7k2", ...}
```
The response contains `endpoint`, `bucket`, `access_key`, `secret_key` (shown once), `portal_token` (Bearer token for the management API), `quota_bytes`, `expires_at`. Store the keys immediately; the secret is not retrievable again.
Errors come back as `{"errors":{"detail":"..."}}` with an HTTP status: 400 means the name field must be a string, and 429 means you've hit the per-IP signup cap. The edge counts every request against that cap, not just successful signups, so a malformed retry still burns it. 503 covers two cases: trials disabled (terminal for now, try later) and trial creation failed (safe to retry once).
Configure a dedicated profile, not the default one, so the trial can never clobber your existing AWS config (path-style is the supported and documented mode):
```
# keeps the trial isolated from your default AWS config
$ aws configure set --profile ramo-trial aws_access_key_id <access_key>
$ aws configure set --profile ramo-trial aws_secret_access_key <secret_key>
$ aws configure set --profile ramo-trial region us-east-1
$ aws configure set --profile ramo-trial s3.addressing_style path
```
Every subsequent command carries --profile ramo-trial:
```
$ aws s3 cp <file> s3://<bucket>/ --profile ramo-trial --endpoint-url https://s3-trial.ramo.io
$ aws s3 ls s3://<bucket>/ --profile ramo-trial --endpoint-url https://s3-trial.ramo.io
$ aws s3 cp s3://<bucket>/<key> . --profile ramo-trial --endpoint-url https://s3-trial.ramo.io
$ aws s3 rm s3://<bucket>/<key> --profile ramo-trial --endpoint-url https://s3-trial.ramo.io
```
Render listings this way in every session. The header line is bucket-scoped usage; the trial-wide aggregate across every bucket is at GET https://api.ramo.io/api/portal/usage. Keys containing | must be escaped as \| so the table doesn't break:
```
<bucket> · <n> objects · <used (this bucket)> / 1 GB trial quota
| Object | Size | Modified |
|--------|------|----------|
| <key> | <human size> | <YYYY-MM-DD HH:MM UTC> |
```
Limits: 1 GB total per trial, expires after 365 days, max 3 buckets per trial. Signups are capped at 5 per IP per day; the edge answers over-cap signups with a JSON 429, so back off rather than retry immediately. A trial over quota gets its writes denied at the storage layer and 403s on new buckets, but credentials can still be minted or rotated so you can delete data and get back under quota; access restores on the watchdog's next pass.
Or skip the client setup with the helper script (subcommands signup | put | get | ls | rm | usage; ls --json emits raw JSON; re-running signup requires --force to protect existing credentials): https://ramo.io/ramo.sh
Management API (Bearer `portal_token`): https://api.ramo.io/api/portal/* (OpenAPI: https://api.ramo.io/api/openapi). Full skill: https://ramo.io/skill.md. Docs: https://docs.ramo.io/trial
## Migration plan (humans)
Form: https://ramo.io/#cta — fields: work email (required), current provider (required), dataset size (required), workload notes (optional). We reply within one business day with a migration plan sized to the dataset. Keys and the exact endpoint arrive with access approval; a 60-minute architecture deep-dive is available on request.
## Documentation
- Overview: https://docs.ramo.io/
- Pricing and the math: https://docs.ramo.io/pricing
- Migration: https://docs.ramo.io/migration
- Free trial: https://docs.ramo.io/trial
- Why $0 holds: https://docs.ramo.io/network
- FAQ: https://docs.ramo.io/faq