---
slug: platform/limits
title: Limits
kind: reference
surface: platform
summary: The Aetherfy platform limit index — per-tier agent, memory, region, collection, key, workspace and storage quotas, the two separate per-minute rate limits for the vector data plane and the control plane, and fixed limits on task duration and log retention.
sources:
  - dashboard/migrations/047_extend_plans_for_full_tier_limits.sql
  - dashboard/migrations/054_extend_plans_for_collections_and_api_keys.sql
  - dashboard/migrations/077_add_max_workspaces.sql
  - dashboard/migrations/080_bump_saas_quotas.sql
  - aetherfy-control-plane:shared/plan_validator.py
  - aetherfy-control-plane:shared/config.py
  - vectordb:backend/services/rateLimit.js
  - vectordb:backend/services/storageGauge.js
---

# Aetherfy limits

## What this Aetherfy limits page covers

This page is the Aetherfy **platform** limit index: quotas that belong to your
account and plan. Per-request caps on the vector API — batch sizes, payload
sizes, result counts — are documented at `/vectors/limits` and are not repeated
here.

## Aetherfy plan limits by tier

| Limit | Free | Starter | Performance | Enterprise |
|---|---|---|---|---|
| Agents | 1 | 3 | 10 | unlimited |
| Max memory per agent | 256 MB | 1 GB | 2 GB | 8 GB |
| Regions | 1 | 1 | 3 | unlimited |
| Always-on allowed | no | yes | yes | yes |
| Collections | 3 | 30 | 200 | unlimited |
| API keys | 2 | 5 | 10 | 50 |
| Workspaces | 1 | unlimited | unlimited | unlimited |
| Storage | 512 MB | 10 GB | 200 GB | unlimited |
| Vector API requests/min | 1 000 | 5 000 | 20 000 | 50 000 |
| Control-plane API requests/min | 100 | 500 | 2 000 | unlimited |
| Custom Dockerfile builds | no | yes | yes | yes |
| Max idle timeout | 5 min | 15 min | 30 min | unlimited |

Where an Aetherfy limit reads `NULL` or "unlimited", no limit is enforced for
that tier.

Note the region row: the Free and Starter tiers of Aetherfy are single-region,
and multi-region placement begins at Performance. See `/platform/regions`.

Note the max-idle-timeout row too, because Aetherfy enforces it in one layer
only: the per-tier maximum applies when an agent is created or updated through
the Aetherfy API or the dashboard. The `aetherfy.yaml` parser and the deploy
path place **no** upper bound on `idle_timeout_minutes` — see
`/agents/aetherfy-yaml`.

## Aetherfy has two separate rate limits

This corrects previously published documentation, so it is worth stating
plainly: Aetherfy enforces **two independent per-minute rate limits**, not one.

| Plane | Host | Limit |
|---|---|---|
| Vector data plane | `vectors.aetherfy.com` | Vector API requests/min from the table above |
| Control plane | `agents.aetherfy.com` | Control-plane API requests/min from the table above |

The two budgets are separate. Saturating the control plane does not consume vector
API allowance, and vice versa. Exceeding either returns HTTP 429 with
`error.code = "RATE_LIMIT_EXCEEDED"`.

## How the Aetherfy rate-limit window works

The Aetherfy rate-limit window is a **fixed 60-second bucket**, not a sliding
window. The counter resets at the bucket boundary rather than gradually
releasing capacity, so a burst that straddles a boundary can succeed where the
same burst inside one bucket would not.

**There is no `Retry-After` header on an Aetherfy 429.** Do not write a client
that depends on one. Back off on your own schedule — exponential backoff with
jitter is the sane default.

## How Aetherfy counts storage

Aetherfy storage quota counts **every replica**. A collection's bytes are counted
once per region it is placed in, so 100 GB held in one region and 33 GB
replicated across three regions consume the same storage budget.

Exceeding the storage limit blocks **writes**. **Reads are never blocked** — an
Aetherfy account over its storage cap can still serve search and retrieval
traffic while you free space or move to a larger plan.

