Skip to Content
PlatformLimits
Raw

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 Vector database limits and are not repeated here.

Aetherfy plan limits by plan

LimitFreeStarterPerformanceEnterprise
Agents1unlimitedunlimitedunlimited
Max memory per agent256 MB2 GB4 GB8 GB
Regions113unlimited
Always-on allowedyes, paused at 75% of the monthyesyesyes
Collections330200unlimited
API keys251050
Workspaces2unlimitedunlimitedunlimited
Storage512 MB10 GB200 GBunlimited
Vector API requests/min1 0005 00020 00050 000
Control-plane API requests/min1005002 000unlimited
Custom Dockerfile buildsnoyesyesyes
Max idle timeout5 min15 min30 minunlimited
Log retention3 days14 days30 daysnegotiated
Stored logs per account50 MB250 MB1 GBnegotiated
Runs in flight11050negotiated
Region changes that copy data, per 30 days0 (single region)0 (single region)10, up to 400 GB copiedunlimited
Deleted collections stay restorable for7 days30 days90 daysno time limit
A collection can be restored to a day back, from its daily backup, up tonot available7 days7 days7 days
Restores, per calendar month (both kinds of restore point)31050unlimited
Volume restored, per calendar month512 MB10 GB200 GBunlimited

Where an Aetherfy limit reads NULL or “unlimited”, no limit is enforced for that plan. For agents that means no cap on how many you run, not that they are free: each is priced by its memory, and the usage beyond the plan’s included amount is billed (see billing).

Note the always-on row. On Starter and Performance always-on is an add-on that counts as usage (billing). On Free it is allowed and costs nothing, under the rule Free’s auto-sleep agent already has: once the agent has been awake for 75% of the month it is paused until the month ends, and new deployments are paused with it. An always-on agent is awake all the time, so that is after about three weeks, and the pause can land up to about a day after the line because awake time is booked once a day. Upgrading to a paid plan lifts the pause and the deployment block at once.

Note the region row: the Free and Starter plans of Aetherfy are single-region, and multi-region placement begins at Performance. See Regions and replication.

Note the four rows on restoring. This page is the one place the days and the counts are typed; every other page, error text and API description names the limit and links here. A delete frees a collection’s name, slot and storage at once, and Aetherfy keeps a copy so a person can restore it: the window is counted from when the copy is ready, a lowered plan shortens the copies already taken, and a raised one does not lengthen them. A daily copy is a restore point for as many days back as the row says, and a plan with none (Free) has only the copy taken at a deletion. The restores and the volume restored are counted per calendar month in UTC, one count and one volume for both kinds of restore point, and the volume is the plan’s storage size. A restore that fails is not counted. A restore the plan has no room for is refused with 403 PLAN_LIMIT_EXCEEDED whose error.limit names the plan’s column: collection_backup_restore_days (a daily copy, on a plan with none), collection_restores_per_month or max_storage_bytes (and max_collections, the collection count a restore is also held to). See restoring a collection.

Note the collection row, because of what it does NOT count: memory threads do not consume collections. Every thread in a workspace is stored in one shared collection keyed by the thread id, so the number of conversations you can hold is not limited by this row — only a namespace costs a collection. See The memory API.

Note the runs-in-flight row, because it is the one limit on this page that is about ACTIVITY rather than about what you own. It counts task runs that are executing at this moment, across every task agent on the account and however each run was triggered — a run you started by hand, a run a schedule fired, and a run one agent spawned in another all count the same. It is the only limit on how many runs of one agent execute at once: a run that finds its agent’s machine busy gets another machine. Start one past the limit by hand or by spawning and Aetherfy refuses it with 429 AGENT_RUN_CONCURRENCY_LIMIT_EXCEEDED, whose detail.limit reads max_in_flight_runs; a scheduled occurrence past it is skipped and recorded with that same code. Nothing is queued, and no run row is created. A service run adds no machine and is not counted. Runs that have finished do not count, so the limit is about how wide you fan out at once and not about how much you run in a day. Enterprise is negotiated per contract rather than unlimited by default.

The max-idle-timeout row applies everywhere the value can be set: when an agent is created or updated through the Aetherfy API or the dashboard, and on every deploy that carries idle_timeout_minutes in aetherfy.yaml, whether uploaded or pushed to a linked repository. It applies only to agents the idle timeout takes effect on: services with keep_alive off. A job runs and exits and an always-on service never sleeps, so neither is refused over its idle timeout — a task keeps running on schedule after a downgrade whatever its value. Above the maximum, on an auto-sleeping service, the deploy fails with PLAN_LIMIT_EXCEEDED and nothing in the file is applied — see the aetherfy.yaml reference.

Aetherfy run tree bounds

The run tree of a run or release is bounded, and the count of what a run spawned is capped, so that reading one costs the same whatever its size. Nothing is cut silently: every answer carries these numbers in limits, says whether a bound cut anything in truncated, and counts what it did not list.

BoundValue
Levels below the root one answer reaches5
Nodes in one answer, the root included200
Children listed under any node but the root50
The root’s children per page, by default50
The root’s children per page, at most100
Runs above the root one answer follows20
A count of spawned runs is exact up to1,000
A count of spawned runs stops at1,001, which means more than 1,000

Aetherfy has two separate rate limits

Aetherfy enforces two independent per-minute rate limits, not one.

PlaneHostLimit
Vector data planevectors.aetherfy.comVector API requests/min from the table above
Control planeagents.aetherfy.comControl-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 carrying the code RATE_LIMIT_EXCEEDED — though the two planes wrap that code in different envelopes, covered below.

How the Aetherfy rate-limit window works

The two Aetherfy planes do not share a limiter implementation, and the difference is visible to a client. Write your backoff against the plane you are calling.

