Skip to content
Skip to content

Compute request and transfer limits

The size, batch, file and pagination limits that apply to a request, and what to check before you retry a rejected one.

Updated

Identify the limit family that applies before sizing a request: JSON and pagination, batch and input, artifact transfer, or quote. Every request must fit all of its applicable limits. The tightest account, workflow, job, operation, and schema boundary wins. A valid field value does not guarantee available capacity, an accepted quote, or permission to run.

The Kit can prepare a request within these bounds, but preparation does not transfer data, approve a quote, reserve capacity or make the work semantically suitable. Keep those decisions with the existing agent and the account's approval flow.

Which limit should I check?

A subscription limit set by another provider follows that provider's terms. It does not by itself change your Lithi account policy or the request limits below. Your Lithi account policy sets its own applicable boundaries; check the account and the response for the limit that stopped the request.

Context size is the space available to the selected model and execution profile for instructions, input and output. Per-operation limits apply to the particular request or transfer, such as its JSON body size. For example, a request can fit a model's context and still exceed the JSON byte limit. Measure the serialized request and check the selected operation before retrying.

JSON request and pagination bounds

BoundaryLimitUnit and scope
JSON request body65,536UTF-8 bytes; 64 KiB for the Compute JSON reader
JSON nesting64Container nesting depth
JSON object keys2,048Total object keys counted across the request
Idempotency-Key8–128ASCII characters
limit1–100Items requested from a paginated operation
cursor1–512ASCII characters when supplied

Use application/json and UTF-8. Duplicate object keys, trailing JSON, malformed UTF-8, and unknown fields in strict schemas are rejected. An omitted pagination cursor starts without a cursor; do not send null as a query value.

The public API accepts an idempotency key of 8–128 ASCII characters made from letters, digits, periods, underscores, colons, or hyphens. The TypeScript SDK adds a client-side rule that the first character must be a letter or digit; direct API callers follow the OpenAPI pattern. Cursor characters are letters, digits, periods, underscores, tildes, or hyphens. Return the cursor unchanged rather than constructing your own.

Batch and input bounds

Schema fieldMinimumMaximumUnit
BatchRequest.items1100,000Job requests in the array
PublicBounds.files11,000,000Files declared in the input bounds
PublicBounds.ciphertext_bytes110,485,760,000Ciphertext bytes
PublicBounds.estimated_input_tokens1131,072Estimated input tokens
LithiJobV1.contract.max_output_tokens132,768Requested output-token ceiling

The batch array ceiling does not override the JSON byte or key-count ceilings. A batch with far fewer than 100,000 entries can exceed 65,536 bytes. Measure the serialized request, including its metadata, rather than assuming that array length alone makes it valid. Do not split or rotate credentials to evade a limit.

The public job route uses LiveBoundedLithiJobV1, which applies the 10,485,760,000-byte ciphertext ceiling to the job's input bounds. A broader reusable contract must not be used to bypass this route-specific bound.

These are schema ceilings, not a supported context window for every model. The selected operation and execution profile can impose tighter input, output and combined limits. Count required instructions, schema and context as well as source text. Do not advertise the generic 131,072-input or 32,768-output fields as a model's measured capacity.

Lithi handles execution partitioning after admission. Do not remove required evidence, invent a larger profile or alter the declared byte count to make a request fit.

Artifact transfer bounds

FieldMinimumMaximumUnit
ArtifactPrepareRequest.ciphertext_bytes110,485,760,000Ciphertext bytes
ArtifactPrepareRequest.chunk_count110,000Chunks
ArtifactPrepareProjection.chunk_size11,048,576Bytes per chunk; at most 1 MiB
ArtifactPrepareProjection.max_chunks110,000Chunks permitted by the preparation response

Use the chunk size, chunk allowance and expiry returned for the actual upload. The JSON request carries metadata; the artifact bytes are not an inline JSON body. Ten thousand 1-MiB chunks total 10,485,760,000 bytes, not 10 GiB.

Do not infer upload completion from preparation. Preserve the upload identifier and verify completion through the artifact flow. Expired transfer authority requires recovery for the existing upload, not repeated use of the expired authorization.

Quote bounds and units

QuoteRequest fieldMinimumMaximumUnit
maximum_charge_micro_usd01,000,000,000,000Millionths of a US dollar
expires_in_seconds3086,400Seconds
capacity.max_replicas164Replicas
capacity.max_cold_model_downloads016Model downloads
capacity.max_wait_seconds1604,800Seconds

One million micro-USD equals one US dollar. The schema maximum for maximum_charge_micro_usd is not your account balance, credit line or approved spend. A zero ceiling does not promise free work.

Quote expiry, maximum wait and execution.deadline_at are different fields. Preserve each field's meaning; increasing one does not silently extend another. A signed quote still requires the applicable approval and admission checks.

Recover from a limit refusal

A JSON body that exceeds the byte cap maps to HTTP 413 with PAYLOAD_TOO_LARGE. Invalid bounds, pagination, keys or strict fields map to HTTP 400 with INVALID_REQUEST. An unacceptable media type maps to HTTP 415 with UNSUPPORTED_MEDIA_TYPE.

Correct those requests before retrying. Replaying unchanged invalid bytes cannot fix their size or schema. Preserve the original job identity when a prior submission has an uncertain outcome.

For HTTP 429 with RATE_LIMITED, respect Retry-After when the response supplies it. Do not treat a permission denial, unavailable service or budget decision as the same condition. The numeric schema ceilings above establish no universal request-per-second rate, concurrency allowance or retention period.

Use the Compute error guide for the response you actually received before changing a request or starting new work.

Was this page helpful?