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

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 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 ```yaml 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.

    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.

    Requires a library of primitives (grasp, navigate, etc.). Does not perform low-level path planning or IK. Mandatory thresholds for battery and localization confidence apply by default.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 months ago

    Permissions

    No special permissions declared or detected

    Listed2 months ago

    What's inside

    Frequently Asked Questions

    This skill acts as a middleware planner that converts high-level human intent into structured, machine-executable YAML plans, complete with mandatory safety gates and perception checks to prevent hardware damage.

    No, this skill focuses on task-level logic; it requires your robot to have an existing library of atomic primitives (like 'move_to' or 'grasp') and handles the sequencing and safety monitoring between them.

    The skill is platform-agnostic and produces standardized YAML outputs designed for easy integration with ROS2 Action Servers, Behavior Trees, or custom state machine controllers.

    Every generated plan includes 'perception gates'—pre-conditions and post-conditions that the robot must verify through its sensors before proceeding to the next step, ensuring it doesn't attempt actions in unsafe or invalid states.

    You will receive the core task planning agent, a schema for defining your robot's specific atomic primitives, and a set of simulation scenario templates to validate your plans before running them on physical hardware.

    Yes, the skill includes a multi-tier recovery logic feature that automatically generates contingency steps, such as retries or operator escalations, if a perception check fails during a mission.

    New in Agents & Orchestration