Changelog

What changed for you in each release of the Python SDK (sequence-ai, the seq CLI) and of sequence-base, the contract both it and a worker read, newest first. A change on the platform itself is listed under the SDK release it ships beside. Releases before these are not listed. Each official template’s versions are on an update page of its own, listed under Templates.

sequence-ai

0.34.31 · 2026-10-13

seq policy status says how long a start waits for the card, and the rest of the SDK says one card a deployment.

Changed

• seq gpus says a deployment runs on its one card (a list, on its first) and waits for it to come free — 10 min unless seq policy scale <name> --start-wait sets another — where it said a list is tried in order.
• seq eval --dry-run names the one card a policy’s instances run on, with no card after it, and says what a run holds as each machine on its card with a reserve (a benchmark that names several cards, on the costliest). @seq.policy without gpu= asks for the one card it runs on, and the README says a deployment’s card is one card it waits for.

Fixed

• seq policy status says how long a start waits for the deployment’s card — “a start waits up to 10 min for a free L4 (start_wait_s)”, under its GPU line. 0.34.30 read it from where the platform does not answer it, and never said it.

0.34.30 · 2026-10-13

One card a deployment: a start waits for it up to --start-wait, says which card and how long when none came free, and seq policy status names it.

Changed

• seq policy scale <name> --start-wait SECONDS (and sequence_ai.scale(start_wait_s=)): how long a robot’s start waits for the deployment’s one card to come free before it is told none did — 60 to 3600 s, 600 unless set; an amount outside them is refused before anything is sent, and seq policy scale says it back.
• A robot whose start found no free card is told which card, how long it waited and how to let it wait longer: “No L4 came free in the 10 min this robot waited; try again in a minute, or let it wait longer: seq policy scale <name> --start-wait 1200”. It used to be told to use another card or list fallbacks with gpu=[...].
• seq policy status says the one card a deployment runs on — “GPU: L4 (pi05-droid’s own) $0.96/h a worker” — and how long a start waits for it; its now: line names that card. The list of cards in the order a worker tried them, and the later cards’ prices beside the price block, are gone: a deployment waits for its card and never switches.
• policy.ready(): first_choice is always True now and first_card is card, and nothing is said on stderr of a worker on a later card. A wait_until_ready() that times out while the version prepares its quick start says so.

On the platform (from 13 October 2026)

• A robot’s start waits for its deployment’s one card for up to the deployment’s start wait (start_wait_s, 10 minutes unless set) and is then told no card came free; it no longer moves to a slower kind of start meanwhile, and a start that ends this way is not billed.
• A version is served once its quick start is ready: robots that connect while it prepares wait for it — ready() says it is preparing, with an estimate — rather than being started the slow way. A model that runs across several machines still starts cold each time.
• A new version whose quick start cannot be prepared — it fails, is interrupted, or is not ready after 90 minutes — fails as a version whose check failed does: the version before it keeps serving. When it is a deployment’s first version, the deployment is marked failed.

0.34.29 · 2026-10-13

seq policy logs --rid says where a first act’s time went — the connect, TCP, TLS, the transfer and the worker — and an unchanged official pi05-droid deployment keeps no weights of its own to bill.

Changed

• seq policy logs --rid says where an act’s time went. For the first act after a connect: the connect that handed the robot its worker, the TCP connect and TLS handshake of the connection the act opened to it, the transfer and the worker — “where it went: connect 413 ms · TCP 88 ms · TLS 176 ms · transfer 2136 ms · worker 140 ms (inference 139)”; for a later act, the transfer and the worker. seq policy logs gives the p50 of each over the first acts after a connect, those whose SDK timed the opening and those whose SDK did not said apart. A robot’s act reports carry the three timings it measures for that (connect_ms, tcp_ms, tls_ms).
• seq policy estimate says a deployed official template’s weights are not billed when it was deployed unchanged: it reads the platform’s read-only copy of them and keeps none of its own, so only its compile cache is. Before, their line was left out.

