Your robot connects with its robot key, which reaches the policies on its list. The gateway admits it and hands it a worker in one of seven regions, all in the United States; from then on every observation and every action goes between your robot and that worker directly, over TLS, and never through the gateway.
The path
| step | goes to | what goes |
|---|---|---|
connect() | the gateway, once | the robot’s key; back come its worker’s address, the fingerprint of that worker’s certificate, a secret for it and a lease |
observe(), act() | the worker, directly | every observation and
every action, on one WebSocket over TLS (wss), the worker’s certificate checked against
that fingerprint; the same secret over plain HTTP is refused |
| keepalive | the gateway, about every 20 s | the robot’s seat and its lease — no observation and no action |
| reconnect | the gateway, when needed | after a rotated secret, an expired lease or a worker that scaled to zero: a fresh address and secret, and the call in flight replayed to the worker |
| a person driving it | the robot, directly | pictures and commands go between the console and the robot and reach no server of ours. The platform carries each side’s connection details, which hold both network addresses, once, and deletes them when the two have paired, within 60 seconds at the most (Teleoperation) |
A robot’s worker starts in the region nearest the robot, one of seven in the US (Regions). How the client reconnects is in Direct connect and fallback.
A policy’s chat() and decide() calls go from its worker to the platform and on to
the provider that serves the model they name. What a call carries — its text, and any image you put in it,
a camera frame among them — reaches that provider and is handled under its terms; the platform keeps what
the call cost, not what it said.
What is kept, and by whom
Recording what your robots saw and did is a switch of its own, and what it records is yours: we store none of it.
| Record, on a robot | |
|---|---|
| turned on with | seq robot set <name> record=on, or the switch by the robot’s name in the console; off until you turn it on |
| who keeps it | you do: seq robot record <name> writes it to a file where you run it, and
sequence_ai.record() hands it to your own code. A robot connected to "teleop"
alone writes it itself, to a file on its own machine. We store none of it, and it costs nothing more |
| what | every step as it runs: each observation as the robot sent it, each action and who drove it, each label and episode end, and every take, release and ask for a person |
| who can read it | you, signed in or with your account’s key, or the robot’s own key, which reads that robot alone |
| how long | on each worker, the newest minute of what it records, at most 32 MiB for all its robots together, in memory alone; after that, as long as you keep it |
| stopped by | record=off, which stops every recorder of the robot and drops what the workers hold |
It is off until you turn it on. Off or on, none of your robots’ observations, actions, frames or labels is
stored by us. On a policy with a standby, what your policy keeps in episode.state is saved as
an episode runs, in our own place, so the robot can go on from it on its standby, and deleted when the episode
ends, an hour after its last save at the latest (A standby copy).
Who took over,
gave back or stopped which robot, and when, is kept in your account’s audit trail
(Teleoperation). How Record works is in
Field data, and reading its steps in your own code in
Your own recorder.
What Record stored in your account while it kept episodes there, and a policy’s capture before it, stays as
it was: in your account’s storage, billed as storage, until its retention ends — 30 days unless you
had set another, and never longer than your account’s data policy allows
— or until you delete it with seq volume rm. What a robot or a policy you deleted had kept
stays as a dataset of its own until you delete it, or your account. seq policy data export reads
either (What was kept before).
On a GPU machine you add
Once a minute, a program on the machine, outside your container, reads how busy each card is, how much of its memory is in use and how much power it draws; the names of the processes using the cards; and the IP address and port at the other end of each of your container’s network connections. It never reads the files in your container, and never what is sent over a connection. We check each reading for signs of cryptocurrency mining, which the Acceptable Use Policy prohibits, and keep only what matches, for 30 days after it was last seen; the rest is not kept (Privacy).
A snapshot of a GPU
A snapshot you save of a GPU holds what you changed in its container — the files you installed and wrote over our base environment — and the command it runs at start. It is kept in your account’s storage with us, and only your account can list it, start a GPU from it or remove it: your keys and your signed-in sessions, no other account. We open it only to start a GPU of yours from it.
Removing it stops its storage charge at once, and its files are deleted within a day after, 25 hours at the most. Deleting your account deletes your snapshots with the rest of your files, within 30 days at the most, as the Terms say.
What the platform keeps
Each kind of log is kept for the time its row says in one table, How long logs are kept, and then deleted; a Custom plan can agree to keep them longer.
Deleting your account deletes every log and every day’s totals at once, and its files — every eval’s recordings and every dataset your policies captured — and the secrets it stored within minutes after; all of it within 30 days at the most, as the Terms say. Your usage records and invoices are kept, as accounting requires.
Keys and secrets
A robot key (seq_robot_…) is one robot’s, and reaches the policies on its list: it connects
to and acts those policies and calls the models they declare, nothing else, and managing anything is refused.
seq robot key replaces one and seq robot rm deletes its robot; either way the old key
stops, and a robot connected with it is cut off at once (Keys).
A secret (BYOK) is write-only: its value reaches your policy as the environment variables you named, when it runs, and is masked in its logs; no command reads a stored value back (Secrets).