physical robot task planner

    1

    Translates natural language missions into structured robot task plans with safety gates and perception checks.

    $5

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    0 installsSecurity scanned

    Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIGitHub CopilotGitHub CopilotGemini CLIGemini CLI+20 more

    physical robot task planner

    Example session with this skill installed

    Go to the laboratory station, pick up the glass beaker, and place it inside the autoclave for sterilization. Avoid any spills or high-velocity movements.

    • Read your context and instructions
    • Compiled the physical robot task

    I have decomposed the mission into a structured task plan. The plan includes perception gates for beaker detection and force-contact verification, along with velocity constraints to prevent spills.

    Robot Task Plan

    mission: "Go to the laboratory station, pick up the glass beaker, and place it inside the autoclave for sterilization."
goal_summary: "Navigate to station, grasp beaker, navigate to autoclave, release beaker."
capabilities_required: [navigation, perception, manipulation]
preconditions: [robot_battery > 20%, localization_confidence > 0.9, gripper_empty]
perception_checks:
  - id: detect_beaker
    type: object_detection
    target: "glass beaker"
    required_confidence: 0.95
    timeout_ms: 5000
    recovery: reacquire_state
  - id: verify_grasp
    type: force_contact
    target: "gripper"
    required_confidence: 0.8
    timeout_ms: 1000
    recovery: retry_locally
  - id: detect_autoclave
    type: scene_state
    target: "autoclave_interior"
    required_confidence: 0.9
    timeout_ms: 4000
    recovery: halt
actions:
  - id: nav_to_lab
    primitive: navigation
    parameters: {target_pose: "lab_station_alpha", avoidance_mode: "conservative"}
    assigned_capability: navigation
    perception_gates: {before: [localize_self], after: [detect_beaker]}
    safety_constraints: [max_speed < 0.3 m/s]
    retries: {max_attempts: 3, on_failure: abort_and_escalate}
  - id: grasp_beaker
    primitive: arm_move + grasp
    parameters: {object_id: "beaker_01", gripper_pressure: 2.0}
    assigned_capability: manipulation
    perception_gates: {before: [detect_beaker], after: [verify_grasp]}
    safety_constraints: [max_joint_velocity < 0.1 rad/s]
    retries: {max_attempts: 2, on_failure: retry_different_approach}
  - id: nav_to_autoclave
    primitive: navigation
    parameters: {target_pose: "autoclave_entry"}
    assigned_capability: navigation
    perception_gates: {before: [verify_grasp], after: [detect_autoclave]}
    safety_constraints: [max_acceleration < 0.1 m/s^2]
    retries: {max_attempts: 3, on_failure: halt}
  - id: place_in_autoclave
    primitive: release
    parameters: {gripper_width: 0.08}
    assigned_capability: manipulation
    perception_gates: {before: [detect_autoclave], after: [verify_release]}
    safety_constraints: [force_limit < 5.0 N]
    retries: {max_attempts: 2, on_failure: escalate}
constraints: [no_spills, max_vibration_level < 0.05g, total_timeout_ms < 120000]
safety_gates:
  - {type: collision_watchdog, monitor: "lidar_proximity", threshold: 0.1, response: halt}
  - {type: force_limit, monitor: "wrist_fts", threshold: 8.0, response: recover}
verification:
  step: final_success_check
  method: "product_of_checks (beaker_in_autoclave AND autoclave_door_clear)"
  expected_outcome: "true"
recovery_behaviors:
  - {trigger: "grasp_failure", behavior: "reinitialize_pose", max_trigger_count: 2, escalate_after: 3}
simulation_tests:
  - test_id: lab_sim_01
    scenario: "Beaker is slightly offset from expected coordinates"
    expected_plan_steps: [nav_to_lab, detect_beaker, grasp_beaker]
    assertion: "Perception gate triggers reacquire_state before grasp attempt"
success_conditions: [beaker_status == "placed_in_autoclave", robot_safe_state == true]

    Next steps

    1. Validate the generated YAML against your robot's middleware executor (e.g., ROS2 BehaviorTree).
    2. Run the lab_sim_01 scenario in your physics-based simulator (Gazebo/Isaac Sim).
    3. Confirm the force-contact thresholds align with your gripper's hardware specs.

    Connects securely to your tools. The creator never sees your data.

    What you get

    Decompose complex missions into verifiable atomic primitives.Automate safety gate integration for physical hardware operations.Generate robust recovery behaviors for uncertain environments.Standardize robot task logic across manipulation and navigation.

    About this skill

    The problem

    Translating vague human instructions into safe, deterministic robot control sequences is error-prone. Without explicit perception gates and safety constraints, physical hardware risks collision or mission failure when environment conditions change.

    What it does

    • Decomposes natural language missions into atomic primitives like navigation, grasping, and docking.
    • Generates a structured YAML plan with mandatory perception checks before and after every physical action.
    • Integrates safety gates for collision watchdogs, force limits, and localization deadbands.
    • Defines multi-tier recovery behaviors, including bounded retries, backtracking, and operator escalation.
    • Produces simulation scenarios to validate plan coherence before deployment to hardware.

    Why this beats prompting it yourself

    Generic LLM prompts often ignore physical constraints, leading to "hallucinated" actions that skip vital state verification. This skill enforces a strict schema that requires deterministic success conditions and safety monitors for every step, ensuring the output is actually executable by a robot controller.

    Use cases

    • Autonomous warehouse picking and sorting missions.
    • Mobile robot navigation and charging dock routines.
    • Automated hardware inspection and sensor data logging.
    • Force-sensitive manipulation tasks like opening doors or rotating valves.

    Known limitations

    Requires a predefined library of atomic primitives and capability mappings. It does not perform real-time path planning or inverse kinematics, focusing instead on high-level task logic.

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean 21 days ago

    • Passed all security checks, Safe to install

    Listed21 days ago

    What's inside

    Frequently Asked Questions