On the platform (from 13 October 2026)

• A deployment that declares more than one card runs on the first alone: a start waits for that card and never takes another. The official templates’ newest versions, on beta (pi05-droid v18 and six others), declare one card.
• A deployment of the official pi05-droid template, unchanged, reads the platform’s read-only copy of its weights instead of copying them, so it keeps no weights to bill.
• The act reports robots send keep, for the first act after a connect, its connect, TCP connect and TLS handshake, and whether an act was that first one, so seq policy logs can say them. An SDK from before this release times none of the three: its first act is said with its network, the connection’s opening in it, and an act kept before the platform said which act was first is said with its network as it is.

0.34.28 · 2026-10-13

ready() and wait_until_ready() answer for this robot — not ready while it waits in line for a slot — and the robot first in line hears of a free slot in about a second.

Changed

• ready() and wait_until_ready() answer for this robot. While its deployment holds its max_gpus with every slot taken, ready() is (False, None) though a worker is up, and wait_until_ready() waits in line, saying its place, and on its timeout says the robot had no slot. Before, a robot whose deployment was full was told ready at once and queued at its first act.
• A robot first in line for a slot asks again every second, as the platform now tells it (the others every 5 s, as before), so a slot another robot frees by closing reaches it about a second later rather than five or six. The “queued for a GPU slot” line is printed when the robot’s place changes, or every 5 s.

On the platform (from 13 October 2026)

• A worker idle past its idle_timeout is stopped as the timeout ends, and one whose robots report their acts is billed to its last act plus the timeout. Before, it ran on to the platform’s next check, up to about a minute more, and was billed for it.
• GET /v1/act/ready answers for the robot whose connect session it names: ready when a worker has a slot for it, queued with its place in line when the deployment is full. The robot first in line for a slot is told to ask again in 1 s. Without a session it answers as before.

0.34.27 · 2026-10-13

policy.ready() and seq policy status say the card a worker runs on and its price an hour, seq policy usage splits each day’s latency into inference + other, and an observation that does not match says how to fix it.

Changed

• seq policy usage splits each day’s p50 and p95 as seq policy logs and the console’s Overview do: “285 (114 + 171)”, the round trip and in brackets inference + other, with a line under the table saying what the two are; the total line gives the period’s p50 and p95 (it was empty). A day whose acts reported no inference time shows the round trip alone. Its milliseconds round halves up, as the console does.
• An observation that does not match what the deployment declares now says how to fix every kind of problem, not only a frame of the wrong size: a camera that sent no frame, a proprioception or state vector of another length, an empty instruction — each with the call that sends it, e.g. “send 7 values of proprioception.joint_positions: joints=[...] in sequence_ai.observation”. The warning, the validate="strict" refusal and sequence_ai.observation(..., contract=...) say it in the worker’s own words.
• policy.ready() says the card its worker runs on, beside (ready, eta_seconds) — still unpacked the same: card, usd_per_hour (what one worker costs an hour on it, as billed) and first_choice, False when it is not the first card of the deployment’s list (first_card names the first). A worker on a later card is said once on stderr, from ready(), wait_until_ready() or a connect.
• seq policy status says which cards the deployment’s workers run on now, each at one worker’s price an hour, and when one is not the first card of its list.

On the platform (from 13 October 2026)

• A worker that refuses an observation for not matching what the policy declares says how to fix each problem in the error’s hint, which print(e) shows: a camera that sent no frame, a vector of another length, an empty instruction, as well as a frame of the wrong size. A worker of a version built before this hints only at a frame’s size until you deploy again. Every version of sequence-ai has it.
• A ready answer and a connect say the card the worker runs on (card: its name, one worker’s price an hour on it and whether it is the first card of the deployment’s list), and the policy’s page in the console says the cards its workers run on now over its Workers list.

0.34.26 · 2026-10-13

