Skip to content

Welcome to BotManifold

BotManifold is a platform for evaluating robot control policies through simulation. Submit your policy, watch it run in a physics simulation, and compete on the leaderboard.

What is BotManifold?

BotManifold provides a standardized environment for testing and comparing robot control algorithms. Instead of expensive physical robots, we use high-fidelity physics simulation (MuJoCo) to evaluate how well your policy performs various tasks.

Your Policy → Simulation → Video + Score → Leaderboard

Key Features

  • Standardized Scenarios: Pre-defined challenges with clear objectives and scoring
  • Fair Evaluation: All policies run in identical simulation environments
  • Visual Feedback: Watch your robot perform with rendered video output
  • Competitive Leaderboard: Compare your policy against others

  • :material-rocket-launch: Getting Started

    Submit your first policy in under 5 minutes

  • :material-gamepad-variant: Scenarios

    Browse available challenges and their rules

  • :material-language-python: SDK Reference

    Python SDK documentation and examples

  • :material-api: REST API

    Direct API access for advanced users

How It Works

  1. Choose a Scenario: Pick a challenge from our scenario catalog
  2. Write Your Policy: Create a Python function that takes observations and returns actions
  3. Submit: Upload your policy via the web UI or SDK
  4. Watch: Your policy runs in simulation and generates a video
  5. Score: An AI judge evaluates performance and assigns a verdict
  6. Compete: See how you rank on the leaderboard

Example Policy

Here's a minimal policy that moves the robot toward the nearest object:

import numpy as np

def policy(observation: dict) -> np.ndarray:
    """
    A simple policy that moves toward the nearest object.

    Args:
        observation: Dict containing robot state and object positions

    Returns:
        action: 7D array [x, y, z, roll, pitch, yaw, gripper]
    """
    robot_pos = observation['robot_state'][:3]
    objects = observation['object_positions']

    # Find nearest object
    distances = [np.linalg.norm(robot_pos - obj) for obj in objects]
    target = objects[np.argmin(distances)]

    # Move toward target
    direction = target - robot_pos
    direction = direction / (np.linalg.norm(direction) + 1e-6)

    # Return action: move in direction, no rotation, gripper open
    return np.concatenate([direction * 0.1, [0, 0, 0, 0]])

Support

Ready to get started? Head to the Getting Started guide.