Docs

Changelog, 2026-10-21 to 2026-10-31

What changed for you in the releases of the Python SDK (sequence-ai, the seq CLI) and of sequence-base from 2026-10-21 to 2026-10-31, newest first. Every release since is on the changelog, and those from 2026-10-12 to 2026-10-20 are on the page before this one.

sequence-ai

0.54.1 · 2026-10-31

A robot can connect through a planner, a new version’s check machine stays on as its first worker, and deploys are faster; 0.54.0 and older are refused, so upgrade with pip install -U sequence-ai.

Added

  • sequence_ai.connect("<planner>", policy="<policy>") connects a robot through a planner, which reads its prompts and tells its policy what to do; act() raises WaitingForPlan until the first plan.

Changed

  • A new version’s check machine stays on as its first worker, so its first robot’s acts are warm, and stops after its idle time with no robot connected.
  • A version whose weights did not change reuses its earlier version’s copy and saves only what changed in its image, and weights="hf://org/repo@<rev>/<path>" copies only that folder or file.

0.54.0 · 2026-10-30

A robot now talks to its policy over one stream only, and seq deploy --dry-run tells you when a policy may not fit in the memory it asks for.

Changed

  • A robot’s observations, acts and episode ends all go to its worker over one stream; the request-by-request path is gone. When something between the robot and the platform blocks WebSocket, connect() says so and what to allow. An older SDK is refused with a message to upgrade, and a policy deployed before this release is told to deploy again.

Added

  • seq deploy --dry-run warns when a policy’s memory= is smaller than its weights, before the deploy rather than at load.

0.53.1 · 2026-10-30

Stopping a robot or taking it over now covers the act on its way, an eval’s report says when its machines were reclaimed, and the messages about your robot say what actually happened.

Added

  • seq eval report says how many of an eval’s machines were reclaimed mid-run and started again, and how many episodes ran again; the lost part is not charged.

Fixed

  • A robot stopped or taken over while an act is on its way is handed its hold or the person’s chunk, never the policy’s answer, and on_resume waits until the arm has something to play; a console also reaches a robot that starts observing right after connect(teleop=True).
  • A robot’s notices and seq robot status say what happened: no notice when it gave its seat back itself to connect again or in wait_until_ready(), whose next poll seats it again; no lost keepalive blamed while the platform hears it; a far robot told to move hears why, not that its worker is leaving; and the stretches with nothing to play that already ended are counted apart from the one under way.

0.53.0 · 2026-10-30

The platform now hears your robot between acts, tells your code the moment the arm has nothing left to play, and shows how each robot’s connection is doing.

Added

  • A Policy sends its worker a heartbeat from its first observe() or act() on, so the platform can tell a robot that is alive from one whose loop is stuck; connect(on_stale=, on_resume=) calls your code when the arm runs out of valid answers to play and again when it has one.
  • seq robot status shows each connection’s link - its round trip and upload time as its worker measured them - and seq policy status its robots’ connects of the last day: how many, how fast to the first answer, and where the others stopped.
  • seq models shows each model’s context and the inputs it takes, seq eval ls --adapter NAME[@vN] --status STATE lists an adapter’s evals in one state, and the seq.*_logs functions take since=0 as the log’s start.

0.52.1 · 2026-10-29

The CLI shows times in your account’s time zone and clock, says what the platform did when you sign in or out, and checks that a robot key’s limit and expiry took.

Fixed

  • seq account set --time-zone/--clock sets the times every seq command prints, not only the console’s; seq logout and a new seq login end your old sign-in on the platform or say they could not, and the sign-in and payment links print before a browser opens - none opens over SSH.
  • seq robot add --limit/--expires checks the key came back with them, seq robot set --limit 0 is refused (none lifts a limit), seq billing top-up waits for its own payment, and a command the platform does not take yet says so rather than “Method Not Allowed”.
  • A robot already connected gets its standby within a minute once its deployment keeps a spare worker, and wait_until_ready() waits on through a ready poll the platform did not answer in time; seq writes each line as it prints it in a script or a pipe, and a chat answer spent on reasoning alone warns why it is empty; seq policy ls shows dev or production, seq account its id and seq eval ls --adapter NAME@vN one version’s evals; and the seq.*_logs functions take a time as epoch seconds or a datetime.

0.52.0 · 2026-10-28

Sign in with seq login and do from the command line what the console’s pages do; an eval’s replays open in a 3D player on your own machine.

Added

  • seq login, seq key, seq billing and seq account do what the console’s Keys, Billing and Account pages do - a promotion code too, with seq billing redeem CODE; a robot key takes an expiry and a spending limit (seq robot add --expires/--limit, seq robot set), seq robot status and seq planner ls|status show what the Machines page shows, and every log pages back with --before - each with its seq.* function.
  • seq eval replay EVAL_ID|FILE opens an eval’s replays in the console’s 3D player on your own machine - turn, zoom and scrub - and seq.read_replay(path) reads a replay file as arrays.

Fixed

  • A robot whose worker is lost goes on with its episode on its standby; seq policy status says why a worker of your warm hours, your minimum or a spare runs and stopped, seq policy rm names each key it stops by its kind, and seq --json eval cancel prints the platform’s answer.

0.51.11 · 2026-10-28

A robot says where its worker runs and why, and seq usage and seq eval report show how each robot’s link went.

