camelAI Documentation

API Reference

Limits

Every limit a developer can hit on camelRun

View as Markdown · Docs index for coding agents

Past a size limit the request is refused with a 400 or 413. Past a count or rate limit, it's a 409 or 429 with Retry-After. See Errors for what to do about each. KiB = 1,024 bytes, MiB = 1,024 KiB.

Agents

LimitValue
An agent's key1 to 80 characters of A-Z a-z 0-9 _ -
Lifetime (ttlSeconds)60 seconds to 366 days, or null for until deleted. Default: until deleted with a key, 1 day without
Imported history (initialMessages)16 MB of JSON
systemPrompt, systemPromptAppend32,000 characters each
modelHeaders20 headers, 8 KB in all
context4 KB
Mounts16 per agent
Agents busy at onceBy usage tier, across the whole runtime. An agent is busy while it has a run open, running or queued; a busy agent queues more runs without another slot. A run past the limit gets 429 BUSY_AGENT_LIMIT
Tools in an agent's catalog4,096 tools and 16 MiB of schemas; at most 64 offered directly to the model, the rest reached from js_exec

Usage tiers

An account's tier comes from what it has paid for credit in total, net of refunds. Starting credit and other grants do not count. A payment moves the account up as soon as it lands. See Pricing.

TierPaid in totalAgents busy at once
Freenothing yet8
Tier 1$525
Tier 2$50100
Tier 3$250250
Tier 4$1,0001,000

GET /v1/billing has busyAgents: the limit, how many are busy now, the tier, and the next one; the console's Billing page shows the same.

Runs and requests

LimitValue
Request id (requestId, idempotencyKey)1 to 80 characters of A-Z a-z 0-9 _ -
Open requests per agent (running and queued)32
Prompt body6 MiB, with inline files
metadata16 keys of 1 to 64 characters, string values of at most 512 characters
Provider retries within a turn3 attempts for overloads, rate limits, 5xx and dropped streams
How long a run may takeNo limit. The SDKs have no default timeout
Idempotency-Key header1 to 255 characters; its answer is kept for 24 hours

Files

LimitValue
Files attached to one message20
Inline (base64) file bytes in one message4 MiB in all
One file256 MiB
Image the model sees natively5 MiB and 8,000 pixels a side
PDF the model sees natively16 MiB and 100 pages
Signed links1 second to 24 hours, default 15 minutes
A volume100,000 files and 100 snapshots

Tools

LimitValue
A tool result the model reads32,000 characters; a longer one is saved whole to a file the model can read
Attached tool call deadline15 seconds without an answer by default; timeoutMs from 1 second to 20 minutes
MCP server call deadlineDefault 60 seconds, at most 20 minutes
OpenAPI operation deadlineDefault 30 seconds, at most 20 minutes
ProgressEach progress report restarts a call's deadline, up to 20 minutes in all
One tool result from the SDKs1 MiB of JSON
Tool sources per definition64 MCP servers and 64 OpenAPI specs
An OpenAPI spec8 MiB, at most 1,024 operations

Code the model writes (js_exec)

LimitValue
Wall time30 seconds by default, at most 120
CPU time2 seconds of executing code (time waiting on tools doesn't count)
Memory32 MiB WebAssembly memory, 16 MiB QuickJS heap
Output32,000 characters by default, at most 128,000
Tool calls256 per script, at most 32 in flight
One fs.readFile or fs.writeFile700 KiB

People

LimitValue
How long an input waits7 days by default; from 60 seconds to 30 days
An input's message4,000 characters
Approvers100
ask_user1 to 4 questions, each with 2 to 4 options

Sub-agents

See Multi-agent.

LimitValue
Delegation depth (delegate.maxDepth)2 by default (a parent, its children and theirs); 1–5
delegate calls in flight per run (delegate.maxParallel)4 by default, 1–16; more wait their turn
A sub-agent's spendwhat its parent's run and agent spend limits have left when it starts, as its run's spend limit; what it spent counts against both
A sub-agent's lifetimea day (86,400 s), as a scratch agent's; one named by key ({ agent }) is yours and keeps its own
A delegate task100,000 characters; inline instructions 32,000
Agents in one allowlist (delegate.agents)32; a name 1–64 letters, digits, _ and -; a description at most 1,000 characters

Sub-agents are agents: each counts against busy agents, the run rate and your spend limits like any other.

Streams and browsers

LimitValue
One SSE frame1.1 MB; a larger event arrives as event_omitted
Events buffered per agent for replayThe last 512, at most 2 MiB
Long poll wait25 seconds
Read-only subscribers32 per agent
Browser token lifetime5 to 3,600 seconds, default 900
History page (?limit=)1 to 500 messages, default 50

Schedules, channels and webhooks

LimitValue
Schedules per agent100, at most a year ahead
Repeating schedulesAt least 60 seconds apart
Channel sendersperSenderPerMinute 1 to 600 (default 10), turnsPerDay 1 to 1,000,000 (default 1,000); allow at most 1,000 senders
Channel daily turnsCount messages, and turns you start through the API or a schedule, since those also post
Channel attachments10 files a message, 25 MiB each, 100 MiB in all
Camel Discord servers10 per account, or 1 on free credit
A Camel Discord serverperSenderPerMinute 1 to 100 (default 5), turnsPerDay 1 to 10,000 (default 100; at most 500 on free credit); no schedule builtin
Webhook endpoints16 per account
A webhook delivery10 seconds to answer; retried for up to 3 days

Trace export

LimitValue
Endpoints1 per account (PUT /v1/telemetry), OTLP/HTTP only (protobuf or JSON)
Headers16, each value at most 4,096 characters
Spans waiting to be sent5,000 per account per node; more are dropped
An export requestAt most 512 spans; 10 seconds to answer; 5 attempts
A content attribute (with include.content)16,384 characters, then cut

Spending

LimitValue
An agent's spend limitNew prompts are refused, and a running turn stops after the response that crossed it
An account's monthly cap402 for new runs once reached
Prepaid credit402 at a zero balance. Free credit allows $1 of usage per hour