Inference API

Both brains, one key.

A robot needs something to decide what and something to decide how. Today those come from two vendors with two SDKs and two invoices. Here they come from one base URL, in one shape: /v1/chat for the models that reason, /v1/act for the ones that move, and the same envelope back from both.

api.generalsequences.com/v1 live
Vision-languagechat
Action policiesact
World-action modelsact
Endpoints to learn2
API keys to hold1
Lightest policy3 B · 1 frame
Heaviest policy36 B · 3 frames
Licences are read from each repository, not from its metadata — well-known checkpoints forbid paid hosting and are refused at the gateway.

The slow brain

Nothing here is wrapped. No system prompt is injected, no message is rewritten, no reply is parsed. Messages go in, one message comes back — in the same envelope the action endpoint answers with.

plan.pyplain http
import requests

plan = requests.post(
    "https://api.generalsequences.com/v1/chat",
    headers={"Authorization": f"Bearer {SEQUENCES_KEY}"},
    json={
        "model": "accounts/sequences/models/claude-fable-5",
        "messages": [{"role": "user", "content": [
            {"type": "text", "text": "What should the arm do next?"},
            {"type": "image_url", "image_url": {"url": frame}},
        ]}],
    },
).json()["message"]["content"]

The fast brain — observation in, action chunk out

One request shape for every policy. A feed-forward VLA reads the latest frame per camera; a world-action model reads a window of them. You send the frames you have and the response tells you what was used.

act.pyno equivalent elsewhere
chunk = requests.post(f"{BASE}/act", headers=HEAD, json={
    "model": "accounts/sequences/models/pi05-droid",
    "observation": {
        "images": [
            {"view": "exterior_1", "data": frame_a, "timestamp_ms": 1000},
            {"view": "wrist_left",  "data": frame_b, "timestamp_ms": 1000},
        ],
        "proprioception": {"joint_positions": q, "gripper": [0.8]},
        "instruction": plan,
    },
}).json()["action_chunk"]

# 15 steps × 32 dof, covers 1.00 s at 15 Hz, joint_absolute
# send the next request before covers_seconds elapses or the arm starves
The same body serves world models. Repeat a view with increasing timestamps and it becomes a video. Isaac reads three; the world models read one and imagine the rest — Cosmos3 Edge seventeen frames ahead, DreamZero thirty-three. Send fewer than a model reads and the earliest frame is repeated to fill the window — and the response says so in warnings, because padding that happens quietly is the hardest kind of wrong to find.

What one GPU carries

Weight and frames read, published the same way for every model. Vendors measure latency on whatever hardware they own, so their figures compare machines as much as models.

ModelFamilyActionContextParameters
Physical Intelligencepi05-droidVLA 32d × 15 @ 15 Hz1 frame 4.14 B
Robbyantlingbot-vla-v2-6bVLA 55d × 25 @ 30 Hz1 frame 6.38 B
Xiaomixiaomi-robotics-1-5bVLA 75d × 20 @ 25 Hz1 frame 5 B
Perceptron AIisaac-0-5VLA 32d × 20 @ 25 Hz3 frames 36 B
NVIDIAgroot-n1-7-3bVLA 32d × 16 @ 30 Hz1 frame 3 B
NVIDIAcosmos3-edge-policy-droidWAM 8d × 16 @ 15 Hz1 frame, 17 imagined 3.86 B
NVIDIA GEARdreamzero-agibotWAM 32d × 48 @ 30 Hz1 frame, 33 imagined 14 B

What we deliberately do not do

No retry loop, no failure detector, no sub-goal scheduler. Those depend on things only you know — whether the task counts as finished, whether the scene can be reset, how many attempts are worth paying for. Anthropic measured a supervisor placed at the action layer performing worse than the policy alone, because it overrode the policy more often than was warranted. We route, meter, and translate. The loop is yours.