Added

  • When a robot connects or moves to another worker, it says which of our regions that worker runs in, and about how far away it is when it is far; seq policy status says under each robot why it sits on its worker.
  • seq usage --policy lists each robot by the key it connects with - its acts, errors, round trips and on-time - and seq eval report shows the link between the benchmark’s and the policy’s machines.

Fixed

  • A run a robot leaves open when its process exits still ends, so seq usage shows its on-time; a read told to wait (429) tries again as asked, up to three times; and timing reports go every 5 s, so they no longer use up the key’s requests per minute.

0.51.10 · 2026-10-28

A teleoperated robot’s audit says who drove it.

Fixed

  • seq audit names the operator of a teleop session beside its robot key, and sequence_ai.teleop() sends its operator when it connects.
  • sequence_ai.teleop() needs no robot=: the key already names its robot.

0.51.9 · 2026-10-27

seq policy status counts the workers running or starting, and says when a spare worker was stopped at no cost to you.

Fixed

  • seq policy status’s fleet line counts only the workers running or starting; a stopped one is still listed below with why it stopped.
  • A second worker started for the same place is stopped and not billed, and seq policy status says so.

0.51.8 · 2026-10-27

A robot that reconnects keeps its episode, and robots move to a new version sooner.

Fixed

  • A robot that reconnects to the worker it was on keeps its episode: its acts no longer stop for up to a minute after its connection drops.
  • A robot moves to a new version, or back to an earlier one in a rollback, about two seconds sooner: as soon as its worker says it is leaving.
  • seq robot revoke <id> names the revoked key by its own last four characters, and help(seq.planner) shows the sample a planner’s build checks.

0.51.7 · 2026-10-27

A person can watch a robot and drive it from a console of their own, and you can see, download and delete what you store.

Added

  • sequence_ai.teleop(policy, robot=..., key=...) watches a robot’s cameras, takes it over, sends it actions, stops it and hands it back to its policy; a robot that connect(teleop=True) takes them, and seq.ask_human(reason=...) lets a planner ask a person for help.
  • seq storage and seq volume files, get and rm: what you store against your plan’s limit (Starter 100 GB, Team 2 TB), and each file to download or delete.

Fixed

  • seq policy data export --format lerobot writes a dataset LeRobot reads and trains on: at the policy’s hz, with LeRobot’s column names, each frame’s task, and who drove it.

0.51.6 · 2026-10-27

A robot’s acts and observations share one connection, a policy can run in a region you choose, and robots reach a new version within seconds.

Added

  • @seq.policy(region=...) and seq deploy --region: us-west or us-east starts a policy’s workers in that region alone, a robot waiting while no card there is free; auto, the default, starts each robot’s worker in the region nearest it.

Changed

  • seq secret rm refuses a secret a deployment still uses, naming the deployment; --force deletes it, and that deployment’s workers stop serving. A secret set again reaches every worker, the ones that start later too.

Fixed

  • A @seq.policy, @seq.benchmark or @seq.adapter class written in a script run as python file.py, in a notebook or inside a function runs there as it did before the decorator; seq deploy still refuses one it cannot import, saying why.

0.51.5 · 2026-10-27

Where a class keeps its episodes follows what its methods take, as the docs say.

Changed

  • A class whose @seq.observe and @seq.infer methods both take episode keeps its episodes in episode.state, as the docs’ example does: seq deploy says they are handed to observe and infer, no longer kept on the class.
  • A class with an @seq.reset method keeps its episodes on itself even when its infer takes episode: a reset is handed nothing, so what it clears is the class’s own.

0.51.4 · 2026-10-27

A policy says how its robots play its answers with two numbers, and a copy’s robots fall into one batch when there is time to wait for them.

Changed

  • @seq.policy(action_chunk_valid_len=N, action_chunk_replan_at=k) in place of action_chunk_len and action_chunk_exec_len: an answer’s first N steps are valid, and its robot asks for the next one k steps after it sent the act, playing the rest meanwhile; the old names are refused saying the new ones. A copy seats more than one robot only when k is below N, and seq deploy says how many from the time between them.
  • --latency-ms and latency_ms= are gone: an eval asks for the next answer at step k and switches to it at step N, the world held still until it comes.
  • Requires sequence-base 0.7.0 or later.

0.51.3 · 2026-10-26

A planner is a class of its own that plans for the policies and planners it names, teams and observations= are gone, and a robot’s observations keep moving on a slow or idle line.

Added

  • @seq.planner(members=[...]) with one @seq.plan method, def plan(self, group), deployed with seq deploy as a policy is; sequence_ai.planner(name).observe(...) for what only a planner reads, such as a site’s iPad; and seq planner key add <planner> --member <name> (and list, revoke): one key for each member of a planner, a deployed member’s held by the platform.

Changed

  • @seq.team, sequence_ai.team(...), seq team key, @seq.plan on a policy, and @seq.policy(observations=...) with seq.Observations and seq.Stream are gone; each says what to write instead. Deploying needs sequence-ai 0.51.3; a robot of an older one connects and acts as before. seq robot add | list | revoke name a robot key by its policy’s tier: a robot develop key or a robot production key.

