Start
Overview
Author a policy as a decorated class, seq deploy it, and call it from your
control loop. Optionally author a benchmark and score a policy on it.
Install
pip install sequence-ai # Python 3.10+ for `seq`; a 3.9 robot gets the client alone export SEQUENCES_API_KEY="seq_live_..." # identifies your account: it owns your deployments
On macOS, /usr/bin/seq (a system tool that prints numbers) can come first on your PATH:
if seq deploy answers invalid floating point argument, check which seq, or run
the CLI as python -m seq … (sequence-ai 0.33.63 and later).
The rest of this page is each step in turn: author a policy, deploy it, run it, and benchmark it.
# 1 — author: one class, decorated with the GPU, image and weights it needs @seq.policy(gpu="L4", max_gpus=1, weights=seq.Weights.template("pi05-droid", version=1)) class Pi05(seq.Policy): @seq.load def load(self, weights_dir): self.model = ... @seq.infer def infer(self, obs, *, seed=None): return self.model(obs) # 2 — deploy (shell): # $ seq deploy pi05_droid:Pi05 --name my-pi05 # 3 — run: connect once, then drive the arm with sequence_ai.connect(model="my-pi05") as policy: out = policy.act("pick up the cup", observe=robot.read, act=robot.apply, max_seconds=30)
Your account
A few read-only calls tell you where you stand before you deploy or run anything. Your account — money left, what you have running, your limits and your GPUs — is read under your key; the models the platform serves and the price list are public and need none.
import sequence_ai # your account: balance, usage, limits acct = sequence_ai.account() acct["balance"]["balance"] # USD left: the platform is prepaid acct["usage"] # {"policies": 1, "benchmarks": 0} acct["limits"] # the per-account caps that are set acct["gpus"]["available"] # cards you can start now acct["compute"]["cpu_cores"] # {"used": 1.125, "limit": 64}: cores, like memory_gib and containers # public: no key needed sequence_ai.models() # the models it serves (chat, decide) and the templates sequence_ai.models(kind="model") # one kind: "model" or "template" sequence_ai.gpus() # each card's price, and CPU and memory's # your bill, per day, deployment and resource sequence_ai.billing("2026-10-01", "2026-10-31")
account() | what it holds |
|---|---|
balance | balance is the USD left (paid credit minus usage) and currency is "usd"; free_credit is this month’s free credit inside that balance: monthly_usd, used_usd, left_usd and resets_at; on an account with a contracted credit line, credit_limit_usd is the line and spendable the two together (both absent otherwise) |
usage | what you have active: policies and benchmarks |
limits | the per-account caps that are set, such as max_policies_per_user or max_gpus_per_user; a cap of null is unlimited |
gpus | your GPU limit, the cards serving, evals and build checks hold now (in_use: serving, eval, build and their total), how many are available, and the evals waiting for cards (waiting_evals); a count that could not be read is null — unknown, never “full” |
compute | the CPU cores, memory and machines your running workers, evals and build checks requested, each against your plan’s cap (cpu_cores, memory_gib, containers: {"used", "limit"}; Starter 64 cores, 256 GiB and 20 machines at once, Team four times that). A worker that would pass one is not started: the robot takes a slot on a worker already up or waits in line, and an eval waits as it does for GPUs (cpu_limit_reached, memory_limit_reached, container_limit_reached). One machine may request at most 16 cores |
The same from the shell: seq account, seq models (the platform’s models), seq gpus and
seq billing export --from 2026-10-01 --to 2026-10-31 (--csv for a spreadsheet).
The wire call is GET /v1/account. Creating keys and topping up stay in
the console.
Plans and free credit. Every account is on a plan. Starter is $0 a month with $20 of free
credit each month, up to 5 deployed policies, 8 GPUs, 5 benchmarks and 600 calls a minute. Team is $200 a month
with $100 of free credit and four times every limit; Custom is agreed per account (volume prices, a
postpaid credit line). Usage is charged at the price list on every plan. The free credit renews on the 1st of
each month (UTC) and is spent before your balance; what a month leaves unused does not carry over.
The pricing page lists each plan’s limits. Move to Team from the console’s
Billing page (Upgrade to Team, billed monthly by Stripe);
Cancel Team there keeps it to the end of the paid month. If Stripe cannot charge a renewal, Team stays while
Stripe retries, but that month’s free credit is Starter’s $20 until the payment goes through; if every retry
fails, the account moves to Starter at the end of the period.
account() shows it as balance.free_credit, and its limits under limits.
When your GPUs ran. seq usage prints your GPU card-hours (one card for one hour)
per hour over the last 24 hours, with what each hour’s machines cost (GPU, CPU and memory: what your balance
is charged for them) and the policies, evals, build checks and weight copies that ran in it.
--days 7, --from 2026-10-01 --to 2026-10-07 (at most 90 days) and --by day
change the range and the columns; --group kind, deployment or gpu splits
each column; hours are this machine’s time zone unless you pass --tz UTC (the bill’s day
starts at midnight UTC). In Python it is seq.gpu_usage(days=7, group="kind"); the console’s
Usage page draws the same numbers.
Data policy and billing
- Data policy. You set the longest captured data may be kept: no capture may keep data longer than the cap. Where workers run is not yours to set: they run wherever a card is free.
- Invoices. Every account gets a monthly invoice on the 1st: its lines, the opening and closing balance, and what is due. The console’s billing page lists them, each printable.
- Credit line. For contracted customers only (the Custom plan): we can grant a postpaid
credit line, so what the account may spend is its balance plus the line. Only such an account sees
credit_limit_usdandspendableinGET /v1/account; every other account is prepaid and sees its balance alone.