Vector data plane (vectors.aetherfy.com)Control plane (agents.aetherfy.com)
WindowFixed 60-second bucketSliding 60-second window
Retry-After on a 429Sent on RATE_LIMIT_EXCEEDED, never on STORAGE_LIMIT_EXCEEDEDSent
X-RateLimit-* headersNot sentSent — Limit, Remaining, Reset
429 envelopeerror.codedetail.code

On the vector data plane 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. A vector-plane RATE_LIMIT_EXCEEDED 429 carries a Retry-After header with the seconds until the bucket resets (at least 1), the same number as details.reset_in_seconds in its body — wait that long. A STORAGE_LIMIT_EXCEEDED 429 carries none, because waiting frees no storage. See Aetherfy vector API limits.

On the control plane the window slides: capacity is returned continuously as individual requests age past 60 seconds, so there is no boundary to straddle. A control-plane 429 tells you exactly when to come back, and you should read it rather than guess:

HTTP/1.1 429 Too Many Requests Retry-After: 23 X-RateLimit-Limit: 500 X-RateLimit-Remaining: 0 X-RateLimit-Reset: 1755600000
{ "detail": { "code": "RATE_LIMIT_EXCEEDED", "message": "Rate limit exceeded. Limit: 500 requests/minute. Try again in 23 seconds.", "limit": 500, "retry_after_seconds": 23 } }

Aetherfy also returns X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset on successful control-plane responses, so a client can pace itself without ever provoking a 429. X-RateLimit-Reset is a Unix timestamp in seconds.

Enterprise accounts have no control-plane request limit, and Aetherfy sends no X-RateLimit-* headers at all on that plan — an unlimited budget has no remaining count to report. Treat the headers as optional rather than guaranteed.

If Aetherfy’s rate-limit store is unavailable, the control-plane limit can fall to 100 requests a minute per key until it recovers.

This corrects earlier published guidance which stated the fixed-bucket window as a platform-wide fact. It was only ever true of the vector data plane.

How Aetherfy limits region changes

A change to a collection’s regions that adds a region copies the collection’s data into it. Over any rolling 30 days, an account may make as many such changes as the table above allows, copying at most its storage quota times its regions minus one. Removing regions and moving a collection between workspaces copy nothing and are never counted. Free and Starter are single-region and allow none: no change of theirs can copy data. Each refusal says when capacity frees up; to see a change’s numbers before making it, use the regions preview.

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
4096
8192

An arbitrary value between these is not accepted. Every deploy refuses one, whether it comes in an uploaded aetherfy.yaml or a push, with HTTP 422 MEMORY_SIZE_UNSUPPORTED (not a plan limit: no plan raises it) and nothing in the file applied: Memory 3072 MB is not a supported size. Choose one of: 256, 512, 1024, 2048, 4096, 8192 MB. Its body names requested_mb and supported_sizes_mb. A value that is one of these but above your plan’s maximum is refused 403 PLAN_LIMIT_EXCEEDED (detail.limit is max_memory_mb) with a message naming the plan’s maximum.

Cores follow memory. Aetherfy gives an agent one shared vCPU per 2048 MB of memory, so the 8192 step runs on four shared vCPUs and every smaller step on one. There is no separate core setting to choose.

Fixed Aetherfy limits that no plan changes

LimitValue
Task run durationTerminated at 60 minutes and recorded as failed

The run duration is not configurable on any Aetherfy plan, 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 stateConsumes an agent slot
Created, never deployedNo
DeployedYes
PausedYes
ArchivedNo

The limit counts deployed agents, so creating one is never refused for being over it — a created agent is a draft until you deploy it, and drafts are not rationed on any plan. 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, custom Dockerfile builds and, on the vector API, the collection count — the whole plan-cap family shares this one code, so branch on limit rather than expecting a distinct code per limit.

The body is the same on both APIs: code, message, upgrade_url, limit (the limit that fired, such as max_agents or max_collections), allowed (what your plan allows: a number, false for a feature your plan lacks, or null when the plan has no cap) and current (what you hold now). A feature that is simply on or off, such as always-on, has no current. The agents API carries these inside detail, the vector API inside error.

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.

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 plan 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?

It depends on the Aetherfy plane. The control plane at agents.aetherfy.com does send Retry-After, alongside X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset, and its 429 body repeats the wait as retry_after_seconds — read it rather than guessing. The vector data plane at vectors.aetherfy.com also sends Retry-After on a RATE_LIMIT_EXCEEDED 429 (the seconds until its bucket resets, repeated in the body as details.reset_in_seconds) but none of the X-RateLimit-* headers, and none on a STORAGE_LIMIT_EXCEEDED 429, which waiting does not clear. The window differs: the vector plane is a fixed 60-second bucket, so waiting out the remainder of the current minute recovers the full allowance, while the control plane slides and returns capacity continuously.

How long are logs kept?

Your plan keeps logs for 3 days and at most 50 MB per account on Free, 14 days and 250 MB on Starter, 30 days and 1 GB on Performance, and negotiated on Enterprise. Whichever limit is reached first applies. A log past the window is not returned by afy logs, the dashboard or the API, even before the hourly cleanup deletes it.

The size counts each line’s message bytes, at least 64 for a short line, across all your agents. When an account is over its size, the oldest lines are removed first; the newest lines are never the ones lost. The cleanup is hourly, so an account may run over its size for up to an hour.

  • After a downgrade the shorter window applies at once to what you can read, and the older logs, and any lines over the lower size, are deleted at the next cleanup.
  • After an upgrade the longer window and the larger size apply from then on. Logs the cleanup already deleted do not come back.

If you need longer retention than your plan gives — for audit, compliance or trend analysis — ship the logs to your own destination from within your agent while they are still inside the window.

Last updated on