Fixed

  • A big observation on a slow line is no longer cut and sent again, a robot’s connection stays warm while it acts, the observations’ connection opens on the first observe() so the acts after it find it open, an observation’s arrays go compressed when that saves time, and an act that had to send its observations again says how long it waited. On Linux, the first large observation says once how to keep the connection’s window after a pause. A CPU worker’s estimate says it is billed from when it starts, a build error in a list names its step once, a build check that called no act says only loading was measured, and an observation past 1 MB points to sequence_ai.Video.

0.51.2 · 2026-10-26

seq benchmark ls shows the driver a benchmark runs with, an eval adds no latency unless you set one, and a robot takes its spare worker sooner.

Added

  • seq benchmark ls and seq benchmark status show the driver version of a benchmark that names one, as "L4 · driver 580.178.04".

Changed

  • An eval’s latency is 0 unless you set --latency-ms or latency_ms=; the platform estimates none.

Fixed

  • A robot whose policy keeps spare workers takes one soon after it is ready, where it could wait over a minute. An official template’s seq deploy no longer says its lock is not read, a team’s says its version, template notes read as sentences, a policy that does not batch is no longer said to serve "0 batch(es)", and seq deploy --dry-run says "kept on one copy" where it said "none kept" of an episode held on one copy.

0.51.1 · 2026-10-25

A team plans for the robots of several policies at once, a class builds itself in its constructor, and a robot’s video plays on through a lost frame.

Needs sequence-base 0.5.1 or later; pip install -U sequence-ai brings it.

Added

  • Teams: @seq.team(policies=[...]) with one @seq.plan plans for the robots of several policies, a group of them at a time; a robot joins a group with sequence_ai.team(name, group=...), and seq team key add | list | revoke issues the team key a site’s iPad observes its group with.

Changed

  • @seq.load and @seq.setup are removed: a policy loads its model and a benchmark builds its worlds in __init__, and init= hands it what the platform fills in - "{weights}", "{num_worlds}", "{policy.hz}". Each refusal writes the method as the constructor it becomes; a benchmark registered with @seq.setup is registered again with seq deploy.
  • A robot’s video reaches its policy sooner, several frames on their way at once, and a frame lost on the way no longer ends its episode: the policy reads on from the stream’s next keyframe. A robot whose policy keeps a spare worker gets it as soon as one is up.

0.51.0 · 2026-10-25

A policy declares its control loop and the batch sizes it serves, a benchmark is the environment as it is, a deployment’s settings change without a redeploy and seq deploy --dry-run --robots N prices N robots at once, a robot whose copy of the policy stops answering goes on at once, its episode with it, on a spare copy the deployment keeps (buffer_workers), each robot connects with a key of its own, and a robot names nothing of the policy’s.

Needs sequence-base 0.5.0 or later; pip install -U sequence-ai brings it.

Changed

  • @seq.policy(hz=..., action_chunk_len=..., action_chunk_exec_len=...): the control rate, and how many steps an answer holds and how many of them play, are the policy’s to declare - hz to deploy - and @seq.concurrent(sizes=[1, 2, 4]) lists the batch sizes its act function is called with; max_concurrent= and dynamic= are refused. A benchmark is @seq.benchmark(tasks=..., seeds=..., max_seconds=..., driver=...) with @seq.setup, @seq.reset and @seq.step, the environment as it is; one registered before this release is registered again with seq deploy.

Added

  • seq policy settings <name> and seq policy set <name> KEY=VALUE ...: every setting of a deployment, where its value comes from and when a change takes effect, changed at once, all of them or none; seq policy scale, params, budget, alerts and capture are settings now, each refused in words that give the new form (seq policy set <name> max_gpus=4, params.<name>=VALUE, budget.monthly_usd=USD, alerts.webhook=URL, capture=on). seq robot add --policy <name> gives a robot a key of its own, printed once (seq robot list, seq robot revoke <id or last four>); seq prod promote <name>, run with a production key, makes a dev policy a production one; seq policy fork <name> <name>-next copies a policy - its code, settings and weights - into one of its own, the way to try a version first now that seq policy traffic is refused. From Python: seq.policy_settings(), seq.policy_set(), seq.robot_add(), seq.robot_list(), seq.robot_revoke(), seq.prod_promote() and seq.policy_fork(); sequence_ai.scale() points to seq.policy_set().

Removed

  • The robot-arm preset, and every keyword a robot gave of the policy’s: sequence_ai.observation(), Observation, ImageFrame, Proprioception, ActionChunk, policy.prepare_image(), to_command(), to_commands(), policy.contract, policy.set_instruction(), policy.instruction, binary frames (policy.act_format, SEQ_ACT_FRAMES), act(steps_left=, action_horizon=, return_world_prediction=, robot=, params=) and connect(control_hz=, params=, validate=, expect=). A robot hands what it observes, its instruction too, to policy.observe(x) as it is, act() returns what the policy’s act function returned, and sequence_ai.resize_image() fits a frame; each removed name is refused saying what to write instead. A robot on 0.50.0 or earlier that connects with expect= is refused by its own SDK before its first act: upgrade to 0.51.0 and leave expect= out.

0.50.0 · 2026-10-24

A policy’s planner runs beside its act function, a robot’s episode keeps its last minute, and capture is one switch that keeps every episode whole.

Added

  • episode.state["seq.observations"] and episode.state["seq.actions"]: each observation a robot sent, at its step, and each return of the act function, at the step of the newest observation before it, kept in the robot’s episode for about its last minute.

