playbooks

home / skills / plurigrid / asi / kbot-humanoid

kbot-humanoid skill

/skills/kbot-humanoid

This skill helps you configure and deploy K-Bot humanoid hardware, MJCF models, and workflows for reliable robotics experiments.

npx playbooks add skill plurigrid/asi --skill kbot-humanoid

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
6.1 KB
---
name: kbot-humanoid
description: K-Bot humanoid robot platform - hardware specs, MJCF models, and deployment configurations. The flagship K-Scale humanoid robot.
version: 1.0.0
category: robotics-platform
author: K-Scale Labs
source: kscalelabs/kbot
license: MIT
trit: -1
trit_label: MINUS
color: "#5B45C2"
verified: false
featured: true
---

# K-Bot Humanoid Skill

**Trit**: -1 (MINUS - specification/verification)
**Color**: #5B45C2 (Purple)
**URI**: skill://kbot-humanoid#5B45C2

## Overview

K-Bot is K-Scale Labs' flagship humanoid robot platform. This skill covers hardware specifications, MJCF model configurations, and deployment workflows.

## Robot Specifications

```
┌────────────────────────────────────────────────────────────────┐
│                      K-BOT HUMANOID                            │
├────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Height: ~1.4m                                                 │
│  Weight: ~30kg                                                 │
│  DOF: 20+ joints                                               │
│                                                                 │
│  Actuators:                                                     │
│  ├── Robstride motors (custom driver)                          │
│  ├── Position/velocity/torque control                          │
│  └── ~40 Nm peak torque per joint                              │
│                                                                 │
│  Sensors:                                                       │
│  ├── IMU (6-axis)                                              │
│  ├── Joint encoders                                            │
│  ├── Cameras (RGB)                                             │
│  └── Force sensors (feet)                                      │
│                                                                 │
│  Compute:                                                       │
│  ├── Onboard: Jetson/custom                                    │
│  └── Inference: Policy runs at 50-100 Hz                       │
│                                                                 │
└────────────────────────────────────────────────────────────────┘
```

## MJCF Model

```xml
<!-- kbot.mjcf excerpt -->
<mujoco model="kbot">
  <compiler angle="radian" meshdir="meshes"/>
  
  <default>
    <joint damping="0.5" armature="0.01"/>
    <geom friction="1 0.005 0.001" condim="3"/>
  </default>
  
  <worldbody>
    <body name="torso" pos="0 0 1.0">
      <freejoint name="root"/>
      <geom type="mesh" mesh="torso"/>
      
      <!-- Legs -->
      <body name="hip_l" pos="0 0.1 0">
        <joint name="hip_yaw_l" type="hinge" axis="0 0 1"/>
        <joint name="hip_roll_l" type="hinge" axis="1 0 0"/>
        <joint name="hip_pitch_l" type="hinge" axis="0 1 0"/>
        <!-- ... -->
      </body>
      
      <!-- Arms -->
      <body name="shoulder_l" pos="0 0.2 0.4">
        <joint name="shoulder_pitch_l" type="hinge" axis="0 1 0"/>
        <joint name="shoulder_roll_l" type="hinge" axis="1 0 0"/>
        <!-- ... -->
      </body>
    </body>
  </worldbody>
  
  <actuator>
    <position name="hip_yaw_l_pos" joint="hip_yaw_l" kp="100"/>
    <position name="hip_roll_l_pos" joint="hip_roll_l" kp="100"/>
    <!-- ... -->
  </actuator>
</mujoco>
```

## Deployment Pipeline

```
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   KSIM      │───▶│   Policy    │───▶│   KOS       │───▶│   K-Bot     │
│   Training  │    │   Export    │    │   Firmware  │    │   Hardware  │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
       │                  │                  │                  │
       ▼                  ▼                  ▼                  ▼
   PPO/AMP in        ONNX/JIT           gRPC actuator      Real robot
   MJX sim           conversion         commands            execution
```

## Training with KSIM

