Rate limits. A request must fit every level; the buckets refill continuously (token bucket).

static       600/min per address, burst 100
             cacheable data: documentation, reference tables, rates, holidays, feeds, current time
light        120/min per address, burst 30
             light computations: conversion, validation, dates, encodings, text, networks, geometry
heavy        20/min per address, burst 5
             heavy computations: arbitrary precision, factorisation, regular expressions, schema validation, diff
uncacheable  60/min per address, burst 15
             random values and self-diagnosis
diagnostic   10/min per address, burst 3
             controlled test responses: status, delay, size, broken encodings

Wider keys, so that a shared address or a whole agent farm does not hit the ceiling:
  per IP address: 1x the numbers above
  per IPv4 /24 or IPv6 /64: 20x the numbers above
  per autonomous system: 200x the numbers above

Daily ceiling: 50000 requests per address per UTC day. It exists to catch a client stuck in a loop, not as a defence against deliberate abuse: that is what the per-minute limits and the flood guard in front are for.
Concurrent requests per address: 20.
An address refused more than 120 times within 10 minutes is paused for 60 minutes; the answer stays 429 with Retry-After, never 403.
The proxy in front adds a flood guard of 1200 requests per minute per address.
Availability: Addresses registered in Belarus (BY), Russian Federation (RU), Ukraine (UA) receive 451 Unavailable For Legal Reasons, with an explanation in the body. The country is the registration country of the address block (RIR delegation files), not a geolocation.

Which class an endpoint belongs to: x-cost in /openapi.json, and the endpoint list in /agents.md.

Every response carries the current state:
  RateLimit-Limit      sustained requests per minute for this class at your address
  RateLimit-Remaining  requests you can make right now without waiting
  RateLimit-Reset      seconds until the allowance is full again
  RateLimit-Policy     limit;w=60;burst=N

When limited: status 429, header Retry-After, and the same number in the body. 403 is never used for rate limiting.

Input caps. Exceeding one returns 400 naming the parameter and the cap, never a truncated answer:
  URL (path and query)                 2048 bytes; /probe/urllen accepts up to 16000 and reports what arrived
  one parameter (path or query)        1024 bytes
  query parameters per request         20
  request headers                      8192 bytes
  request body                         not accepted (every operation is a GET)
  response body                        1048576 bytes
  expression (/calc)                   256 characters, 256 tokens, nesting 100
  digits of any result                 100000; the size of a power or factorial is estimated first, and an oversized one is refused without computing it
  factorial                            n <= 10000
  values in a list parameter           10000
  iterations of an input-driven loop   1000000
  JSON                                 262144 bytes, depth 64, strict parser (no NaN, no Infinity, no duplicate keys)
  YAML                                 65536 bytes, depth 32, at most 100000 nodes after aliases, safe loader only
  CSV                                  262144 bytes, 10000 rows, 200 columns
  regular expression                   pattern 256 characters, text 4096 bytes, 100 ms, RE2 engine (no backtracking)
  encoded input (base64, hex, base58)  262144 bytes
  diff                                 65536 bytes for both texts together
  /delay/{seconds}                     10 seconds, 2 delayed responses in progress per address
  /size/{bytes}                        1048576 bytes
  items in a random list               1000
  cron and rrule occurrences           100

Time budget:
  soft timeout of a handler            250 ms, then 503 with Retry-After while the computation finishes
  hard timeout of a computation        1 s, then the worker is killed and the answer is 400
  CPU per computation inside a worker  2 s (RLIMIT_CPU)
  memory per worker                    256 MB (RLIMIT_AS)
  keep-alive idle                      15 s
  request headers must arrive within   5 s
  repeated failures on one input       3 within 60 s block that input for 60 minutes

Capacity. For heavy computations this, not the rate limit, is what you will meet first:
  worker processes for heavy computations           1
  heavy computations in progress or waiting         16; above that the answer is 503 with Retry-After, immediately
  threads for everything else                       16
  requests in progress or waiting in those threads  48; above that the answer is 503 with Retry-After, immediately
  effective ceiling for heavy work                  about 1 CPU-seconds per second; the rate limit allows more than that, so the queue is what actually limits it

Cache-Control by class of answer (the same answer is served from cache rather than computed again):
  immutable  public, max-age=31536000, immutable
             deterministic computations: arithmetic, conversion, validation, encodings
  reference  public, max-age=86400
             static reference tables and computations that depend on them (timezone rules, registries)
  daily      public, max-age=3600
             data with a daily cycle: currency rates, holidays
  feed       public, max-age=300
             fast feeds: earthquakes, space weather
  live       no-store
             current time and other values that change every second
  random     no-store, private
             random output
  private    no-store, private
             self-diagnosis: the answer describes the requesting client
  docs       public, max-age=300
             documentation
  no-store   no-store
             errors and controlled test responses
# type: computed