region= is retired: workers run wherever a card is free, and a robot that reconnects asks the platform first rather than waiting on a worker that had failed.

Changed

• region= is retired: workers run wherever a card is free. @seq.policy(region=...) imports with a warning — so the code of a deployment from before still imports where it runs — and seq deploy, seq validate and seq deploy --dry-run refuse it (“@seq.policy got retired argument ‘region’: it is no longer offered - the platform runs a deployment’s workers wherever there are cards; remove it”). seq eval run --region and seq.eval(region=) are gone, and seq policy estimate and the price seq deploy prints name no region.
• After a reconnect that places the robot on no worker yet (a queue, a worker still starting, a stopped deployment), the next act asks the platform first rather than going to the worker that had failed, which may be gone by then: that act used to wait out its whole timeout, about 10 s.

On the platform (from 13 October 2026)

• A deploy, its dry run or an eval that names a region is refused with why (an SDK from before sends it), and GET /v1/pricing no longer lists region multiples. An account’s data policy sets only how long captured data may be kept; it no longer names regions.
• A worker being stopped answers an act sent meanwhile at once (“this worker is shutting down”, which every SDK answers by reconnecting) rather than once its copies of the policy have closed: an act sent as a worker’s stop began went unanswered for up to 22 s. Workers of a version deployed from 13 October 2026, 20:01 UTC have it; deploy again to give it to a version deployed before.
• A robot that reconnects while its worker is busy (a long first act) is told to retry and keeps its place on that worker, rather than being placed as a new robot: on a deployment at its max_gpus, it queued behind its own place. A robot whose worker is being stopped is placed on another at once.
• A worker started for a robot that left before the worker was up is stopped a minute after it was up and not billed. Some were never seen up, ran until their idle timeout (10 minutes by default) and were billed for it. A worker that ends before it was up is not billed.

0.34.25 · 2026-10-13

seq policy logs splits a round trip into the policy’s inference and the rest, and a worker is billed from the second it was up.

Changed

• seq policy estimate says a policy that declares no weights keeps none (“no storage for its weights: it declares none”) rather than that their size is known once it is deployed, and a size under a tenth of a GB in MB: a 5 MB compile cache read “0.0 GB”.
• seq policy logs splits the round trip its robots reported into the policy’s inference and the rest: “round trip p50 455 ms (inference 247 + other 208), p95 513 ms (inference 262 + other 251)”, the two adding up to the total as the console’s Latency cells say it. Acts that report no inference time (an older SDK’s) show no split.

On the platform (from 13 October 2026)

• A worker is billed from the second it was up. Before, its billing started when the platform first saw it up, which for a worker no robot was waiting on — one your min_workers, buffer_workers or warm schedule keeps — came up to a minute later. A worker no robot takes, which is never billed, is now stopped a minute after it was up rather than a minute after the platform saw it. A worker of a version built before this keeps the old timing until you deploy again. Every version of sequence-ai has it.

0.34.24 · 2026-10-13

What keeping a deployment costs, said where you read prices.

Changed

• seq gpus and sequence_ai.gpus() say the storage price: what a GB of a deployment’s copy of its weights, its compile cache or a volume costs a month ($0.12 today), billed every day it is kept whether or not a worker runs.
• seq policy estimate says what keeping the deployment costs in storage beside its worker time: once it has been deployed, its weights copy’s and compile cache’s sizes and what they come to a month (“its weights 12.4 GB at $0.12/GB-month: ~$1.49/month”); before, the price and what 10 GB comes to. It said only “worker time only; storage is billed as volumes”. Needs a platform that says its storage price; with an older one the line has no number.

On the platform (from 13 October 2026)

• GET /v1/pricing says the storage price as storage.usd_per_gb_month, and the Pricing page lists it beside the compute rates. The deploy docs say what keeping a deployment costs and that deleting it stops its storage billing at once (What keeping a deployment costs).
• region= is no longer offered: workers run wherever a card is free. A deploy, its dry run or an eval (seq eval run --region) that names a region is refused with why, and the price list no longer lists region multiples. An account’s data policy sets only how long captured data may be kept; it no longer names regions.