Changed

  • @seq.plan(every_s=, wake_on=) marks def plan(self, episode), plain or async: it is called every every_s seconds after a robot’s last plan began, once the robot has sent something new, and at once for an observation that holds a key wake_on lists. What it returns is kept in episode.state["seq.plans"]; the act function takes episode and reads the newest as episode.state["seq.plans"][-1]["value"]. plan=, robot=, max_concurrency= and max_batch= are gone, refused in words that say what to write instead.
  • seq policy capture <name> on | off: on keeps every episode whole, its frames too, and seq policy data export includes what the policy kept in episode.state at each episode’s end; --rate, --images and --off are gone, refused in words that give the new form.

0.49.0 · 2026-10-24

A robot plays its actions in a loop of its own, and a policy marks its methods by decorator alone: run(), the Player and the method names on @seq.policy are gone.

Removed

  • policy.run(), sequence_ai.Player, RunOutcome and Answer: act() returns what the policy’s act function returned as it returned it; a robot-arm policy’s act() sends the newest observation policy.observe(obs) kept and returns its ActionChunk, and act(obs) is refused.
  • infer=, observe=, reset=, end=, sample= and make= on @seq.policy: mark the methods @seq.infer, @seq.observe, @seq.reset, @seq.on_episode and @seq.sample - for a class of your repository, in a subclass of it - and build what make= built in a class’s constructor; seq deploy writes the subclass out for you. A method takes episode where it took episode_id (episode.id), and @seq.on_episode’s is (self, episode).
  • connect(embodiment=), @seq.policy(embodiments=) and execution feedback (act(feedback=), seq.Feedback): what a robot is, and what it was playing, go in its observations.

0.48.1 · 2026-10-24

Video, Depth and Tactile reach a class that names its observe= method, and seq deploy --dry-run answers as the deploy would in two more cases.

Fixed

  • policy.observe() of a sequence_ai.Video, Depth or Tactile item works for a policy that names its observe= method or declares observations=seq.Observations(every=1); before, it was refused. A policy that reads some steps and not others still refuses them, saying why.
  • seq deploy --dry-run under the name of a deployment you just deleted ends as the deploy would, with a new deployment, instead of failing after saying the platform accepted it.
  • init= naming a part that weights= does not have, as "{weights.nope}", is refused by seq deploy and its dry run, naming the part and the parts there are; before, the build failed on the platform.

0.48.0 · 2026-10-24

Every input goes through observe() and act() carries none, and a robot can send its camera, depth and touch data compressed.

Added

  • sequence_ai.Video, Depth and Tactile: wrap an item of what you observe, and it travels compressed and reaches your policy as it was sent (pip install "sequence-ai[observe]", Python 3.10 or later).
  • A sample episode (sample=) is the robot’s own calls in order, ("observe", x) and ("act",): seq deploy plays it on the card and says how long the first act and the ones after took, and the peak GPU memory.

Changed

  • For a policy that names its methods, or one written with @seq.infer that takes one act at a time and plans nothing, policy.act() carries no data: hand inputs to policy.observe(x) first. With no episode_id the calls go under the handle’s current episode, and what the act function returns comes back as it is, arrays with their dtype and shape. A policy deployed before this takes act(x) until seq deploy builds it again.

0.47.0 · 2026-10-24

A class you already have deploys as it is: its factory function, its methods’ named inputs and its torch tensors.

Added

  • make="package.module:function" names the function that builds a policy, and seq.policy(...)(Cls) in a file of your own declares a class imported from elsewhere, so the class’s own files stay as they are.
  • A named method that takes several required inputs is handed an act’s dict by key; a missing or extra key is refused, naming it.

Changed

  • An answer’s torch tensors reach the robot as numpy arrays of the same dtype (bfloat16 and float8 as float32), and seq deploy warns when infer= names a method that answers one action a step, such as select_action.

0.46.0 · 2026-10-24

seq deploy says what a policy’s declarations make of it before anything is built, and installs a project’s named requirements file.

Added

  • seq deploy and its --dry-run say what a policy reads of each observation, how its answers play, whose its episodes are, what its build check acts on and how many robots a copy seats - and, once, what to add when a policy that could seat several robots a copy seats one because nothing times it: sample=, or an observation contract.
  • seq.Image.from_project(requirements="requirements-gpu.txt") names the requirements file a project installs from.

Changed

  • seq deploy installs a folder’s one requirements-<name>.txt when it has no other dependency file, and of several asks you to name one.

0.45.1 · 2026-10-24

A policy that declares observations= is handed the same inputs on a robot as in an eval, and seq deploy says how long its sample= episode took.

Fixed

  • A policy that declares observations= and reads each act’s own step alone - seq.Observations({"head": seq.Stream(...)}) - is handed {"observations": [...], "steps": [...]} on a robot, with only the keys it declares, as an eval hands it; before, a robot’s act reached infer as it was sent, every key in it. A robot on an older sequence-ai gets the same, its acts’ steps counted 0, 1, 2, ... each episode; a policy deployed before this gets it once seq deploy builds it again.
  • seq deploy says how long a policy’s sample= episode took, where it said no act was called, and the platform’s hints no longer ask for a sample= the policy has.
  • A policy’s own inputs that hold numpy scalars - a bool_, a complex, a timedelta64, a longdouble - reach it as such instead of failing the act.

0.45.0 · 2026-10-24

