Executing Feature Mating logo

Executing Feature Mating

Organization
graph-robots
executing-feature-mating

Executes a supplied feature-mating plan for an already-held rigid object - collision-aware planner legs tracked to millimetre precision, Cartesian servo for short corrections and fixture crossings, contact-controlled seating - then releases and retreats along the fixture axis or straight up. Use when the goal is a constrained mate such as a loop over a shaft, a shaft into an aperture, or a handle seated on a support; use transporting-objects for ordinary container drops.

Overview

Publishergraph-robots
Repositoryopen-robot-skills
Skill nameexecuting-feature-mating
Stars
58
Forks
8
Bundled files
2
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 2 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by graph-robots on GitHub. Read the source before you install it.

Installation

Install the Executing Feature Mating AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/graph-robots/open-robot-skills/tree/main/skills/executing-feature-mating
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/graph-robots/open-robot-skills.git /tmp/open-robot-skills
mkdir -p .claude/skills
cp -r /tmp/open-robot-skills/skills/executing-feature-mating .claude/skills/executing-feature-mating
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Executing Feature Mating in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Executing Feature Mating on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Executing Feature Mating is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Both scripts also return a report -- waypoint_reports (one record per waypoint) from execute_placement_plan, release_report from release_and_retract -- stated here rather than under produces_outputs because the type registry names no bare list or record. A contact_profile (one per object kind) overrides the executor's tolerances one key at a time; arm_id names the hand on a bimanual cell; verify_cartesian and measure_errors turn on the TCP re-reads that fill the reports (they are recorded tool calls and are off unless asked). robot.describe_arm is called only under verify_cartesian, to learn whether the solver honours roll.

executing-feature-mating

Execute a previously computed feature-mating plan for an already-grasped rigid object, then release it. The upstream localization/planning node supplies ordered poses; this skill does not locate a fixture or compute mating poses and does not depend on object names, task names, simulator state, or evaluator predicates.

Use this instead of transporting-objects when the goal is a constrained mate, not a drop into a volume or onto a broad surface. Examples are putting a loop over a rod, inserting a rod through a loop, or lowering a handle gap onto a support point.

Recommended subgraphs

text
execute_placement_plan -> seated
release_and_retract    -> released

The two scripts are usually two subgraphs so the graph can settle, verify, or re-observe between engagement and release; a single subgraph running both in order is also valid.

execute_placement_plan

Runs scripts/execute_placement_plan.py with placement_plan = Ref("in.placement_plan"). The plan carries its collision world and attached-object spheres, and every waypoint is a typed record {pose, mode, allow_start_contact?, allow_goal_contact?, contact_margin?}:

  • planned_joint — collision-aware transit via motion.plan_to_pose.
  • planned_linear — orientation-locked straight leg via motion.plan_linear.
  • cartesian_cross — a short local segment across a fixture mouth, driven by the robot's Cartesian servo so an incidental touch does not stop it.
  • contact_seat — the final intended-contact leg via robot.move_cartesian_until_contact, which stops when the target is reached or measured TCP progress stalls.

Before each planned leg the script reads robot.get_ee_pose: a waypoint within 1.5 mm and 2 degrees is skipped (the planner would otherwise be asked for a zero-motion problem its start-contact check can reject), and a planned_joint correction of at most 3 cm with matching orientation is served through robot.go_to_pose_cartesian rather than a fresh joint-space trajectory that can make a loosely held object slip. Larger legs are planned with up to three attempts (the sampled planner can miss a narrow corridor on one seed) and executed with a 2 mm tracking tolerance and a 60-step-per-waypoint budget. A planner refusal raises; route it through on_error: blocked. Output: final_pose: Se3Pose, the last waypoint pose.

release_and_retract

Runs scripts/release_and_retract.py with final_pose (the mate pose the object was released at) and, for a fixture mate, retreat_axis: Vec3 (the fixture axis), attached_object: AttachedObject and relation: string. It opens the gripper (open_settle_steps, default 80), retreats and then waits settle_steps (default 120) so a freshly released object stops swinging before the graph reports success.

  • With retreat_axis: the retreat runs along the axis (reversed for shaft_into_aperture, tip_through_aperture and insert_through, where the feature went into the fixture) by max(retract_m or 0.08, farthest attached sphere + 1 cm) and lifts by half that distance so the open fingers clear the released object.
  • Without retreat_axis: a plain vertical retreat of retract_m (or 0.08 m when unset), still never less than the attached extent plus 1 cm.

Boundaries

  • This skill does not infer fixture geometry or choose feature landmarks.
  • Do not query sim.*, cameras, rewards, or goal predicates inside this skill.
  • Preserve the waypoint order. Insertion plans encode clearance first, mating second, seating third; shortcutting between them can cross solid geometry.
  • Never fall back to unchecked robot motion after a collision-aware planner rejects a waypoint.
  • Use transporting-objects for bins, baskets, and unconstrained surface drops.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Executing Feature Mating AI skill do?

Executes a supplied feature-mating plan for an already-held rigid object - collision-aware planner legs tracked to millimetre precision, Cartesian servo for short corrections and fixture crossings, contact-controlled seating - then releases and retreats along the fixture axis or straight up. Use when the goal is a constrained mate such as a loop over a shaft, a shaft into an aperture, or a handle seated on a support; use transporting-objects for ordinary container drops.

Why use Executing Feature Mating on TypingMind?

Because you install it once and use it with any model. Executing Feature Mating is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Executing Feature Mating in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/graph-robots/open-robot-skills/tree/main/skills/executing-feature-mating. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Executing Feature Mating?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Executing Feature Mating?

As many as you like. As long as a model supports skills, you can use Executing Feature Mating with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Executing Feature Mating AI skill free?

Yes. It is published on GitHub by graph-robots under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