0.34.23 · 2026-10-13

seq policy logs sums up the acts your robots reported, and seq account’s balance line adds up to the cent.

Changed

• seq account says each amount of its balance line to the cent and the balance as their sum, so the three add up: a CPU worker’s hold of less than a cent read “$108.26 · $0.01 held · $108.26 available now”; it reads “$108.27 · $0.01 held · $108.26 available now”, and a hold under half a cent “under $0.01 held”. The console’s balance says them the same way.
• seq policy logs sums up the acts your robots reported under its machines: how many, over what stretch, the round trip’s p50 and p95, how many were turned away while the worker loaded, and the ones that failed by rid — the one record of a robot’s acts on a worker that writes no lines of its own (a worker started from a snapshot, of a version built before 13 October 2026). With a platform that does not say when each act came, the stretch is left out.

On the platform (from 13 October 2026)

• A worker now tells the platform when it last acted, so its idle_timeout counts from its last act whether or not a robot still holds it, as the docs say: a robot that stops acting for longer finds its next call paying the cold start. A worker of a version built before this does not tell it and keeps the rule of 0.34.20’s note: not stopped as idle while a robot holds it, at most 5 minutes after its last act. seq policy logs now also shows every act of a worker started from a snapshot, which it showed none of. Every version of sequence-ai has both.

0.34.22 · 2026-10-13

seq account says what running work holds of your balance, and seq policy source checks what it downloads against the version’s tree hash.

Changed

• seq account says what running workers and evals hold of the balance until they stop: “balance $19.73 · $0.86 held for running workers and evals until they stop · $18.86 available now”. The balance the platform reports was already less the hold, so it read below the month’s free credit with nothing saying why. Needs a platform that reports the hold; with an older one the line reads as before.
• seq policy source checks the files it unpacks against the tree hash the version recorded when it deployed — the number seq deploy prints as “tree sha256” — and says so (“tree sha256 3f2a9c1b7e44, the same as the version’s”); it stops if they differ. A version deployed before the platform recorded the hash is downloaded as before.

On the platform (from 13 October 2026)

• The console’s balance, in the left rail and on Billing, is the balance before what running workers and evals hold of it, as seq account says it; while something is held, Billing says under it and the rail’s card at its head how much, and what may be spent now. GET /v1/account says it as balance.held_usd, beside the balance, which is unchanged.

0.34.21 · 2026-10-13

A worker’s state says where it is and a sentence says why, in seq policy status and on the console alike: Failed only for one that failed.

Changed

• seq policy status says why a worker stopped when no robot took it within a minute of starting, and that nothing was billed for it; such a worker showed its state alone. The console’s Workers list says the same.

On the platform (from 13 October 2026)

• The console’s policy page said Failed of a worker that had stopped after its idle timeout, or was still starting, and counted one still starting as running. Each worker now shows its state (Running, Starting, Stopped) with why it is there, and Failed only when it failed; the workers running and starting, the Workers list and the workers on each card of the GPU list are counted from the same workers. Every version of sequence-ai has it.

0.34.20 · 2026-10-13

seq deploy uploads the folder your policy is in, whole, and says what it uploaded; seq policy source downloads the code a version runs: the files you see are the ones that run.

Changed