A policy’s own inputs keep their numpy arrays’ dtype and shape, and its observe= method can be handed each frame’s step.

Added

  • @seq.policy(observe="...") naming a method that takes step is handed each frame’s step in its episode, from 0 each episode; seq deploy checks the method takes it after the observation or by name.

Fixed

  • A policy’s own inputs that hold numpy arrays reach it with each array’s dtype and shape, as bytes do, and an answer’s arrays come back as arrays - before, act() could not send them; to a policy deployed before this, arrays go as JSON lists, with one warning.
  • A policy that names its observe= method and declares a key read every few steps, or a window with gaps, has its acts served instead of refused; after the copy holding an episode stops, the new episode counts its steps from 0 and is handed none of the old one’s observations.

0.44.2 · 2026-10-24

observe() as a robot’s first call waits for a worker that is starting, as act() does.

Fixed

  • policy.observe(...) made before any act - the call that connects - waits out a worker that is starting, or a place in line, within startup_timeout_s (0 still raises at once) instead of raising Unavailable; once connected, a frame never waits.
  • policy.observe(...) while its worker restarts mid-episode keeps the observation for the episode’s next act, which waits for the worker and sends it, instead of raising Unavailable.

0.44.1 · 2026-10-24

A policy of its own inputs plays as its seq.Actions declares, with no actions_of=.

Fixed

  • run() and a Player play the rows each answer’s seq.Actions(key=...) names, up to its open_loop_horizon, at its hz - else the default: a dict or a list of numbers is one action, a list of rows of one length plays row by row; control_hz= and absolute= no longer need actions_of=.
  • answer.rows and answer.spare read such an answer’s rows the same way, and a Player plays one you hand it.

0.44.0 · 2026-10-24

seq eval report says what an eval’s own measurements say is worth declaring.

Added

  • seq eval report prints the platform’s hints for an eval as hint: lines under the policy’s load.
  • A run’s report says the step its chunks take within one and how long one plays, so the platform’s hints about a jump between two chunks and about chunks running out are said only where they apply.

Fixed

  • A Player on a policy that reads steps before an act’s own no longer sends, near its run’s end, a frame that no act reads.

0.43.0 · 2026-10-24

seq policy status and seq deploy say what a deployment’s own measurements say is worth adding to it next, under the figure each comes from.

Added

  • seq policy status prints each of the platform’s hints as a hint: line under the figure it comes from - batching, the build check, the robots waiting - and an on time: line with the stalls, its hints under it; seq deploy prints its build’s after its check.
  • A run’s report says the settings it played its chunks by (lookahead, smooth_seam, max_age_s, aligned), so a hint never asks for one a run had set.

Changed

  • A Player on a policy that reads steps before an act’s own sends each of those frames once, as it is made, also when its acts come at a changing spacing.

0.42.0 · 2026-10-23

A policy can be handed what the robot was playing when it sent each act, and a robot plays a chunk that starts at its observation’s moment from the row that is now.

Added

  • An @seq.infer that takes feedback: seq.Feedback is handed, with each act, the rows the robot had not played, the steps it expects to play before the answer is back, how many it had played and the last one; a Player, run() and an eval send it, and act(obs, feedback=...) sends your own.
  • aligned=True on seq.ActionContract or seq.Actions: a Player and run() take each answer as it lands and play it from the row that is now, the rows that went by while it was inferred skipped, and Player(policy, aligned=...) and run(aligned=...) say it for one loop.

0.41.0 · 2026-10-23

A policy can say what it reads and answers, a robot sends only the steps its acts read, and a policy that keeps its episodes on the platform can run its acts together.

Changed

  • @seq.policy(observations=, actions=, tensors=), with seq.Observations, seq.Stream, seq.Actions and seq.Tensors, replace own_observations= and own_actions=: observations=seq.Observations(every=1) takes every observation since the last act, and actions=seq.Actions() plays an answer a row a step.
  • A policy whose observations read a window of past steps (at=) or keys fed every few steps (every=) is handed those steps by its worker, and policy.observe(), run() and a Player send only the steps its acts read.
  • @seq.concurrent beside an infer that takes episode hands it episode: list[seq.Episode], one for each observation; when a batch raises, acts at their episode’s start run again alone and the other episodes end, and a robot on 0.41.0 goes on in a new one.

0.40.0 · 2026-10-23

The control loop comes apart into run(), a Player for a loop of your own and act() for one request, and a policy can keep each robot’s episode apart and batch its acts.

Changed

  • predict(), next_action() and act("instruction", observe=, act=) are gone: write act(obs), which returns an Answer, sequence_ai.Player(policy) for a loop of your own, or run(observe, step, instruction=...), which now needs max_seconds= or max_actions=.
  • @seq.policy(streaming=) is gone, worked out from how the policy is written: an @seq.infer that takes episode is handed that episode’s seq.Episode, so one copy keeps several robots’ episodes apart, and policy.observe(obs, episode_id=...) sends each observation as the robot makes it.
  • seq.collate and seq.uncollate turn a @seq.concurrent policy’s acts into one batch and its answer back, and when a batch raises, only an act that fails on its own gets an error.

0.39.0 · 2026-10-23

seq deploy takes a folder and makes its image from the project’s own dependencies, a robot goes on in a new episode when its policy’s copy stops, and an eval’s estimate says what it will likely cost.

