Call your model

Inference by name

~2 min read

You trained a model on nothing but your own demonstrations. Now you call it — by name — and read what it sends back.

From the CLI

newt run takes a model tag, authenticates, loads a real bundled observation, and calls your model once against prod:

newt run <your-model-tag>

It prints the resolved model, the round-trip latency, and the action-chunk shape. No robot is connected and nothing moves — this is a live inference against your model, not a robot demo.

From Python

The same call, in four lines:

from newt import Robot, snapshots

robot = Robot()
obs = snapshots.load("red_cube")
response = robot.infer(obs)

snapshots.load("red_cube") hands you a real recorded SO-101 observation — six-axis joint state plus the two camera frames — already in your model's contract shape. robot.infer() sends that one observation and returns an InferenceResponse. Print it:

print(response)
# action_chunk (30, 6): shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper | latency 261ms

Your weights, answering by name

That line is what the whole course was built toward. Thirty steps of six-axis motion — shoulder_pan through gripper, each column named by your model's own contract instead of guessed from a bare float index — returned by weights that have seen nothing but the demonstrations you recorded. Your model, answering you by name.

Be precise about what that proves. The software chain is end to end: the model loads, answers, and returns correctly shaped chunks for your task. Putting those chunks onto the physical arm is the run-loop's job — the next chapter.

Not the only door

Under robot.infer() and robot.run(), the call is a single WebSocket connection carrying msgpack frames — your observation out, an action chunk back. Nothing about that wire is SDK-only: a client in any language that can open a WebSocket and encode msgpack can hold the same connection, log every frame, or replay a saved call later.

Run it yourself

→ Call the model — the full robot.infer() call and every field of the InferenceResponse — with model discovery for how the registry resolves your tag into a contract, and WebSocket vs HTTP if you're building your own client instead of the SDK.

The next chapter puts these chunks onto the arm.