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()raisesWaitingForPlanuntil 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-runwarns when a policy’smemory=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 reportsays 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_resumewaits until the arm has something to play; a console also reaches a robot that starts observing right afterconnect(teleop=True). - A robot’s notices and
seq robot statussay what happened: no notice when it gave its seat back itself to connect again or inwait_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()oract()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 statusshows each connection’s link - its round trip and upload time as its worker measured them - andseq policy statusits robots’ connects of the last day: how many, how fast to the first answer, and where the others stopped.seq modelsshows each model’s context and the inputs it takes,seq eval ls --adapter NAME[@vN] --status STATElists an adapter’s evals in one state, and theseq.*_logsfunctions takesince=0as 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/--clocksets the times everyseqcommand prints, not only the console’s;seq logoutand a newseq loginend 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/--expireschecks the key came back with them,seq robot set --limit 0is refused (nonelifts a limit),seq billing top-upwaits 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;seqwrites 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 lsshows dev or production,seq accountits id andseq eval ls --adapter NAME@vNone version’s evals; and theseq.*_logsfunctions 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 billingandseq accountdo what the console’s Keys, Billing and Account pages do - a promotion code too, withseq billing redeem CODE; a robot key takes an expiry and a spending limit (seq robot add --expires/--limit,seq robot set),seq robot statusandseq planner ls|statusshow what the Machines page shows, and every log pages back with--before- each with itsseq.*function.seq eval replay EVAL_ID|FILEopens an eval’s replays in the console’s 3D player on your own machine - turn, zoom and scrub - andseq.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 statussays why a worker of your warm hours, your minimum or a spare runs and stopped,seq policy rmnames each key it stops by its kind, andseq --json eval cancelprints 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 statussays under each robot why it sits on its worker. seq usage --policylists each robot by the key it connects with - its acts, errors, round trips and on-time - andseq eval reportshows 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 usageshows 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 auditnames the operator of a teleop session beside its robot key, andsequence_ai.teleop()sends its operator when it connects.sequence_ai.teleop()needs norobot=: 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 statussays 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, andhelp(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 thatconnect(teleop=True)takes them, andseq.ask_human(reason=...)lets a planner ask a person for help.seq storageandseq volume files,getandrm: 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 lerobotwrites 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=...)andseq deploy --region:us-westorus-eaststarts 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 rmrefuses a secret a deployment still uses, naming the deployment;--forcedeletes 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.benchmarkor@seq.adapterclass written in a script run aspython file.py, in a notebook or inside a function runs there as it did before the decorator;seq deploystill 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.observeand@seq.infermethods both takeepisodekeeps its episodes inepisode.state, as the docs’ example does:seq deploysays they are handed to observe and infer, no longer kept on the class. - A class with an
@seq.resetmethod keeps its episodes on itself even when its infer takesepisode: 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 ofaction_chunk_lenandaction_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, andseq deploysays how many from the time between them.--latency-msandlatency_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.planmethod,def plan(self, group), deployed withseq deployas a policy is;sequence_ai.planner(name).observe(...)for what only a planner reads, such as a site’s iPad; andseq planner key add <planner> --member <name>(andlist,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.planon a policy, and@seq.policy(observations=...)withseq.Observationsandseq.Streamare 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 | revokename 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 lsandseq benchmark statusshow 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-msorlatency_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 deployno 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)", andseq deploy --dry-runsays "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.planplans for the robots of several policies, a group of them at a time; a robot joins a group withsequence_ai.team(name, group=...), andseq team key add | list | revokeissues the team key a site’s iPad observes its group with.
Changed
@seq.loadand@seq.setupare removed: a policy loads its model and a benchmark builds its worlds in__init__, andinit=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.setupis registered again withseq 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 -hzto deploy - and@seq.concurrent(sizes=[1, 2, 4])lists the batch sizes its act function is called with;max_concurrent=anddynamic=are refused. A benchmark is@seq.benchmark(tasks=..., seeds=..., max_seconds=..., driver=...)with@seq.setup,@seq.resetand@seq.step, the environment as it is; one registered before this release is registered again withseq deploy.
Added
seq policy settings <name>andseq 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,alertsandcaptureare 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>-nextcopies a policy - its code, settings and weights - into one of its own, the way to try a version first now thatseq policy trafficis refused. From Python:seq.policy_settings(),seq.policy_set(),seq.robot_add(),seq.robot_list(),seq.robot_revoke(),seq.prod_promote()andseq.policy_fork();sequence_ai.scale()points toseq.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=)andconnect(control_hz=, params=, validate=, expect=). A robot hands what it observes, its instruction too, topolicy.observe(x)as it is,act()returns what the policy’s act function returned, andsequence_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 withexpect=is refused by its own SDK before its first act: upgrade to 0.51.0 and leaveexpect=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"]andepisode.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=)marksdef plan(self, episode), plain or async: it is called everyevery_sseconds after a robot’s last plan began, once the robot has sent something new, and at once for an observation that holds a keywake_onlists. What it returns is kept inepisode.state["seq.plans"]; the act function takesepisodeand reads the newest asepisode.state["seq.plans"][-1]["value"].plan=,robot=,max_concurrency=andmax_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, andseq policy data exportincludes what the policy kept inepisode.stateat each episode’s end;--rate,--imagesand--offare 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,RunOutcomeandAnswer:act()returns what the policy’s act function returned as it returned it; a robot-arm policy’sact()sends the newest observationpolicy.observe(obs)kept and returns itsActionChunk, andact(obs)is refused.infer=,observe=,reset=,end=,sample=andmake=on@seq.policy: mark the methods@seq.infer,@seq.observe,@seq.reset,@seq.on_episodeand@seq.sample- for a class of your repository, in a subclass of it - and build whatmake=built in a class’s constructor;seq deploywrites the subclass out for you. A method takesepisodewhere it tookepisode_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 asequence_ai.Video,DepthorTactileitem works for a policy that names itsobserve=method or declaresobservations=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-rununder 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 thatweights=does not have, as"{weights.nope}", is refused byseq deployand 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,DepthandTactile: 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 deployplays 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.inferthat takes one act at a time and plans nothing,policy.act()carries no data: hand inputs topolicy.observe(x)first. With noepisode_idthe 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 takesact(x)untilseq deploybuilds 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, andseq.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 deploywarns wheninfer=names a method that answers one action a step, such asselect_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 deployand its--dry-runsay 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 deployinstalls a folder’s onerequirements-<name>.txtwhen 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 reachedinferas it was sent, every key in it. A robot on an oldersequence-aigets the same, its acts’ steps counted 0, 1, 2, ... each episode; a policy deployed before this gets it onceseq deploybuilds it again. seq deploysays how long a policy’ssample=episode took, where it said no act was called, and the platform’s hints no longer ask for asample=the policy has.- A policy’s own inputs that hold numpy scalars - a
bool_, a complex, atimedelta64, alongdouble- 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 takesstepis handed each frame’s step in its episode, from 0 each episode;seq deploychecks 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, withinstartup_timeout_s(0 still raises at once) instead of raisingUnavailable; 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 raisingUnavailable.
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 aPlayerplay the rows each answer’sseq.Actions(key=...)names, up to itsopen_loop_horizon, at itshz- 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=andabsolute=no longer needactions_of=.answer.rowsandanswer.spareread such an answer’s rows the same way, and aPlayerplays 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 reportprints the platform’s hints for an eval ashint: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
Playeron 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 statusprints each of the platform’s hints as ahint:line under the figure it comes from - batching, the build check, the robots waiting - and anon time:line with the stalls, its hints under it;seq deployprints 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
Playeron 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.inferthat takesfeedback: seq.Feedbackis 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; aPlayer,run()and an eval send it, andact(obs, feedback=...)sends your own. aligned=Trueonseq.ActionContractorseq.Actions: aPlayerandrun()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, andPlayer(policy, aligned=...)andrun(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=), withseq.Observations,seq.Stream,seq.Actionsandseq.Tensors, replaceown_observations=andown_actions=:observations=seq.Observations(every=1)takes every observation since the last act, andactions=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, andpolicy.observe(),run()and aPlayersend only the steps its acts read. @seq.concurrentbeside an infer that takesepisodehands itepisode: 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()andact("instruction", observe=, act=)are gone: writeact(obs), which returns anAnswer,sequence_ai.Player(policy)for a loop of your own, orrun(observe, step, instruction=...), which now needsmax_seconds=ormax_actions=.@seq.policy(streaming=)is gone, worked out from how the policy is written: an@seq.inferthat takesepisodeis handed that episode’sseq.Episode, so one copy keeps several robots’ episodes apart, andpolicy.observe(obs, episode_id=...)sends each observation as the robot makes it.seq.collateandseq.uncollateturn a@seq.concurrentpolicy’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.benchmarkor@seq.adapterclass (--namepicks one of several) and replacesseq deploy <file>.py,-mand--entry-only; a.envstays on your machine unless a!.envline uploads it.- A policy that writes neither
image=nordeps=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, andclose()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 --freezeandseq 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.policycan 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()andwait_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 --robodojoandseq port scaffold --isaaclab: wrap a policy class you already have with a plain@seq.policyinstead.
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.warmupincluded, has yourseq.Timeouts(startup=...)(1800 s unless set) and ends at once when@seq.loadraises; 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 versionsandseq benchmark versionssay whether the copy is being kept or kept whole, andseq volume rm depsasks for--yeswhile versions hold copies there. seq port scaffold --robodojo(with--envs Nfor a batch) andseq 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_observationsandown_actions, and the ones@seq.xpolicylabdeclares 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_registryandfrom_dockerfiletakeclear_entrypoint=True, which drops the base image’sENTRYPOINT; andseq deploy --dry-runsays 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
COPYfinds 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 putrun 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_dockerfilereads its Dockerfile and context next to the file that declares them, asadd_local_fileandadd_local_diralready did, soseq deploy <folder>/benchmark.pyworks 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 lsshows 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_KEYSandWAITING_FOR_PLANdescribe a robot connected through a planner.- An inference parameter declared
list[float]takes a list of numbers, each held to itsminandmax. - An eval’s
POST /observenames 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,StandbyandSettingsChangedleave 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.logwrites 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.blockscarries the contents a post’s frames need; a worker namesx-seq-blocks/1to be sent them. A post without blocks reads as before.
Changed
Resources.regionnames one of the platform’s own regions,us-westorus-east, orauto(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_lenis nowaction_chunk_valid_len, the steps of an answer that are valid, andaction_chunk_exec_lenis nowaction_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_msis 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.Cameratakes nocodec=,quality=orlayout=any more, gone withseq.Stream; a frame goes assequence_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.plannerandDeploymentPolicy.planner(PlannerSpec: themembersit plans for), and the models of a planner’s round and plans (PlannerRound,PlannerPlans,PlannerObserveand 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 (
TeamSpecand its models;ConnectRequest.team,groupandteam_key), a plan on a policy andobservations=(Observations,Stream) are refused where they are written, each saying what to write instead; a spec stored withteamorobservationsnull 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 409frames_missingand 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.constructorsays 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 bindsRESETandSTEPalone; one that bindsSETUPis 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; andConnectResponse.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
PolicySpeccarrieshz,action_chunk_lenandaction_chunk_exec_len, andConcurrency.sizeslists the batch sizes the act function is called with;action,observation,scaledown_window,on_full,queue_timeout_sandConcurrency.dynamicare gone.ConnectResponsetells a robot the policy’shzand chunk lengths.BenchmarkSpecandBenchmarkRegisterRequestcarrytasks,seeds,max_secondsandworldsand bindSETUP,RESETandSTEP;driverstays, andConditions,Variant,Step,RenderSpec,BenchmarkConditionSpec,max_steps,envsand the old benchmark’s other fields are gone.EvalRequestdropsenvs,variantsandrecordand takeslatency_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 ofGETandPATCH /v1/deployments/{name}/settings; andcontract.team:PolicySpec.teamnames the policies whose robots may join a team, andConnectRequest.teamandgroupsay 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
driveronBenchmarkSpecandBenchmarkRegisterRequest: the driver’s major version beside the card (driver="580"). Left out, the benchmark takes whichever driver its card has; named besidegpu="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
planandrobotare no longer names the platform hands an act function: a declaration that still takes them is refused in words that say to takeepisodeand readepisode.state["seq.plans"], and a@seq.planwritten otherwise, or awake_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,embodimentand execution feedback in the contract: a function takesepisode(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 aVideo,DepthorTactileitem 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
observeextra 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.maketakes"package.module:function": the worker imports that function and calls it withinit, 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
FeedbackandPolicySpec.feedback: a policy whose infer takesfeedbackgets 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.feedbackandConnectResponse.feedback: the act carries it, and the robot is told to send it.ActionContract.alignedandActions.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
PolicySpecandDeploymentPolicyno longer haveown_observationsorown_actions:Observations(every=1)is every observation since the last act,Actions()an answer played a row a step, andObservationstakes its keys first.contract.obs_schedulesays which steps a declaration reads, andcontract.own_io.rows_ofwhich 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,ActionsandTensorsonPolicySpec: what a policy reads, by key with aStreamandCameraeach, the actions it answers with, and whether its arrays arrive as tensors;SeqFlags.SAMPLEnames a sample episode.ObserveRequestandObserveResponse(POST /observe) andActRequest.seq: a policy that reads every observation gets each one as the robot makes it.PolicySpec.episodes,Timeouts.episode_idleandEpisode: 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.freezeandBenchmarkRegisterRequest.freeze: the version is kept in its user’s storage, so it can be built again exactly as it is.PolicyConstructor,PolicyRegistration.constructorand theOBSERVEandRESETbindings, withsequence_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_observationsandDeploymentPolicy.own_actions: the deploy request carries them. In 0.4.23 they were onPolicySpecalone, so no deploy sent them and evals ran such a policy as if it declared neither.msgpack_io.unpackreads an array where numpy is not installed as the nested lists itstolist()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:packandunpackforapplication/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") andPolicySpec.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’sENTRYPOINTwrapped around it. Off unless asked for, since some images use their ENTRYPOINT to prepare the environment.