Changed

  • seq deploy [folder] (. by default) deploys the folder’s one @seq.policy, @seq.benchmark or @seq.adapter class (--name picks one of several) and replaces seq deploy <file>.py, -m and --entry-only; a .env stays on your machine unless a !.env line uploads it.
  • A policy that writes neither image= nor deps= gets an image made from its project’s own dependency files.
  • When the copy of the policy holding an episode stops, the robot goes on in a new episode with a warning; policy.end_episode() ends an open episode, and close() ends one left open.

0.38.17 · 2026-10-21

Freeze a version to rebuild it from your own storage, and deploy a class that runs locally by naming its own methods.

Added

  • @seq.policy(freeze=True), seq deploy --freeze and seq policy freeze NAME[@vN] [--off] (and the benchmark ones) keep a version’s base and what its build installed in your storage, at $0.12/GB-month, so it can be built again exactly as it is.
  • @seq.policy can name a class’s own methods (infer=, observe=, reset=, end=) and its constructor’s arguments (init=, make=, seq.config): a class that runs locally deploys with one decorator.

Changed

  • connect() and wait_until_ready() wait as long as the platform holds the start (1800 s when it says nothing) and say how far it got; a start whose machine stops while it loads ends at once, unbilled.

0.38.16 · 2026-10-21

Framework shortcuts are gone, a version no longer keeps a copy of what it depends on in your storage, and a worker’s start, its warmup included, runs within your own startup time.

Removed

  • @seq.xpolicylab, seq port scaffold --robodojo and seq port scaffold --isaaclab: wrap a policy class you already have with a plain @seq.policy instead.

Changed

  • A version no longer keeps a copy of what it depends on in your storage (0.38.15 did); your image can install a package too large to upload from where it is published, by its URL.
  • A worker’s start, its @seq.warmup included, has your seq.Timeouts(startup=...) (1800 s unless set) and ends at once when @seq.load raises; start time past what the default allows is billed.

0.38.15 · 2026-10-21

A version keeps what it depends on in your own storage, seq port scaffold writes a benchmark from your RoboDojo or Isaac Lab checkout, and a policy of its own inputs and outputs is evaluated the way it declares.

Added

  • Each version of a deployment or benchmark keeps its own copy of what it depends on in your storage, so it can be rebuilt as it was; seq policy versions and seq benchmark versions say whether the copy is being kept or kept whole, and seq volume rm deps asks for --yes while versions hold copies there.
  • seq port scaffold --robodojo (with --envs N for a batch) and seq port scaffold --isaaclab <task> write a benchmark folder from your own checkout; @seq.benchmark(reset_together=True) resets a batch of environments at once.

Fixed

  • own_observations and own_actions, and the ones @seq.xpolicylab declares for you, now reach your evals (0.38.14 did not send them); a client without numpy reads an answer’s arrays as lists; a robot that waits past its time is told whether its GPU is held or still awaited; tables keep their columns apart.

0.38.14 · 2026-10-21

A policy of its own inputs and outputs takes bytes and arrays and is evaluated the way its own eval ran it, and an XPolicyLab policy deploys as it is.

Added

  • @seq.xpolicylab("XPolicyLab/policy/<name>", ...) deploys a policy from an XPolicyLab checkout, with no code of your own around it.
  • Inputs of a policy’s own may hold bytes and numpy arrays (they travel as msgpack), and @seq.policy(own_observations=, own_actions=) has an eval send every observation since the last act and play the answer one action a step.

Fixed

  • An act waits as long as its deployment’s request timeout (it waited 30 s), is not sent again while its worker still runs it, and a busy worker or a briefly busy service is retried instead of failing the call.

0.38.13 · 2026-10-21

A benchmark’s Dockerfile builds with its context, a subclass keeps its parent’s hooks, and seq volume put sends only what changed.

Added

  • from_registry and from_dockerfile take clear_entrypoint=True, which drops the base image’s ENTRYPOINT; and seq deploy --dry-run says how long the name’s last version took to start and what its check cost.

Fixed

  • A benchmark’s Dockerfile context ships with its registration, so its COPY finds what it names; a subclass of a benchmark or a policy has the hooks of the classes it is built on; and a class whose declaration is refused no longer stops the other classes of its file from deploying.
  • seq volume put run again sends only the files that changed, and says the volume is already up to date when none did.

0.38.12 · 2026-10-21

seq deploy --dry-run checks a benchmark or an adapter on the platform, as it already checked a policy.

Fixed

  • A benchmark's or an adapter's dry run is checked by the platform as registering it would be: a missing assets volume, a name another class holds or a limit is said before anything is built, with the same error and exit code.
  • seq.Image.from_dockerfile reads its Dockerfile and context next to the file that declares them, as add_local_file and add_local_dir already did, so seq deploy <folder>/benchmark.py works from any directory.

0.38.11 · 2026-10-21

seq policy rm and seq policy storage show small sizes as they are.

Fixed

  • Sizes under a gigabyte show to a tenth of a megabyte, as seq volume ls shows them: a 2.6 MB compile cache no longer reads “0 MB”.

sequence-base

0.8.0 · 2026-10-31 · contract 0.5.38

What only an SDK before 0.54 sent or read is gone, and the contract names a robot’s prompts and a planner’s first plan.

