GRID Docs | General Robotics

A skill is plain Python that drives your robot through GRID’s APIs. You develop it against a live robot in a generated notebook — no environment setup, because the CLI provisions the Python environment for you.

1. Open a dev session

In the GRID shell, run:

GRID # skill run --dev

Choose an online robot. The CLI opens a VS Code workspace in a GRID-managed folder under ~/.grid/sessions/ with dev.ipynb and the Python environment configured, and reuses it on later runs. Run the notebook’s connection cell, then write your code. You can also create Python files or additional notebooks in the editor; no existing script is needed to get started. To use your own project folder instead, pass its path:

GRID # skill run ./my-project --dev

The folder must already exist. You can also pass an existing file to open its containing folder. Direct execution and deployment still take a Python file: skill run my_skill.py or skill run my_skill.py --deploy. Each run asks you to choose an online robot in the GRID shell. To target a robot explicitly, add --robot <robot>; headless commands require this flag. The notebook connects using the robot you selected, for example:

from grid_nexus_client import make_robot

robot = make_robot("my-go2")
print(f"Connected: {robot}")

2. Find out what your robot can do

make_robot() returns a RemoteRobot. Its attributes are the robot’s own methods, discovered live when you connect — so the fastest way to see the surface is to ask it:

for name in robot.session.methods_info():
    print(f"  {name}")

Those methods come from the Robot interface, which is the same whether the robot is physical or simulated. A quadruped gets Quadruped, an arm gets Arm, and every robot gets the shared Robot methods like getState() and getImage().

3. Drive it

State, motion, and camera all work directly from notebook cells:

from grid_types import Velocity

robot.getState()

# standUp and moveByVelocity are a quadruped's. Every robot exposes its own
# methods — print them with robot.session.methods_info().
robot.standUp()
robot.moveByVelocity(Velocity(0.1, 0.0, 0.0), Velocity(0.0, 0.0, 0.0))

Motion cells move the robot physically. Make sure it has clearance, and run robot.shutdown() when you’re done — it releases the session cleanly.

Sensors, arms, and end effectors nest as attributes, so you can reach into a subcomponent the same way:

image = robot.getImage("front")
wrist = robot.left_arm.wrist_cam.getImage()

4. Add perception

Anything you capture can go straight to a hosted Cortex model. This finds a water bottle in the robot’s camera frame:

from grid_cortex_client import CortexClient

cortex = CortexClient()  # reads GRID_CORTEX_API_KEY from the environment
image = robot.getImage("front")
detections = cortex.run("owlv2", image_input=image, prompt="water bottle")
print(detections["scores"])

From there it’s ordinary Python — loop over frames, check a score threshold, and command the robot when you see what you’re looking for:

import time

robot.standUp()
while True:
    image = robot.getImage("front")
    detections = cortex.run("owlv2", image_input=image, prompt="water bottle")
    scores = detections.get("scores", [])
    if len(scores) > 0 and max(scores) > 0.3:
        robot.stop()
        break
    robot.moveByVelocity(Velocity(0.0, 0.0, 0.0), Velocity(0.0, 0.0, 0.4))
    time.sleep(0.5)

Where next

Every method your robot exposes: Robot interface
The full Cortex model catalog for perception in your skills: AI models
Calling models from Python: grid-cortex-client
Every shell command: CLI reference

Get Started

Simulation

Deployment

FAQ

Support

Your first skill

1. Open a dev session

2. Find out what your robot can do

3. Drive it

4. Add perception

Where next

​1. Open a dev session

​2. Find out what your robot can do

​3. Drive it

​4. Add perception

​Where next

1. Open a dev session

2. Find out what your robot can do

3. Drive it

4. Add perception

Where next