```python
from ksim.robots.kbot import KBotConfig
from ksim import PPOTask

class KBotWalking(PPOTask):
    robot = KBotConfig(
        model_path="kbot-headless.mjcf",
        joint_names=KBotConfig.DEFAULT_JOINTS,
        actuator_config={
            "kp": 100.0,
            "kd": 10.0,
            "torque_limit": 40.0,
        }
    )
```

## GF(3) Triads

```
kbot-humanoid (-1) ⊗ kos-firmware (+1) ⊗ mujoco-scenes (0) = 0 ✓
kbot-humanoid (-1) ⊗ topos-generate (+1) ⊗ ksim-gym (0) = 0 ✓
```

## Related Skills

- `ksim-rl` (-1): RL training for K-Bot
- `kos-firmware` (+1): Firmware for K-Bot deployment
- `zeroth-bot` (-1): Smaller 3D-printed platform
- `evla-vla` (-1): VLA for manipulation tasks

## References

```bibtex
@misc{kbot2024,
  title={K-Bot: Open-Source Humanoid Robot Platform},
  author={K-Scale Labs},
  year={2024},
  url={https://github.com/kscalelabs/kbot}
}
```


## SDF Interleaving

This skill connects to **Software Design for Flexibility** (Hanson & Sussman, 2021):

### Primary Chapter: 10. Adventure Game Example

**Concepts**: autonomous agent, game, synthesis

### GF(3) Balanced Triad

```
kbot-humanoid (○) + SDF.Ch10 (+) + [balancer] (−) = 0
```

**Skill Trit**: 0 (ERGODIC - coordination)


### Connection Pattern

Adventure games synthesize techniques. This skill integrates multiple patterns.

Overview

This skill documents the K-Bot humanoid platform: hardware specs, MJCF robot models, and deployment workflows for simulation-to-hardware pipelines. It targets engineers and researchers who build, train, and deploy control policies for the K-Scale K-Bot. The content consolidates actuator/sensor details, a representative MJCF model, and a recommended training and firmware export pipeline.

How this skill works

The skill inspects and describes the physical and simulated K-Bot: measurements, actuators, sensors, compute, and control loop rates. It includes an MJCF model excerpt that maps joints, bodies, and position actuators to real hardware joints. The deployment pipeline shows how policies trained in KSIM/MuJoCo convert to ONNX/JIT and then to gRPC actuator commands via KOS firmware for real-robot execution.

When to use it

  • Designing or validating control policies for K-Bot in simulation
  • Preparing MJCF models or tuning joint and actuator parameters
  • Exporting trained policies for onboard inference and firmware integration
  • Planning simulation-to-hardware deployment and testing
  • Documenting hardware specs for integration with higher-level stacks

Best practices

  • Keep MJCF joint names and actuator KP/KD consistent with firmware mappings
  • Validate sensor timing and inference rates (50–100 Hz) in both sim and hardware
  • Use torque/position limits in sim to match physical actuator constraints (~40 Nm)
  • Export policies to deterministic formats (ONNX/JIT) and test with firmware gRPC in a staging environment
  • Log and replay sensor and actuator streams when diagnosing sim-to-hardware discrepancies

Example use cases

  • Train a walking PPO policy in KSIM using the provided KBotConfig and MJCF model
  • Tune actuator gains and torque limits in simulation to avoid hardware saturation
  • Export a trained policy as ONNX and run it through KOS firmware to actuate a real K-Bot
  • Use the MJCF excerpt as a starting point for building more detailed robot visuals or collision geometry
  • Integrate K-Bot into a larger system that requires known DOF, sensor modalities, and onboard compute constraints

FAQ

What is the recommended control loop rate?

Policy inference and control should run at 50–100 Hz to match onboard compute and actuator responsiveness.

How do I match simulation torque to the real robot?

Set actuator torque limits and KP/KD in MJCF to the hardware values (e.g., ~40 Nm peak torque) and validate with low-risk tests on hardware using conservative gains.