Added

  • PROMPT_KEYS and WAITING_FOR_PLAN describe a robot connected through a planner.
  • An inference parameter declared list[float] takes a list of numbers, each held to its min and max.
  • An eval’s POST /observe names its arm’s inference parameters, so a policy’s observe function runs with them.

0.7.3 · 2026-10-28 · contract 0.5.36

A model that carries a secret leaves it out when it is printed.

Fixed

  • BootstrapResponse, ConnectResponse, Standby and SettingsChanged leave their secrets out of their repr, so an error that prints one shows none of them.

0.7.2 · 2026-10-28 · contract 0.5.36

Two log lines written at the same moment come out as two lines.

Fixed

  • obs.log writes a line and its newline together, so two threads logging at once no longer run their events together on one line.

0.7.1 · 2026-10-27 · contract 0.5.36

An observation’s large arrays, bytes and text cross to the worker once an episode.

Added

  • codec.blocks: an unmarked array, bytes or text of 16 KiB or more is sent as a reference to blocks its worker holds, a frame stacked in a window one block a slice, and turned back byte for byte before the policy is handed it. ObserveRequest.blocks carries the contents a post’s frames need; a worker names x-seq-blocks/1 to be sent them. A post without blocks reads as before.

Changed

  • Resources.region names one of the platform’s own regions, us-west or us-east, or auto (the default) for the one nearest each robot.

0.7.0 · 2026-10-27 · contract 0.5.35

A policy’s two control-loop numbers carry the names its user gave them, and an eval models no network.

Changed

  • action_chunk_len is now action_chunk_valid_len, the steps of an answer that are valid, and action_chunk_exec_len is now action_chunk_replan_at, the step, counted from when an act is sent, at which the next answer is asked for; the old names are refused saying the new ones.
  • EvalRequest.latency_ms is gone: an eval asks for the next answer at the policy’s replan step and switches to it at its valid step, the world held still until it comes.
  • Camera takes no codec=, quality= or layout= any more, gone with seq.Stream; a frame goes as sequence_ai.Video.

0.6.0 · 2026-10-26 · contract 0.5.34

A planner is a deployment of its own that plans for the policies and planners it names, teams and observations= are gone, and an observation may travel compressed.

Added

  • PolicySpec.planner and DeploymentPolicy.planner (PlannerSpec: the members it plans for), and the models of a planner’s round and plans (PlannerRound, PlannerPlans, PlannerObserve and the rest).
  • x-seq-zstd/1: a worker that says it takes an observation’s arrays compressed with zstd-1, which a robot sends when that saves time.

Changed

  • A team (TeamSpec and its models; ConnectRequest.team, group and team_key), a plan on a policy and observations= (Observations, Stream) are refused where they are written, each saying what to write instead; a spec stored with team or observations null reads as before. An act waits at most 3 seconds for the observations its robot sent before it (STREAM_WAIT_S, 10 until now), then is answered 409 frames_missing and its robot sends them again.

0.5.1 · 2026-10-25 · contract 0.5.33

A benchmark is built by its constructor after the machine’s snapshot, and a team’s robots join a group with a team key.

Changed

  • BenchmarkSpec.constructor says how a benchmark’s class is built: init= hands its constructor "{worlds}", how many worlds the eval builds, and "{policy.<field>}", what the evaluated policy declares. A benchmark binds RESET and STEP alone; one that binds SETUP is refused and is registered again with sequence-ai 0.51.1. An eval’s settings are the constructor’s own parameters with defaults.
  • A team is built by its constructor as a policy is, and may bind SAMPLE.

Added

  • ConnectRequest.team_key, the team key of the group a robot joins, beside its own robot key; and ConnectResponse.standby_retry_s, how many seconds on a robot asks for a standby again when none could be held yet.

0.5.0 · 2026-10-25 · contract 0.5.32

A policy declares its control loop and batch sizes, a benchmark is the environment as it is, and a deployment’s settings have a contract of their own.

Changed

  • PolicySpec carries hz, action_chunk_len and action_chunk_exec_len, and Concurrency.sizes lists the batch sizes the act function is called with; action, observation, scaledown_window, on_full, queue_timeout_s and Concurrency.dynamic are gone. ConnectResponse tells a robot the policy’s hz and chunk lengths.
  • BenchmarkSpec and BenchmarkRegisterRequest carry tasks, seeds, max_seconds and worlds and bind SETUP, RESET and STEP; driver stays, and Conditions, Variant, Step, RenderSpec, BenchmarkConditionSpec, max_steps, envs and the old benchmark’s other fields are gone. EvalRequest drops envs, variants and record and takes latency_ms.

Added

  • contract.settings: the settings a deployment’s owner changes without a redeploy, each with its type, bounds and who reads it, and the shapes of GET and PATCH /v1/deployments/{name}/settings; and contract.team: PolicySpec.team names the policies whose robots may join a team, and ConnectRequest.team and group say which team and group a robot joins.

0.4.34 · 2026-10-25 · contract 0.5.30

A benchmark can name the NVIDIA driver its card must have.

Added

  • driver on BenchmarkSpec and BenchmarkRegisterRequest: the driver’s major version beside the card (driver="580"). Left out, the benchmark takes whichever driver its card has; named beside gpu="cpu", it is refused.

0.4.33 · 2026-10-24 · contract 0.5.29

A policy’s planner is written plan(self, episode), and what it returns is kept in the episode’s state.