• seq deploy uploads the folder the entry file is in, whole — helpers, configs and third_party/ with it — and that snapshot is the version’s code; nothing of an earlier version is kept. seq deploy --entry-only uploads the entry file alone, as before, and says the folder’s other files are not in the version.
• Left out, and said: version control and caches anywhere; a virtualenv or a build’s output at the folder’s root (.venv/, venv/, env/, build/, dist/, node_modules/, *.egg-info); what a .seqignore beside the entry file lists, in gitignore’s form (! is not supported); links. A directory named build/, dist/, env/ or venv/ deeper in, such as a vendored package’s own build/, is uploaded: before, it was dropped wherever it was, unsaid.
• The deploy prints how many files it uploads, how large, and their tree sha256 — the hash the platform now keeps beside each version, on the console’s Versions too — then says whether the platform holds the same.
• A folder too large to upload names its largest paths and how to leave them out with a .seqignore.
• A path add_local_file / add_local_dir names inside the folder is the folder’s copy, uploaded once.

Added

• seq policy source <name> [--version N] [-o DIR]: the code a version runs, as it deployed it — the version serving unless --version names another — downloaded into a new folder (./<name>-v<N> unless -o names one; a folder that already holds files is refused). The platform checks it against what the version deployed before sending it. The console’s Versions has the same Download on each version.
• seq init downloads the large upstream sources a template’s image installs (LIBERO, robosuite: too large to come with its code, listed in third_party/SOURCES.json) into third_party/, checked against their packages’ sha256; seq init --no-source leaves them out. seq deploy leaves one as published out of the upload (the image installs the same package) and refuses one you changed: a large upstream runs as published for now.
• seq.source.tree_sha256(directory): the tree sha256 of a folder, as seq deploy prints it and the platform keeps it.

On the platform (from 13 October 2026)

• A worker a robot was acting on was stopped as idle in the middle of its session when the deployment’s idle_timeout was under about 4.5 minutes: a robot’s acts go to its worker directly, and only its connect and its lease renewals counted as use. A worker a robot holds is no longer stopped as idle: it stays until the robot closes (policy.close(), or the end of its with block) or, when it stops acting without closing, until its lease lapses, at most 5 minutes after its last act. Every version of sequence-ai has it.

0.34.19 · 2026-10-13

Pillow comes with sequence-ai: pip install -U sequence-ai is all a robot needs to fit and encode its camera frames.

Changed

• Pillow is a dependency. Since 0.34.12 the robot fits each frame itself (Policy.prepare_image, resize_image, and encode of an array or a PIL image), which needed the [image] extra as well; pip install -U sequence-ai now brings it. sequence-ai[image] still installs, and adds nothing more. A robot whose environment pins Pillow below 10 has it upgraded.

0.34.18 · 2026-10-13

seq usage says what its dollars cover, seq audit the template versions an upgrade moved between, seq policy logs a machine whose stop was not recorded, and seq init which sequence-ai asks, so the platform can tell an older one which sequence-ai a template version needs.

Fixed

• seq usage --group kind counted a deploy’s checks as evals, on accounts that never ran one. They are build checks.
• The dollars in seq usage were what the GPU cost alone, so they did not add up to what your balance was charged once CPU and memory are billed apart. Each bucket’s dollars are now everything its machines cost: GPU, CPU and memory. Card-hours still count GPU cards.

Changed

• seq policy logs says “stop not recorded” for a machine that ended before the platform recorded each machine’s stop, where it left the stop blank and the machine read as still running — as the console’s Logs tab says it. Needs a platform that says which machines those are; with an older one the machines print as before.
• seq audit says under each upgrade the template versions it moved between, “v14 → v15”. A dry run changes nothing, and the platform no longer writes it to the audit trail; one written before reads “dry run · to v15”.
• seq usage says what its dollars cover (“$0.25 (GPU, CPU and memory)”), and its summary line gives each group’s dollars beside its card-hours (“by machines: policy workers 0.356 ($0.00) · build checks 0.159 ($0.24)”).
• seq usage --group kind names a fourth kind, weight copies: the machine that copies a version’s weights before its check, which uses CPU and memory but no GPU. A split row that cost something without a card, such as this or a CPU policy, is now shown, so the rows add up to the total.
• seq init and seq init --list say which sequence-ai asks, so the platform can answer a template version this SDK is too old to read with the version it needs — “toy-benchmark v4 needs sequence-ai 0.34.17 or later: pip install -U sequence-ai” — instead of handing over files that then fail to import without saying why. An earlier sequence-ai says no version, and is told to upgrade for a version that needs 0.34.17 or later.

