Platform Surface

A product portal backed by developer infrastructure.

ISACAI brings the company website, API portal, skill schema, rosbridge integration patterns, demo workflows, and bilingual product documentation into one connected platform surface.

Internal API Portal

A companion API website for internal development, robot-agent integration, skill interfaces, and team-side documentation.

http://isacai.space

Open isacai.space

Company product website

Public narrative layer

Explains ISACAI, VLAClaw, product positioning, safety philosophy, roadmap, team, and cooperation paths.

Developer API website

Internal platform layer

Supports internal developers with API-oriented documentation and a clearer path from robot capability to agent integration.

Skill schema and examples

Execution contract

Defines how action groups, motion commands, sensor reads, and interaction behaviors become validated robot skills.

rosbridge integration design

Robot connectivity layer

Documents WebSocket JSON patterns for ROS2 topic subscription, command publishing, and future service calls.

Demo workflow library

Deployment workflow

Frames voice greeting, visual interaction, safe patrol, and developer integration as repeatable demo workflows.

Bilingual product materials

Product communication layer

Makes the platform understandable to labs, robot teams, education customers, OEM partners, and Hong Kong / mainland collaborators.

Developer API

Developer-friendly ROS2 integration through WebSocket JSON.

VLAClaw exposes example rosbridge and skill-call patterns so developers can subscribe to robot observations and invoke bounded behaviors without a full ROS2 host setup.

API Portal for internal development

The platform is paired with an API website for team documentation, robot-agent interfaces, skill calls, integration notes, and future SDK access.

http://isacai.space

Open API Portal
WebSocket endpoint: ws://robot_ip:9090Example interface. Topic names and message schemas are customizable per robot platform.
Subscribe IMU
{
  "op": "subscribe",
  "topic": "/imu_raw",
  "type": "sensor_msgs/Imu"
}
Subscribe Camera
{
  "op": "subscribe",
  "topic": "/usb_cam/image_raw",
  "type": "sensor_msgs/Image"
}
Publish Motion
{
  "op": "publish",
  "topic": "/puppy_control",
  "msg": {
    "action": "walk_forward",
    "duration": 1.5,
    "speed": 0.2
  }
}
Call Skill
{
  "skill": "sit_wave",
  "params": { "repeat_count": 1 },
  "safety_check": true
}
Python WebSocket client sketch
import json, websocket

ws = websocket.create_connection("ws://robot_ip:9090")
ws.send(json.dumps({
    "op": "subscribe",
    "topic": "/imu_raw",
    "type": "sensor_msgs/Imu"
}))

ws.send(json.dumps({
    "skill": "sit_wave",
    "params": {},
    "safety_check": True
}))
Skill Library

From robot actions to AI-callable skills.

A PuppyPi-style action group such as sit_wave.d6a can become a semantic skill that OpenClaw can call from natural language while Skill Server enforces safety conditions.

Quadruped Locomotion

stand_up()

Recover to a stable standing posture.

Requires no active motion.

walk_forward(distance, speed)

Move forward with bounded distance and speed.

Speed and obstacle checks.

turn_left(angle)

Rotate with a validated angle range.

IMU stability monitored.

Action Group Skills

sit_wave()

Play sit_wave.d6a for greeting.

Requires stable ground and not walking.

bow()

Run a pre-authored bow action group.

Only from safe posture.

dance()

Sequence validated action groups.

Interruptible by stop.

Perception Skills

get_camera_frame()

Read the current camera observation.

Read-only.

detect_person()

Run visual detection on camera frames.

No motion side effects.

read_imu_state()

Estimate stability and motion state.

Used before movement.

Interaction Skills

listen_command()

Capture voice command for OpenClaw.

Wake-word gated.

display_expression(emotion)

Show expression on a robot display.

Allowed during stationary or slow motion.

greet_user()

Speak, wave, and show a friendly expression.

Skill chain validated step by step.

skills.yaml example
sit_wave:
  type: action_group
  file: sit_wave.d6a
  description: Robot sits and waves one front leg.
  duration: 5.3
  safety:
    requires_stable_ground: true
    allow_while_walking: false

walk_forward:
  type: locomotion
  description: Move forward for a given duration and speed.
  parameters:
    duration: { type: number, min: 0.1, max: 5.0 }
    speed: { type: number, min: 0.05, max: 0.4 }
Natural language to skill plan
User: "Come over and say hello."
Plan:
  1. detect_person()
  2. walk_forward(duration=2.0, speed=0.25)
  3. stop()
  4. sit_wave()
  5. display_expression("happy")
Integration Workflow

A practical path from an existing ROS2 robot to an OpenClaw-controlled demo.

This is the implementation story customers and developers need: VLAClaw works with existing robot controllers and maps robot capabilities into observations and validated skills.

1

Audit robot interfaces

List ROS2 topics, services, action groups, sensor streams, and safety commands already available on the robot.

Topic map + control checklist
2

Enable rosbridge

Run rosbridge_websocket on the robot and expose a stable WebSocket endpoint for upper-computer access.

ws://robot_ip:9090 connection
3

Map observations

Normalize camera, IMU, radar, odometry, and status topics into OpenClaw-readable observation channels.

Observation adapter
4

Register skills

Convert motion commands, action groups, services, and interaction behaviors into skills with parameters and limits.

skills.yaml + registry
5

Run bounded demos

Start with single-command and short workflow demos before moving to multi-step planning.

Voice greeting / safe patrol demo
6

Measure and harden

Log latency, success rate, refusal behavior, recovery path, and feedback quality before deployment.

Mission logs + safety report
Resources

Engineering notes that make the platform feel reproducible.

The company portal carries product documentation, engineering notes, demo logs, and research observations, with space for future articles, cases, and release updates.

Engineering Note

How rosbridge makes ROS2 robots accessible to AI agents

A practical guide to WebSocket JSON, topic subscription, and service calls.

Demo Log

Turning sit_wave.d6a into an OpenClaw skill

How authored action groups become semantic, validated robot capabilities.

Research Note

Why VLA robots need skill-level control instead of direct joint prediction

A reliability-first argument for bounded robot skill orchestration.

FAQ

Platform questions, answered.

Key answers about VLAClaw, ROS2 integration, Skill Server boundaries, developer access, and deployment workflows.

Is VLAClaw a robot controller?

VLAClaw is an intelligent upper-computer and skill orchestration layer. Robot-side ROS2 nodes remain responsible for real-time motion and hardware control.

Does the AI directly output motor commands?

The model outputs skill choices and bounded parameters. Skill Server validates the command before ROS2 executes the underlying action.

Do developers need to install ROS2 on the host?

Not for the primary integration path. The host can connect through rosbridge WebSocket and JSON messages while the robot runs ROS2.

What can be evaluated first?

Teams can review the architecture, Skill API, rosbridge examples, action-group mapping, developer workflows, and demo runbooks, then connect the same contracts to robot-side ROS2 systems.

Which robots are easiest to support?

ROS2-enabled quadruped robots are the first target. Any robot with stable command interfaces, sensor topics, and emergency stop behavior is a candidate for integration.