## Aetherfy agent memory values

Agent memory in Aetherfy must be one of these exact values, in megabytes, and
must also be within your plan's maximum from the table above:

| Allowed memory values (MB) |
|---|
| `256` |
| `512` |
| `1024` |
| `2048` |
| `8192` |

An arbitrary value between these is not accepted.

## Fixed Aetherfy limits that no tier changes

| Limit | Value |
|---|---|
| Task run duration | Terminated at **60 minutes** and recorded as failed |
| Log retention | **7 days** |

Neither is configurable on any Aetherfy tier, including Enterprise. A workload
that legitimately needs more than 60 minutes should be split into several
scheduled task runs that checkpoint their progress.

## How Aetherfy counts agents against your limit

| Agent state | Consumes an agent slot |
|---|---|
| Archived | No |
| Paused | Yes |

A paused Aetherfy agent still holds its slot, so pausing agents is not a way to
fit more of them under your plan's agent limit. Archiving is.

## What Aetherfy returns when a plan limit is exceeded

Requests that would take you past a plan limit are rejected with HTTP 403 and
the code `PLAN_LIMIT_EXCEEDED`. The message names the limit that fired and what
would resolve it. It covers the agent count, memory per agent, region count,
always-on, the idle timeout, and custom Dockerfile builds — the whole plan-cap
family shares this one code, so branch on the message rather than expecting a
distinct code per limit.

This is separate from the usage-limit codes: `PLAN_LIMIT_EXCEEDED` means a
structural cap on your plan, while `SOFT_CAP_EXCEEDED` means you are within your
plan but at your spend limit. See [Billing and spend caps](/platform/billing).

## Aetherfy limits FAQ

### Which rate limit applies to my request?

It depends on which Aetherfy host you called. Requests to the vector data plane
at `vectors.aetherfy.com` — searching, upserting, retrieving and deleting points
— draw on the vector API allowance, which is 1 000 requests per minute on Free,
5 000 on Starter, 20 000 on Performance and 50 000 on Enterprise. Requests to the
control plane at `agents.aetherfy.com` — deploying, spawning, reading logs,
managing workspaces — draw on a completely separate control-plane allowance of
100, 500, 2 000 and unlimited respectively. These are two independent budgets:
exhausting one leaves the other untouched.

### Does storage count once, or once per region?

Once per region. Aetherfy counts every replica against your storage quota, so a
collection replicated into three regions consumes three times its own size. This
is why 100 GB in a single region and 33 GB across three regions cost you the same
budget. It also means that adding a region to a large existing collection is a
storage decision as much as a latency one — check your headroom before you widen
a collection's placement.

### What happens if I exceed my storage cap?

Aetherfy blocks writes and leaves reads alone. Upserts and other write operations
are refused while you are over the cap, but search, retrieval and every other read
path continue to serve normally. That asymmetry is deliberate: an application over
its storage limit degrades to read-only rather than going dark. To recover, delete
vectors you no longer need, release a replica in a region you no longer serve, or
move to a tier with a larger storage allowance.

### Do paused or archived agents count against my agent limit?

Paused agents do; archived agents do not. Pausing an Aetherfy agent stops it from
doing work but keeps its slot reserved, so you cannot pause your way under the
agent limit. Archiving releases the slot. If you are at your agent limit and want
to deploy something new without upgrading, archive an agent you are not using
rather than pausing it.

### Is there a `Retry-After` header on a 429?

No. Aetherfy does not send a `Retry-After` header on a 429, and client code must
not depend on one being present. Implement your own backoff — exponential with
jitter is the standard choice. It also helps to know that the Aetherfy rate-limit
window is a fixed 60-second bucket rather than a sliding window, so waiting out
the remainder of the current minute is generally sufficient to recover capacity.

### How long are logs kept?

Aetherfy retains logs for 7 days, on every tier. This is not configurable, and no
plan extends it. If you need longer retention — for audit, compliance or trend
analysis — ship the logs to your own destination from within your agent while
they are still inside the 7-day window.