On the platform (from 13 October 2026)

• The two fixes above are in what the platform returns, so every version of seq usage, seq.gpu_usage() and the console’s Usage page shows build checks as build checks and the full cost. With --group gpu, a machine with no card reads CPU.

0.34.17 · 2026-10-13

An image can install from an official template version’s frozen files, which the platform keeps.

Added

• seq.Image.template_files(template, version): each run_commands step after it reads that official template version’s frozen build files at /seq/frozen, read-only, while the image builds — its sources at their pinned commits, every Python and system package its image installs, the assets it downloads — so the image builds the same whether or not the sites they came from still serve them. Nothing of them stays in the image unless a step copies or installs it. One template version an image; a bad name or version is refused when the file is read.
• Requires sequence-base>=0.4.3 (contract 0.5.3), so pip install -U sequence-ai brings it.

Changed

• seq policy ls and seq policy versions say when a version started waiting for its quick start on this machine’s clock with its zone’s name, as every time the CLI prints (“started 18:22 EDT”); they said it in UTC.
• A policy class in a module that cannot be imported is refused with “the platform cannot load it”.

0.34.16 · 2026-10-13

seq policy says what a redeploy would bring the version that serves, and upgrade --help says what --to takes.

Changed

• seq policy upgrade --help and seq benchmark upgrade --help say that --to vN names any published version of the template: a beta one to try it, or an earlier one to go back. It always took one; the help named only the earlier.

Added

• seq policy ls, seq policy versions and seq policy status say what a redeploy would bring the version that serves, when its workers do not make a check that applies to it yet — each said as the stricter check it is: “after a redeploy its workers refuse a frame that is not the size its camera declares”, or an /act parameter its type cannot carry. Nothing is printed for a version that makes them, or by a platform that does not say it.

0.34.15 · 2026-10-12

A deployment or benchmark made from an official template says which version of the template it runs, and moves to a newer one with one command. A new version of a deployment keeps the deployment’s scaling.

Added

• seq policy upgrade <name> and seq benchmark upgrade <name> move a deployment or benchmark made from a template to the template’s newer version, or to the one --to vN names. A deployment’s new version builds beside the one that serves and takes over when it is ready; the one serving now is kept, so seq policy rollback goes back. What you changed of the old version stays yours: your own checkpoint, cards, CPU or memory. Before anything is built it prints what changes (for pi05-droid v14: “policy.action.bounds: none → [-1, 1] ×7, [0, 1]”), what stays, and one worker’s price an hour before and after. --dry-run prints the same and deploys nothing. A policy’s page in the console has the same Upgrade.
• seq policy status and seq policy versions name the template version each version runs (“template pi05-droid v13”), and the newer stable version with what it brings and the command that moves to it. seq policy ls and seq benchmark ls say when one is available.

Changed

• A new version of a deployment that runs keeps the deployment’s scaling: its GPU cap, warm floor, buffer, idle timeout and queueing as they are when the new version takes over. seq deploy sets only what its flags name (--max-gpus) and says what it kept where the file says otherwise: “kept mypi05’s max_gpus 8 (the file says 1) - change it with seq policy scale mypi05 --max-gpus N”. A template’s policy.py says max_gpus=1; before, deploying it again lowered a cap of 8 to 1 without a word. Change the scaling with seq policy scale.
• seq deploy --dry-run says what the deployment does to each action step where it declares it - the bounds it clips into, the most a step may change, the dimensions the robot is given as 0 or 1 (“binarize dim 7 at 0.5”) - and how each camera’s frames are to be fitted to its size (“exterior_1 224x224 (pad · bilinear)”), or that the robot fits them itself with resize_image.

0.34.14 · 2026-10-12