Changed

  • plan and robot are no longer names the platform hands an act function: a declaration that still takes them is refused in words that say to take episode and read episode.state["seq.plans"], and a @seq.plan written otherwise, or a wake_on= that is not a list of keys, is refused the same way.

0.4.32 · 2026-10-24 · contract 0.5.29

What the platform hands a policy’s functions is its episode alone, and an eval’s seed.

Removed

  • episode_id, embodiment and execution feedback in the contract: a function takes episode (episode.id), and a declaration that still names them is refused in words that say what to write instead.

0.4.31 · 2026-10-24 · contract 0.5.28

A robot can mark the camera, depth and touch data it observes, so they travel compressed and arrive as they were sent.

Added

  • sequence_base.codec.marked: how a Video, Depth or Tactile item travels - video as low-latency H.264, depth without loss, touch as high-quality video or as sent - and how each is decoded back to the array it was.
  • An observe extra installs what encoding and decoding need: pip install "sequence-base[observe]".

0.4.30 · 2026-10-24 · contract 0.5.27

A policy’s make= can name a module’s function, and the rule that binds an act’s keys to a method’s parameters lives in one place.

Added

  • PolicyConstructor.make takes "package.module:function": the worker imports that function and calls it with init, and what it returns is the instance the named methods are called on.
  • sequence_base.by_name: the rule that hands a dict’s keys to a method’s parameters by name, which the SDK and the worker both read.

0.4.29 · 2026-10-23 · contract 0.5.26

A policy can be handed what the robot was playing when it sent each act, and can say its chunk starts at the moment of the observation.

Added

  • Feedback and PolicySpec.feedback: a policy whose infer takes feedback gets the rows the robot had not played, the steps it expects to play before the answer is back, how many it had played and the last one it played.
  • ActRequest.feedback and ConnectResponse.feedback: the act carries it, and the robot is told to send it.
  • ActionContract.aligned and Actions.aligned: the rows played while a chunk was inferred are skipped.

0.4.28 · 2026-10-23 · contract 0.5.25

A policy declares what it reads and plays with Observations and Actions alone, and which steps it reads and which rows of its answer play are worked out by the contract’s own rules.

Changed

  • PolicySpec and DeploymentPolicy no longer have own_observations or own_actions: Observations(every=1) is every observation since the last act, Actions() an answer played a row a step, and Observations takes its keys first.
  • contract.obs_schedule says which steps a declaration reads, and contract.own_io.rows_of which rows of an answer are played.

0.4.27 · 2026-10-23 · contract 0.5.24

A policy can say what it reads and answers, take each observation as the robot makes it, and have each episode’s state kept for it.

Added

  • Observations, Actions and Tensors on PolicySpec: what a policy reads, by key with a Stream and Camera each, the actions it answers with, and whether its arrays arrive as tensors; SeqFlags.SAMPLE names a sample episode.
  • ObserveRequest and ObserveResponse (POST /observe) and ActRequest.seq: a policy that reads every observation gets each one as the robot makes it.
  • PolicySpec.episodes, Timeouts.episode_idle and Episode: the state of each episode a copy of a policy serves, and how long an idle one keeps its place.

0.4.26 · 2026-10-23 · contract 0.5.23

An image can install a project’s own dependencies from its files.

Added

  • ImageStepProject: an image step that copies a project’s dependency files and installs them, so a policy’s image can be made from the project it was deployed from.

0.4.25 · 2026-10-21 · contract 0.5.22

A deploy or a registration can freeze its version, and a policy can be a class the worker builds and calls by its own names.

Added

  • DeploymentRequest.freeze and BenchmarkRegisterRequest.freeze: the version is kept in its user’s storage, so it can be built again exactly as it is.
  • PolicyConstructor, PolicyRegistration.constructor and the OBSERVE and RESET bindings, with sequence_base.construct: how a worker builds a class from its constructor’s arguments, config files and "{weights}".

0.4.24 · 2026-10-21 · contract 0.5.21

A deploy carries how a policy of its own inputs and outputs is evaluated, and an answer’s arrays read without numpy.

Fixed

  • DeploymentPolicy.own_observations and DeploymentPolicy.own_actions: the deploy request carries them. In 0.4.23 they were on PolicySpec alone, so no deploy sent them and evals ran such a policy as if it declared neither.
  • msgpack_io.unpack reads an array where numpy is not installed as the nested lists its tolist() gives, as the same answer in JSON holds it, instead of raising.

0.4.23 · 2026-10-21 · contract 0.5.20

An act can travel as msgpack, and a policy of its own inputs and outputs can be evaluated the way its own eval ran it.

Added

  • sequence_base.msgpack_io: pack and unpack for application/x-seq-msgpack (x-seq-msgpack/1), in plain Python. Arrays go byte for byte as msgpack-numpy writes them; arrays of objects and extension types are refused.
  • PolicySpec.own_observations ("latest" or "since_last_act") and PolicySpec.own_actions ("one" or "steps"): an eval sends every observation since the policy’s last act, and plays its answer one action a step. Unset, nothing changes; beside the robot-arm contract they are refused.

0.4.22 · 2026-10-21 · contract 0.5.19

An image can drop its base’s ENTRYPOINT.

Added

  • ImageSpec.clear_entrypoint: set, the platform’s start command runs without the base image’s ENTRYPOINT wrapped around it. Off unless asked for, since some images use their ENTRYPOINT to prepare the environment.