Reference

Wire endpoints

For a controller not written in Python. deploy and connect reach the gateway; /act reaches the worker directly.

SDK → gateway. Registers a policy from its spec (image, weights, resources, autoscaler). Returns 202 building; poll GET /v1/deployments/{id} until ready.

Client → gateway, once. Admits the call and ensures a worker is up; returns worker_url, cert_fingerprint, direct_secret and a lease. A cold worker answers 503 with Retry-After while it boots.

Client → worker, directly — the gateway is not in this path. Runs inference and returns an action_chunk. A 401 (rotated secret) or lease expiry sends the client back to connect to fetch fresh coordinates.

Client → gateway, under your API key. The read-only status of the account the key belongs to: balance (money left — the platform is prepaid; an account with a contracted credit line also gets credit_limit_usd and spendable, the two together), usage (active policies and benchmarks) and limits (the per-account caps that are configured). Creating keys and topping up stay in the console.

import sequence_ai

acct = sequence_ai.account()
acct["balance"]["balance"]   # USD left on the prepaid account
acct["usage"]                  # {"policies": 1, "benchmarks": 0}

Client → gateway, under your API key. Your GPU card-hours per hour or day: from and to (ISO dates or times; the last 24 hours by default, at most 90 days), by (hour up to a week, day beyond, unless given), tz (an IANA zone the buckets start in, UTC by default) and group (none, kind, deployment or gpu). The answer has total_card_hours, total_usd and one entry per bucket and group in buckets: start, group, card_hours, cost_usd and the deployments that ran. seq usage prints it.

Client → gateway, under a full key of the account (a robot’s act key is refused). One row per robot — per API key: name, last_four, role, state (acting, connected, queued, offline, revoked), deployment, version, last_seen, requests_1h, errors_1h, p50_ms, p95_ms, labeled_24h, success_rate_7d — in data, with total; limit and offset page it. GET /v1/robots/{name}?hours=6 adds the robot’s latency per minute (latency), its time budget (budget_ms, from chunk_frames and control_hz), its sessions and labeled episodes; GET /v1/robots/{name}/logs its lines; GET /v1/fleet the robots by state and each deployment’s workers, robots and queued.

Official templates

The templates are in the model library: the physical AI templates and the benchmark templates. seq init <template> [dir] writes one into a folder of your own, from the platform; seq init --list is the live list, and each template’s README says how to use it. A policy template deploys as your own policy (seq deploy), a benchmark registers as your own benchmark, and an adapter registers as your own adapter, named in an eval with --adapter.

The seq CLI

Secrets (BYOK)

Store a credential once by name and refer to it from a policy by that name; the value never enters your code, your logs, or any output. A secret is one name bound to a set of environment variables.

seq secret set hf         --env HF_TOKEN            # private hf:// weights (and your policy's own use)

# there is no --value flag: pipe it in, or type it at the hidden prompt
printf '%s' "$HF_TOKEN" | seq secret set hf --env HF_TOKEN

seq secret ls                                       # names + env-var NAMES + timestamps; the value is never shown

There is no command that reads a stored value back — a secret is write-only, and re-running set rotates the whole bundle. Use it from a policy by name:

@seq.policy(gpu="L4", max_gpus=1, secrets=[seq.Secret.from_name("hf")])
class MyPolicy(seq.Policy):
    ...

Error codes

Every response that is not 2xx carries one JSON body: detail (a sentence), code, retryable, retry_after_s, request_id, hint and details. Switch on code rather than the status, and quote request_id when you report a problem — it is also in the X-Seq-Request-Id header. 429 and 503 send Retry-After too.

Errors in Python

In Python each code above is one exception class — the Python exception column — all inheriting SequencesError: switch on .code, show .hint, quote .request_id. Unavailable carries .warming and .retry_after_s; Gone carries .replacement; a policy that raised comes back as PolicyError with .remote_traceback, or as the built-in exception itself (ValueError, …). ChunkExhausted is local: an action asked for with an empty buffer and no observation. A failed seq command prints error[<code>]: … and exits with the number in the last column, so a script can tell retry (7) from give up.

Set SEQUENCES_API_KEY in the environment, or pass api_key= to connect(). Create a key in the console; browse models in the model library.

Keys

There are two kinds of key, and a robot never needs the first:

A policy declares the models it calls while it runs with models=; seq deploy refuses a name the catalogue does not have. There is nothing else to set up: each time a robot connects, and while it keeps its lease, the platform hands the policy’s worker a short-lived credential for exactly those models as SEQUENCES_API_KEY, so the policy’s own chat() and decide() calls work and no key is stored on the worker. The calls are billed to your account under the key the robot connected with — when several robots share one worker, the one that connected or renewed last. Ten minutes after the last robot leaves, the credential lapses; a call then is refused, and the robot that connects next gets a fresh one. A SEQUENCES_API_KEY you give the policy yourself, as a secret, is used instead.

import sequence_ai, seq

@seq.policy(gpu="L4", max_gpus=1, weights=seq.Weights.template("pi05-droid", version=1),
            models=["qwen3-8-27b"])
class PlannedPolicy(seq.Policy):
    @seq.plan(every_s=2.0)
    def plan(self, obs):
        r = sequence_ai.chat("qwen3-8-27b", [{"role": "user", "content": [
            sequence_ai.image(obs.images[0].data), {"type": "text", "text": "Next step, in one sentence?"}]}],
            max_tokens=100, reasoning={"effort": "none"})
        return r.content