A camera frame that is not the size its camera declares is refused before sending only when the deployment's version refuses it too.

Fixed

• 0.34.12 and 0.34.13 counted such a frame as refused for every deployment. A version built before the platform checked frame sizes passes the frame to its policy as it is, so the default warning said “the call will fail” when it would not, and connect(..., validate="strict") refused, on the robot, frames that version accepts. Now the check follows the version: one built since the platform checks frame sizes is refused before sending, as before; for any other the warning says that it passes the frame on and that deploying it again makes it refuse such frames, and strict lets the frame go. A version the platform says nothing about is treated the same way.

Added

• policy.contract["checks"]: what the version the connection reached refuses beyond the shape it declares — "frame_sizes" for a camera frame of another size — or None when the platform does not say. sequence_ai.act.contract_problems(declared, observation, checks) takes the same list.

0.34.13 · 2026-10-12

A new version of a deployment that already serves takes over once its quick start is ready, and the CLI says so while it waits.

Changed

• seq deploy, seq policy status, seq policy ls and seq policy versions say when a new version has passed its check and waits for its quick start: “v2 passed its check; it takes over once its quick start is ready (started 22:22 UTC) - v1 serves until then”. Robots go on to the version that serves until then, 30 minutes at most. seq deploy used to say the version that still served “is deployed”.
• seq policy rollback says which version it dropped. A rollback now drops a version still building or waiting for its quick start — “v3 was waiting for its quick start; dropped - deploy again to try it again” — where a version still building refused the rollback, and one waiting took over afterwards.

0.34.12 · 2026-10-12

Camera frames are fitted on the robot, by tools you call. Nothing in the SDK resizes a frame behind your back, and a worker built on contract 0.5.2 only checks that each frame is the size its camera declares.

Changed

• sequence_ai.encode() sends a frame at its own size. Until 0.34.12 it scaled a frame whose long edge was over 640 px down to 640, and the policy resized it again on the worker. Fit frames with resize_image or Policy.prepare_image before encoding them.
• Requires sequence-base>=0.4.2 (contract 0.5.2), so pip install -U sequence-ai brings it too.

Added

• sequence_ai.resize_image(frame, width, height, *, mode, filter): fits a camera frame to a size on the robot. mode="pad" keeps the aspect ratio and pads the rest black, centred (openpi’s resize_with_pad, byte for byte); mode="stretch" fills the box. filter is one of nearest, box, bilinear, hamming, bicubic, lanczos. Both are required: they are how the policy was trained. Takes a PIL image, encoded JPEG or PNG bytes, base64 text, or an HxWx3 uint8 array.
• Policy.prepare_image(view, frame): fits a frame the way the deployment declares for that camera (width, height, resize, filter) and encodes it. It connects on first use. A camera the deployment does not declare, or declares without resize and filter (a template version from before contract 0.5.2), is refused with the resize_image call to make instead; nothing is guessed.
• Policy.to_command(step) and Policy.to_commands(chunk): the command a robot runs. Each value is clipped into the deployment’s bounds, then each dimension its binarize names is set to 1.0 above the threshold and 0.0 otherwise (a DROID gripper is {7: 0.5}). predict() still returns the model’s own numbers; run() and next_action() still clip into the bounds and do not binarize, so pass their step through to_command.
• sequence_ai.image_size(data): a frame’s width and height, read from its JPEG or PNG header.
• observation(contract=...), and the check a Policy makes before sending, refuse a frame that is not its camera’s width x height, in the worker’s own words and with the call that fits it.
• seq validate / seq deploy: a policy file that declares a contract field your sequence-base does not know says to run pip install -U sequence-ai.

On the platform (deployments built from 12 October 2026, contract 0.5.2)

