The consolidated limits table. Values come from the product as audited — if something isn’t listed here, it isn’t documented as a limit.
| What |
Window |
| Trash (access groups, features, tables, workflows, notes, secrets, MCP servers, apps, connections, automations, Saved Agents) |
30 days, then permanently purged. Restoring inside those 30 days brings the item back as it was — with one exception: a deleted PostgreSQL change capture connection restored more than 24 hours later comes back without its place in the source database’s change history, so it re-copies every selected table (row below) |
| A paused or deleted PostgreSQL change capture connection keeps its place at the source |
24 hours. Resume or restore inside that window and capture continues from exactly where it stopped; after it, the next successful collection copies every selected table from the beginning. The connection page says which side of the line you are on, and gives you the deadline |
| A reservation Ronja cannot release on your own PostgreSQL |
Retried for 30 days, then Ronja stops and tells your admins. From then on it is yours to remove with pg_drop_replication_slot on the database — see When Ronja cannot release the reservation. A role that lost REPLICATION after the connection was set up is never releasable by Ronja, however long it retries |
| Trash page listing |
Most recent 100 items per section |
| Organization deletion cooling-off |
7 days — contact Ronja support to restore before then |
| Execution-trace detail |
Kept 1 year after the run started. A workflow that pauses and continues keeps ONE trace for the whole pipeline, so the clock runs from the first run of the chain |
| A workflow that keeps pausing |
Given up on after ~11 months from the first run of the chain, with a message saying so. That is one month before its trace would be removed, so a paused chain never outlives its own trace. Work that needs to keep going longer belongs in an automation on a schedule |
| A decided (or expired) run-approval request |
Kept 1 year, then deleted — the run itself and its trace keep their own windows |
| Run history (workflows, automations, Saved Agents) |
Kept 1 year, then each run and its logs are removed from the list. A workflow that pauses and continues is kept as a whole: nothing in a chain that is still running is removed, however long the chain has been going. Files a run saved are not removed with it and stay in Files |
| Connected-mailbox chat read history |
Cleared 7 days after a chat reads a mailbox thread |
| A conversation in a Chat with Agent panel |
Kept 1 year after the last message. This covers the panel on a Saved Agent’s page and the chat panel in an app; a conversation you come back to starts the year again from that message. Once removed, the transcript is gone and the panel opens on a new, empty conversation. Explorations are not affected |
| Attachments that arrive by email |
1 year — this covers both attachments Ronja pulls out of a connected mailbox and attachments on mail sent to your organization’s Ronja address. Move one into a folder in Files and it is kept for good: filing it is what tells Ronja you want it. Anything left loose in Files is cleaned up after a year — with two other exceptions: a mailed file you have added to a Codex is kept as long as the Codex points at it, and a mailed file that was in a folder somebody later deleted is kept for good. Deleting a folder puts everything inside it back loose in Files, but Ronja remembers those files were filed once and leaves them alone |
| Connected-mailbox search by an automation, when no age is given |
Looks back 7 days — Ronja can search further back when she needs to. Searching a mailbox yourself in a conversation is not limited |
| Notifications (the bell) |
1 year, read or unread. Cleared automatically, about once an hour. An unread notification is never cleared sooner than a read one — it is still the only copy of an alert nobody has seen |
| Activity page counts (people, topics, app opens, table reads, what was built from chats) |
Cover at most the last 90 days — the longest time window is 90 d. A person’s status looks back over the past year of visits |
| Audit log |
Keeps a year of events. The list browses about the newest ten thousand events in the selected time window |
| A feature export |
The download stays available 1 year from when the export was made, then the export and its file are deleted. Export again for a fresh copy |
| Login-domain verification link |
Valid 72 hours |
| What |
Limit |
| Images (PNG, JPEG, GIF, WebP) |
20 MB per file |
| Documents (PDF, DOCX, PPTX, …) |
100 MB per file |
| Text and code files |
5 MB per file — only the first ~50 KB is sent to Ronja (a “truncated” badge appears) |
| Data files (CSV, TSV, XLSX, Parquet) |
No fixed size cap in the picker. Older Excel 97–2003 (.xls) workbooks, and workbooks that need a password to open or carry a sensitivity label, can’t be read — save them as an unprotected .xlsx first (Supported formats) |
| Files attached to a single message |
50 in the app — chat attachments, and a drop onto the home page. Over Slack or Teams, 10 per message; anything beyond that is skipped and Ronja names the files she couldn’t take |
| Zip unpacked automatically |
Up to 25 files, 150 MB of contents, and 10 images — a bigger archive is listed instead of unpacked, and unpacked on request (Zip archives) |
| Zip unpacked on request |
200 files and 1 GB per request — ask again for the rest |
| What |
Limit |
| File push API |
Parquet only · 1 GiB per file |
| Connection sync cadence |
Minimum once per hour; interval mode up to 8,760 hours |
| Feature export |
512 MiB per table · 4 GiB per export — over-cap tables export metadata only |
| A Derived table written in SQL |
Built as one file of at most 2.5 GB, from input tables holding at most 4 GB in all. A build over either is refused with an error naming the limit. Over the 2.5 GB output: split the table into smaller tables, or narrow its SQL. Over the 4 GB input, which counts each input table’s whole size whatever the SQL reads of it: build it from fewer or smaller input tables. Its SQL may be several statements whose last is a query (SELECT, WITH … SELECT, FROM or VALUES), and may be a PIVOT without an IN list; a last statement that is not a query is refused |
Column name sent in fields (Row push API) |
1024 bytes — a longer name is refused with a 400 rather than stored |
| Sending several tables at once |
100 tables per release call. A held rebuild nobody releases is released automatically about 15–20 minutes after the table’s first held write |
| Migrations for a managed database |
1,000 per folder sent · at most 40 not yet applied in one push — a bigger push is refused, naming the last migration that fits |
| Column documentation for names a table’s data does not have |
1,000 per table, and 1,000 names per request. On a Dynamic table the names declared at create count toward the per-table budget until the first write, which drops the ones the data did not produce |
These hold wherever SQL over Ronja tables runs — in a chat, a chart, an app, a health check, a workflow, a script Ronja writes, or through the API and CLI. Each place may stop sooner: its own row cap or timeout, listed with it.
| What |
Limit |
| Table data one query reads |
4 GB across the tables it names, each counted at its whole size: filtering or selecting fewer columns does not change it. A query over it is refused with the actual size — read fewer or smaller tables (a derived table that aggregates a large one, for example). No SQL query or SQL build can read a single table over 4 GB: split it into smaller tables |
| Memory and time |
A query too large for the warm query tier gets 9 GB of memory, 2.5 GB of disk to spill to and 13 minutes. One that needs more fails with an error naming what it ran out of; there is no larger compute to retry on (The data platform) |
| A query’s answer |
64 MB. A larger answer is refused — select fewer columns, filter or aggregate |
A table read in a workflow (tools.query) |
One answer of at most 2.5 GB, as a Parquet file — 64 MB for a query that reads no table. A larger one is refused: narrow the query, or build the result as a Derived table |
One tools.query |
One statement that returns rows — a SELECT, WITH … SELECT, FROM …, VALUES, DESCRIBE, SUMMARIZE, or a PIVOT with an IN list. Several statements (a leading SET included), a PIVOT without an IN list, EXPLAIN, PRAGMA, CREATE and COPY are refused |
| What |
Limit |
| Favorites |
10 per type in each Space — “Max 10 favorites in your Space — unfavorite one there to add another”, or “Max 10 favorites outside the Spaces you can open — unfavorite one to add another” for chats and apps in no Space you can open |
| Favorites kept in all |
250 per type, counting favorites of apps in the trash and of chats or apps you can no longer open — past it, adding one shows “You have 250 saved favorites of this kind, including ones in the trash or that you can no longer open — remove some to add another” |
| Sidebar exploration lists |
Your last 50 + the last 50 shared with you |
| Notification panel |
Your most recent 50 — the panel says how many more there are, and the unread count on the bell always covers all of them |
| Prompt queue |
One queued prompt at a time; attachments can’t be queued |
| Conversations with an Agent answering at the same time |
10 per person — the Chat with Agent panel on a Saved Agent’s page shows one conversation, so working normally never reaches it; waiting for a reply to finish frees a slot |
| Conversation length |
No fixed cap. Once a thread outgrows what the model can read in one go, Ronja summarises the earlier turns and carries on, telling you she has (Explorations). The full transcript stays on the page |
| Tangent fork point |
Can’t branch from very old points — roughly 5,000 messages back (“this point is too far back to branch from”) |
| Tangent return summary |
100 KB |
| “Add to chat” text selection |
2,000 characters |
| Styled (HTML) note body |
512 KiB — plain notes are not capped |
| Your policy |
10,000 characters |
| Organization policy |
20,000 characters |
| Policy version history |
The last 50 versions of each policy are kept; History lists the 20 most recent, each restorable |
| Document version history |
The 25 most recent earlier versions of each document or PDF; older ones drop off. A deleted version can’t be recovered |
| Personal memory (still read in conversations; Ronja no longer adds to it) |
2,000 characters |
| Search (⌘K) |
Minimum 2 characters; up to 40 results shown |
| Past conversations Ronja searches when you ask her to find one |
The 500 you most recently worked in. Older conversations are not searched, and she says so when a search reached that far back — ask her to list your chats instead and she covers all of them |
| Managed database joined into a question |
Up to 5 databases in one question, joined with Ronja tables that hold under about 1 GB between them. Each read of the database stops after 60 seconds, and a question that runs out of time is not retried — filter the database side, or mirror the database instead |
| Ronja reading Ronja’s own API for you in a chat |
20 calls per reply. Past that she is told to narrow what she is fetching — one listing usually replaces a loop over ids — or to carry on in her next reply. Another agent she hands work to gets its own allowance |
| What |
Limit |
| Workflow run timeout |
10 minutes by default; 4 hours on dedicated compute — including a workflow whose code is too large for standard compute, which Ronja runs there. A run on dedicated compute can take a few minutes to start, and the wait for a machine does not count toward its 4 hours |
| Wait for a dedicated compute machine |
40 minutes. When every machine is busy, a run waits up to 40 minutes for one to become free; if none does, it fails saying it never started, and nothing ran |
| Function return value shown inline |
8 KB |
| Files saved by one run |
200. A run that saves more keeps the first 200, in the order they were saved; the rest are not delivered |
| An interactive chart a run draws in Python |
5 MB. Over that the code is told, with the fix (fewer points, fewer traces); a chart file that is over the limit anyway is not drawn — the card says how big it is, and the file can still be downloaded |
| A picture a run draws in Python |
10 MB per picture, as a PNG or JPEG. An SVG is refused rather than shown: save one as an ordinary file instead, which is downloadable but not displayed |
| Spawned agents listed per run |
200 (shown as “200+” past the cap) |
| Tables a workflow writes to |
A workflow’s code may name at most 1,000 tables to write to, and one run may write at most 1,000, including tables it creates by name. A run over it is refused before any table is written |
| Tables a workflow reads · secrets · Saved Agents · Codexes it references |
100 each |
| Managed database joined in a workflow |
Read-only. Up to 5 databases in one query, joined with Ronja tables that hold under about 1 GB between them. At most 100,000 rows come back; when the workflow does not set a row limit, a bigger answer is refused, not cut short — filter or summarize the database side |
| Workflows one workflow may run |
32 |
| Connected mailboxes a workflow may send as |
8 |
| Folders a workflow may write files into |
16 |
| Run starts from one workflow run |
60 at once, then 5 per second as the allowance builds back up — starting a Saved Agent and starting another workflow both count against it. A batch of parallel starts fits inside the burst, so an ordinary fan-out is not torn in half |
| Links to pages in Ronja from one workflow run |
300 at once, then 30 per second as the allowance builds back up. Past that the request fails straight away with a rate-limit error — a workflow does not wait and try again — so ask for each link once and reuse it |
| Saved Agent runs at once, per organization |
60 unless an admin has changed it for your organization |
| How far ahead a run may pause |
1 year. A Durable workflow that asks to wait until a moment further out than that is refused when it tries to pause |
| How long a Waiting run stays paused |
14 days past the moment it was due to continue. A Durable workflow that pauses and cannot be woken by then is failed, with a message saying why |
| How long a run stays Awaiting approval |
7 days by default; the workflow’s author can set anything up to 14 days. Nobody decides by then and the request expires and the run fails — see Monitor runs and traces |
| How long an agent waits at one go |
24 hours. An agent that asks to wait longer is refused and told to use an automation instead |
| How many times one agent run may wait |
5. Past that it is told to finish with what it has, or to set up an automation |
| How long an agent run may live in total |
72 hours from when it started, waiting included |
| What |
Limit |
| Source files |
1 MiB per file · 256 files per module |
| Modules one workflow may import |
32 |
| What |
Limit |
| Agent chain depth |
3 generations when one agent runs another directly; 6 when the chain goes through workflows. Past it the run is refused with an explanation |
| Declared references on one Saved Agent |
100, counted across every kind together — an Agent asked to carry more is refused when it is saved, naming the cap |
| Agent runs at once |
60 per organization unless an admin has changed it — further starts are refused until in-flight runs finish |
| Paused runs |
50 per organization, counted across both kinds of pause together — runs waiting for someone’s reply and runs waiting on a timer or another run. Past that, an agent that would have paused finishes with what it has and says what was missing instead |
| How long a run waits for a reply |
3 days by default, between 1 and 14 days if the Agent sets its own — then the run continues without an answer |
| Questions one run may ask |
5. Past that the run carries on without asking again |
| Questions to one person per day |
10 per person per organization (rolling 24 h). Past that the agent is told to try tomorrow or ask someone else |
| How much of a reply Ronja reads |
8 KB — several pages of text. A longer reply is read up to that point and the run is told plainly that the rest was cut, so a fragment is never mistaken for the whole answer |
| Files sent with a question |
10 files, 25 MB total. Email only — a question asked over Slack cannot carry files and is refused if it tries. From an Outlook mailbox the ceiling is about 3 MB per message (Microsoft’s limit); an oversized send is refused before anything goes out |
| Messages Ronja can send in one conversation |
20 — the first question, every follow-up, and every closing message together (the person’s own replies don’t count). Past that the run carries on without contacting them again |
| How long a conversation stays open |
30 days after its most recent message, pushed out again by each new one. Continuing a conversation works for questions sent from a connected mailbox and for questions asked over Slack; one sent from Ronja’s own address gets one answer and stops there |
| Questions open in one conversation |
One at a time |
| How long a closed conversation is kept |
7 days after it stops being open, then Ronja’s record of the conversation is deleted. A conversation still waiting on an answer is never deleted |
| What |
Limit |
| Schedule trigger |
Minimum interval 1 hour |
| Webhook trigger |
1,000 runs per rolling 24 h · 1 MB request body · signed requests within a 5-minute window |
| Table trigger |
50 runs per rolling 24 h · at most 25 watched tables |
| Event trigger |
5,000 runs per rolling 24 h across all event automations (per-organization loop-safety ceiling) |
| Mailbox trigger |
Filters are optional; at most 50 entries per filter list. Only mail arriving after the automation is enabled is picked up, and mail is looked back over a few hours only |
| Attachments a mailbox trigger reads |
20 files per message, each up to 25 MB, and 100 MB per message in total. Reading them as a search instead — in a conversation, or from a Saved Agent working the inbox — is capped at 50 files per search. Anything skipped is named, with the reason |
| Automation rate limit (webhook, email, event & mailbox) |
Per-automation two-window throttle — system defaults 60 runs/minute and 1,000 runs/day; an admin sets the per-organization default and a max ceiling on the Automation limits page in the sidebar’s Billing & Control group (Admin only) |
| Email trigger |
Chained automation depth capped at 4 |
| Address / URL rotation |
About once per minute |
| Automations shown on the Automations page |
200. An organization with more sees the first 200, and a line under the list says how many it is showing out of how many there are. The filters and Search automations reach only the automations the page has, so they cannot find one past the cap |
| Declared resource references per automation |
200 |
| What |
Limit |
| Email recipients Ronja can send to from her own address |
500 per organization per day (rolling 24 h) |
| Email recipients Ronja can send to as a connected mailbox |
500 per mailbox per day (rolling 24 h) by default — an Admin sets a Daily send limit on the mailbox card, up to 10,000 |
| Recipients on one email |
20, counting the main recipients and anyone copied in (Cc) together |
The split is by which address the mail came from. Everything Ronja sends as one of your connected mailboxes — a reply in a chat, a reply or new email from an Automation or Saved Agent, a question she emails, and mail a workflow sends — draws on that mailbox’s own Daily send limit, and never on the organization-wide cap. Everything she sends from Ronja’s own address draws on the organization-wide cap, and never on a mailbox’s limit.
So the Daily send limit on a mailbox card is the whole answer to “how much mail can leave this address in a day”, whoever or whatever asked for it. Each connected mailbox has its own budget, independent of the others and of the organization-wide cap.
All of these count recipients, not messages: one email to ten people counts as ten. People copied in (Cc) are recipients like any other: they go through your organization’s email policy and count toward whichever budget applies. There is no Bcc — see Copying people in.
Questions to a person count too, when they go out as email. A question an Agent emails is a recipient like any other and goes through your organization’s email policy. Which budget it draws from follows the same rule as everything else: a question sent from a connected mailbox draws one from that mailbox’s Daily send limit, and a question sent from Ronja’s own address draws one from the organization-wide cap. It also has its own, much tighter limits on top (5 questions per run, 10 questions to one person per day, 50 paused runs per organization) — see Saved Agent runs above. Every later email in the same conversation — a follow-up question, or a closing message that needs no answer — is a recipient again and draws from whichever budget applies. A question asked as a Slack message is not email and touches neither the policy nor either budget.
| What |
Limit |
| Properties per organization |
20 |
| Values per property |
500 |
| Values one person has on a Several values property |
20 |
| Property name · value name · description |
60 · 128 · 280 characters |
| Import from file |
1 MB and 1,000 people per file, and at most 5,000 operations per import (each value given, and each property or value created) — the preview names the limit before you apply |
| What |
Limit |
| Source files |
5 MiB per file · 100 files per app · 50 MiB total · app icon (icon.svg): 16 KiB |
| Server functions |
Each call gets 10 s, or up to 30 s when the app asks; 4.5 s of computing time; 64 MB of memory; and about 4.5 MB in each direction. A call to an outside service gets at most 30 s and a 5 MB answer, and a search of a Codex at most 10 s and 50 matches. A call to the AI, and a wait for a workflow it starts, fit inside the call’s own time. A function can join up to 2 managed databases with the app’s tables in one read by default, also within the call’s time. Each person using an app has at most 2 Codex searches and AI calls, and 2 workflow calls, going at a time on each of Ronja’s servers. A function Ronja has to stop by force twice within ten minutes, for running past its time, is turned off for an hour, or until a fixed version is published. Calls count toward the app’s query rate below |
| Attached tables / secrets / Codexes / Saved Agents / workflows / metrics |
100 each |
| Query results |
1,000 rows by default; hard cap 100,000. When a query hits the cap the app says so, so the person looking at it knows they are seeing only part of the result — a notice across the top by default, or the app’s own “showing the first N” line where it already states it in place — see Open it standalone |
| Query rate |
60 queries/second, with a burst allowance of 600. Unused allowance builds back up continuously, so an app that loads many panels at once is fine — only a runaway loop sustains enough traffic to be throttled. A throttled call is retried automatically before your app ever sees it |
| Links to pages in Ronja |
300 at once per app session, then 30 per second as the allowance builds back up. A throttled link is retried automatically, so only an app linking many hundreds of different pages at once gets near it |
| Chat panel conversations answering at the same time |
10 per person — a panel shows one conversation, so a normally built app never reaches it; waiting for a reply to finish frees a slot |
| Replies in one chat panel conversation |
One at a time. Sending again while a reply is still arriving is refused rather than queued — wait for the answer, then send |
| Messages in one chat panel conversation |
100 from the person, across the life of the conversation |
| External database query timeout |
60 s |
| In-browser result decoding |
Every query an app runs is answered by Ronja, and the results are turned into rows inside the person’s browser. Loading the reader that does it has a 60 s limit; past it the app shows an error instead of loading indefinitely — see Troubleshooting. An App built before that reader moved inside it still starts a separate decoder, with 60 s to start it the first time it reads data and 60 s for each result after that; after a start-up times out it waits before trying again, beginning at a minute and lengthening while it keeps failing, so a retry inside that wait is refused straight away. Asking Ronja to update the App, and publishing that change, removes that decoder |
| Server-side fetch proxy |
10 MiB request/response · 30 s timeout |
| Version history |
Up to 100 snapshots |
| App session |
1 day, one per app address per browser: the app in Ronja, in a new tab and in Fullscreen share it, and opening or reloading the app reuses it until the day is up, then signs you in to the app again on its own (an open chat panel conversation still does not survive a reload). Signing out, being removed from the organization, or having your account deleted ends the session within 30 seconds — an app left open in another tab stops loading data by then and needs a fresh sign-in |
| What |
Limit |
| Stations per organization |
100 that are not disconnected — disconnect one to add another |
| Apps per station |
20 |
| Rotate every |
10 seconds to 24 hours |
| Query rate on a station |
Each App on the station has its own allowance, the same as one person’s above. A station showing 20 Apps can therefore use up to 20 times one App’s |
An inline app is the interactive answer that lives inside one conversation, and its limits are the conversation’s rather than an App’s.
| What |
Limit |
| Inline apps in one conversation |
4. Asking for a change to one you already have rewrites it in place and does not count; a fifth new one is refused |
| Rewrites of one inline app |
40 from scratch. Ronja usually changes one by patching a file, which is not counted, so a normal back-and-forth never reaches it |
| Source files |
24 files · 512 KiB total per app |
| Query rate |
The same 60 queries/second with a burst allowance of 600 as an App — but the allowance is per person, per conversation, shared by every inline app in that chat. A colleague reading the same conversation has their own allowance, so nothing you do can throttle theirs |
| In-browser result decoding |
Results are decoded inside the person’s browser by a small reader loaded from Ronja itself — no tens-of-megabytes download and no third-party network — so the first read is fast. Loading that reader is still bounded at 60 s, and past it the app shows an error instead of waiting (see Troubleshooting). There is no per-result decode limit |
| Repairs Ronja makes herself |
2 per app, per conversation. She checks each app she writes and rewrites it if something came out broken; after the second repair she stops and tells you what is still off |
| Lifetime |
The conversation’s. It is deleted with the chat, and there is no version history — keep one with Make it an App |
| What |
Limit |
| Tags per resource |
20 |
| Tags per organization |
500 distinct tags |
| Tag name length |
64 characters |
| What |
Limit |
| Open move requests |
100 per user |
| Request notes, decision reasons, move rationales |
4,000 characters each |
| Table / app drafts |
One open draft per person per resource |
| Edit draft on a shared resource |
Removed 30 days after it is created, whether or not you are still editing it |
| Proposal awaiting review |
Removed 30 days after it is filed |
| Active content health checks per table |
20 |
| Active freshness checks per table |
1 |
| Freshness check interval |
5 minutes – 90 days; from the CLI or the API, whole hours: 1 hour – 90 days |
| What |
Limit |
| Spaces per organization |
20 |
| Notification email recipients |
47 |
| Daily AI safety limit |
The lower of your organization’s own limit and Ronja’s limit for your organization, in credits per day counted as on your bill. When today’s AI use reaches it, all AI pauses for everyone until 00:00 UTC, when the day resets; workflows that don’t use AI keep running, and so does Ronja’s own background work, such as naming chats, which still counts |
| Role changes taking effect on active sessions |
Up to ~2 minutes |
