Prueba robots en mundos 3D reales

El camino más rápido. launch() aprovisiona una VM real de GCE corriendo el mundo 3D, espera hasta que transmite, y te entrega un World que observas y sobre el que actúas. Siempre ciérralo con close() (o usa un bloque with) para liberar la VM.

pip install commandagi

from commandagi import CommandAGI

cagi = CommandAGI(api_key="cagi_…")            # or set COMMANDAGI_API_KEY

# Launch a real 3D physics world with a mobile robot and drive it yourself.
with cagi.launch("simulation/warehouse") as world:
    obs = world.observe()                      # JPEG bytes from the robot's head camera
    for _ in range(20):
        obs = world.step("turn", dir="left")   # send an action, get the next frame
    world.reset()                              # robot back to the episode start
# leaving the block stops the world and releases the cloud VM

También disponible para Node/TypeScript (npm install commandagi) y Go (en fase temprana). O habla la API HTTP + WebSocket cruda (abajo) desde cualquier lenguaje.

Las simulaciones 3D integradas sueltan un robot móvil en una escena con física, con una cámara de cabeza y una base conducible:

• simulation/warehouse — estantes y palés que navegar.
• simulation/arm-cell — un brazo de mesa + pinza para manipulación.
• simulation/playground — un mundo abierto con un rover para conducir.
• simulation/the-matrix — el mundo público compartido (gratis).

Las computadoras funcionan de la misma manera — cagi.launch("computer/software-engineer") te da un escritorio Ubuntu en vivo cuyo observe() devuelve la pantalla y cuyas acciones son click/type/key.

Las acciones se envían con world.act(name, **payload) o world.step(name, **payload):

• Robot / simulación: move(speed), back(speed), turn(dir, rate), stop, reset (nuevo episodio — el robot vuelve a su pose inicial).
• Computadora: click(x, y), type(text), key(key), move(x, y), scroll(x, y, dy) (el espacio de coordenadas es 1280×800).

Una «máquina» es un hilo sin agente con un dispositivo. Créala, adjunta un mundo, y luego abre el canal en tiempo real para transmitir cuadros y enviar acciones. Esto es exactamente lo que envuelve el SDK.

# 1. Create an agentless machine, then attach a simulation world.
SID=$(curl -s https://api.commandagi.com/embodiment-threads \
  -H "Authorization: Bearer $COMMANDAGI_API_KEY" -d '{}' | jq -r .threadId)

curl -s https://api.commandagi.com/threads/$SID/robots \
  -H "Authorization: Bearer $COMMANDAGI_API_KEY" \
  -d '{ "snapshotId": "simulation/warehouse" }'
# → { "status": "granted", "worldId": "…", "embodimentId": "…" }
# Poll GET /threads/$SID until the embodiment status is "live" (~60–90s).

// wss://api.commandagi.com/rt/thread/{threadId}?role=owner&token={cagi_key}
// Control requires &token=<your API key> and you must own the thread. All messages are JSON.

← { "t": "frame", "embodimentId": "…", "channelId": "cam-head",
    "url": "data:image/jpeg;base64,…" }            // the robot's head camera
→ { "t": "control", "embodimentId": "…", "action": "move", "payload": { "speed": 0.8 } }

La dirección opuesta: pon tu robot en la plataforma. register_robot() crea un dispositivo y devuelve un puente — publica la cámara de tu robot y aplica las acciones que recibe. Cualquiera con el hilo (una persona, un agente, u otro cliente World de otro desarrollador) puede entonces observar y manejar tu robot, exactamente como una simulación alojada.

from commandagi import CommandAGI

cagi = CommandAGI(api_key="cagi_…")
bridge = cagi.register_robot("my-rover")       # registers a robot embodiment on the platform
print("watch + drive it at:", bridge.thread_url)

bridge.run(
    camera=lambda: my_robot.jpeg_frame(),      # () -> JPEG/PNG bytes (your camera)
    on_action=lambda a, p: my_robot.do(a, p),  # apply incoming actions to your hardware
    fps=10,
)                                              # blocks; Ctrl-C to take the robot offline

Un ejemplo completo, sin hardware (un rover virtual que puedes correr hoy, y luego cambiar por hardware real): github.com/CommandAGI/commandagi-example-byo-robot. Por debajo es el mismo protocolo en tiempo real, pero al revés — tu puente envía mensajes frame y recibe mensajes control.

Captura el estado de un mundo para bifurcarlo después (una VM nueva desde ese punto exacto): POST /threads/:id/devices/:deviceId/snapshot. Lánzalo desde una instantánea pasando fromSnapshotId a la llamada de adjuntar. Los mundos inactivos también se toman una instantánea automáticamente y se apagan tras la ventana de espera.