• A colour frame of a camera the deployment declares that is not the camera’s width x height is refused with 400 invalid_request. details.sizes lists each frame’s view, index, the size its camera reads and the size it is, and hint names the call that fits it. The worker never resizes a frame. A deployment built before keeps accepting any size until it is deployed again.
• A frame of a declared camera whose data is not a JPEG or PNG image (a URL, for one) is refused the same way.
• An /v1/act request over the size limit (413 payload_too_large) says to fit camera frames before sending.

Unchanged

• sequence_ai.image() for chat still scales an array or a PIL image down to 640 px on its long edge: a chat image goes to a language model, which has its own size limits.

0.34.11 · 2026-10-12

• seq account names the cards a deploy’s build check holds beside serving and evals — “in use 1 (serving 0, evals 0, build checks 1)” — so the parts add up to what is in use. A GPU shortfall names them too, and says to wait for the check.

0.34.10 · 2026-10-12

• seq audit writes a billing line’s amounts in dollars, “$0.42 → $0.00” where it printed “0.422416 → 0”, and a plan’s change from the plan before it, “free → pro” — as the console’s Audit page says them.

sequence-base

0.4.3 · 2026-10-13 · contract 0.5.3

An image can install from an official template version’s frozen files, which the platform keeps, instead of from the sites they came from.

Added

• ImageStepTemplateFiles ({"template_files": {"template": "<name>", "version": <n>}}, the shape TemplateFiles) and FROZEN_PATH (/seq/frozen): each run_commands step after it reads that template version’s frozen build files — its sources, Python and system packages, assets — read-only at /seq/frozen while the image builds. sequence-ai’s seq.Image.template_files writes it. One an image. A gateway or worker on contract 0.5.2 refuses an image that has it, so the platform takes it before the SDK sends it.

0.4.2 · 2026-10-12 · contract 0.5.2

The robot fits its camera frames with an explicit tool, and a worker only checks a declared camera’s size.

Added

• Camera.resize ("pad" or "stretch") and Camera.filter (nearest, box, bilinear, hamming, bicubic, lanczos): how the policy was trained to see a frame fitted to the camera’s width x height. sequence-ai’s Policy.prepare_image reads them. Optional; unset, they stay off the wire, so a gateway or worker on contract 0.5.1 reads a contract that does not use them.
• ActionContract.binarize ({dimension: threshold}): the dimensions a robot reads as off or on. sequence-ai’s Policy.to_command reads it. Dimensions must be within action_dim, thresholds finite.
• codec.resize_image(frame, width, height, *, mode, filter): "pad" is openpi’s resize_with_pad, byte for byte. mode and filter have no default.
• codec.image_size(data): a frame’s width and height from its JPEG or PNG header, without Pillow.
• frame_size_problem, fit_hint and PAYLOAD_HINT (in sequence_base.contract.io): the words a worker and the SDK use for a frame that does not fit its camera.

Changed

• codec.encode sends a frame at its own size; it no longer scales a frame whose long edge is over 640 px down.
• A declared camera’s width x height is what a worker on contract 0.5.2 checks each colour frame against.

Templates

Each official template has an update page of its own: every version published, newest first, with what it changed, what it needs and how to start from it or move to it. A deployment or benchmark made from a template names the version it runs, and seq policy upgrade or seq benchmark upgrade moves it to another; every template’s update page.

• π0.5 DROID (pi05-droid): stable v14, beta v18
• π0.5 LIBERO (pi05-libero): stable v13, beta v14
• GR00T N1.7 DROID (gr00t-droid): stable v3, beta v7
• Cosmos 3 Edge DROID (cosmos-droid): stable v3, beta v7
• π0.5 DROID + Qwen planner (pi05-droid-qwen): stable v10, beta v14
• π0.5 RoboCasa (pi05-robocasa): stable v7, beta v8
• π0.5 RoboTwin (pi05-robotwin): stable v6, beta v7
• LIBERO (libero): stable v7, beta v7
• RoboCasa365 (robocasa): stable v6, beta v7
• RoboTwin 2.0 (robotwin): stable v6, beta v8