What makes skill-graph-for-analogical-reasoning notable?

970 downloads. Trust evidence available

How should skill-graph-for-analogical-reasoning be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

skill-graph-for-analogical-reasoning

Skill Graph for Analogical Reasoning. Build a graph over SKILL.md skills, choose one primary skill, and retrieve complementary support instead of naively att...

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

970

Updated

Oct 12, 2026

Version

1.0.4

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 970 downloads reported by the source. Last updated 10/12/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 12, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 12, 2026
Adoption signal: 970 downloadsadoption · observed Oct 12, 2026
Latest release: 1.0.4release · observed May 28, 2026
Handshake status: UNKNOWNsecurity

What changed

Newest first. Only changes that point at a source are listed.

Release 1.0.4release
- Added _meta.json for enhanced metadata support. - Improved guidance for handling supporting skills: only use a supporting skill if it provides clear, non-conflicting value for the current task. - Clarified instructions in "How to interpret results" for better adoption of skill roles.
Observed May 28, 2026 · source

Install and run

Setup complexity: low.

clawhub skill install s175hh79c5hqmmg8b7ec9gq43183kws2:skill-graph-for-analogical-reasoning

Install using `clawhub skill install s175hh79c5hqmmg8b7ec9gq43183kws2:skill-graph-for-analogical-reasoning` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/h4444433333/skill-graph-for-analogical-reasoning before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-h4444433333-skill-graph-for-analogical-reasoning/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

79,206 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: grap-skill
description: Skill Graph for Analogical Reasoning. Build a graph over SKILL.md skills, choose one primary skill, and retrieve complementary support instead of naively attaching top similar skills.
user-invocable: true
metadata: {"openclaw":{"requires":{"bins":["python3"]}}}
---

# Skill Graph for Analogical Reasoning

Use this skill when the user wants to work with a **graph skill** over local `SKILL.md` folders.

This skill is for:

- graph-based skill indexing
- analogical reasoning and transfer
- one primary skill plus complementary support
- avoiding naive "top similar skills" retrieval

The full Python package and CLI for this project are available in the GitHub repository.

## What this skill does

This skill wraps the `grap-skill` capability.

It supports three primary commands:

- `/grap-skill build`
- `/grap-skill query`
- `/grap-skill look`

## Core rule

- `build` is the only command that may scan skill folders and update the graph.
- `query` and `look` are read-only against an existing `graph.json`.
- Do not silently rebuild during `query`.

## Code-backed usage

This skill is allowed to call code.

The `python3 {baseDir}/scripts/run_grap_skill.py ...` commands below are the
stable execution entrypoints intended for the skill runtime and for model-driven
tool use. They let the skill call a controlled wrapper inside the installed
skill bundle instead of relying on ad hoc shell reconstruction.

Preferred execution order:

1. Use the helper script in `{baseDir}/scripts/run_grap_skill.py`.
2. If the Python package is installed in the current interpreter, the wrapper may use `python -m auto_grap_skill`.
3. If neither bundled code nor the local Python package is available, direct the user to the GitHub repository for this project and install the Python package first.

## Primary commands

### `/grap-skill build`

```bash
python3 {baseDir}/scripts/run_grap_skill.py build --source <skills_dir> --output <graph_dir>
```

Example:

```bash
python3 {baseDir}/scripts/run_grap_skill.py build --source ./skills-main --output ./.grap-skill
```

### `/grap-skill query`

```bash
python3 {baseDir}/scripts/run_grap_skill.py query "<task text>" --graph <graph_json_path>
```

Example:

```bash
python3 {baseDir}/scripts/run_grap_skill.py query "edit a docx file with comments" --graph ./.grap-skill/graph.json
```

### `/grap-skill look`

```bash
python3 {baseDir}/scripts/run_grap_skill.py look --graph <graph_json_path> --output <html_path>
```

Example:

```bash
python3 {baseDir}/scripts/run_grap_skill.py look --graph ./.grap-skill/graph.json --output ./.grap-skill/graph-look.html
```

## How to interpret results

- `primary_skill` is the execution center.
- Always treat `primary_skill` as the default lead. Use a `supporting_skill` only if it adds clear missing coverage and does not conflict with or dilute the primary skill. If a suggested supporting skill is not actually helpful for the current task, do not adopt it.
- `supporting_skills

python-package/README.md

# Skill Graph for Analogical Reasoning

[![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](./LICENSE)

`Skill Graph for Analogical Reasoning` is a graph-powered retrieval engine for AgentSkills-compatible `SKILL.md` folders.

- pick one `primary_skill` as the execution center
- retrieve a small set of `supporting_skills` that add complementary value
- keep `similar_skills` separate from the default prompt context
- use the graph to support transfer, analogy, and non-redundant composition

This project is built for graph skill retrieval, analogical reasoning, and
cross-skill transfer over real skill folders.

## Highlights

- graph-based retrieval over `SKILL.md`
- one `primary_skill` plus complementary support
- not naive `top-k similar skills`
- read-only query over a persisted `graph.json`
- whole-graph HTML visualization with edge explanations
- code-backed ClawHub/OpenClaw skill bundle

## What You Get

- multiple skills say almost the same thing
- context gets wider but not smarter
- execution focus becomes weaker
- the model sees redundancy, not real analogy

- `primary_skill` answers: which skill should lead?
- `supporting_skills` answer: which skills fill what the primary skill does not cover?
- `fallback_skills` answer: which nearby options are substitutes rather than companions?
- `similar_skills` answer: what is graph-nearby, but should not be injected by default?

The graph is designed to separate leadership, support, fallback, and redundancy instead of collapsing everything into similarity.

## Quick Start

### Install

```bash
python3 -m venv .venv
./.venv/bin/python -m pip install -e .
```

### Build A Graph

```bash
./.venv/bin/grap-skill build --source ./skills-main --output ./.grap-skill
```

### Query The Graph

```bash
./.venv/bin/grap-skill query "edit a docx file with comments" --graph ./.grap-skill/graph.json
```

### Render The Graph

```bash
./.venv/bin/grap-skill look --graph ./.grap-skill/graph.json --output ./.grap-skill/graph-look.html
```

## Core Commands

### `build`

`build` is the only command allowed to scan skill folders and update the graph.

It currently:

- recursively scans `SKILL.md` and `skill.md`
- parses frontmatter and markdown instructions
- extracts descriptions, triggers, keywords, tool references, code references, and runtime constraints
- constructs a weakly supervised graph from those signals
- persists both a `similarity` view and a `complementarity` view into `graph.json`

`query` and `look` are read-only over the saved graph and do not silently rebuild.

### `query`

`query` selects a structured result instead of dumping a similarity list.

It returns:

- `primary_skill`
- `supporting_skills`
- `fallback_skills`
- `similar_skills`

The important part is how `supporting_skills` are selected.
They are not chosen by raw similarity.

They are scored by a balance of:

- `task_relevance`
- `complementarity`
- `execution_support`
- `redundancy_with_primary`

Current s

README.md

# Skill Graph for Analogical Reasoning

This is the ClawHub/OpenClaw skill bundle for the `Skill Graph for Analogical Reasoning` project.

It exposes the `grap-skill` capability as a skill-oriented interface around three main commands:

- `/grap-skill build`
- `/grap-skill query`
- `/grap-skill look`

## What this version is

This skill version is for users who want to use the graph capability through a skill workflow.

The full source code, Python package, and CLI live in the GitHub repository for this project.

## What this skill can do

- build a graph over local `SKILL.md` folders
- select one primary skill for a task
- retrieve complementary support instead of simply taking the top similar skills
- render the skill network as a visual graph

## Skill usage

- Use `/grap-skill build` to scan local skill folders and create a `graph.json`
- Use `/grap-skill query` to select one primary skill plus complementary support from an existing graph
- Use `/grap-skill look` to render the current graph as an HTML visualization

## Cross discovery

The GitHub repository is the main development version and the official Python
package source.

Use the GitHub version when you want:

- a full source checkout
- editable installs
- direct Python package development

Use this ClawHub/OpenClaw skill version when you want:

- `openclaw skills install skill-graph-for-analogical-reasoning`
- a skill-style wrapper around the packaged graph commands
- a bundle that can be installed into an OpenClaw workspace

_meta.json

{
  "ownerId": "kn76ts9v9tgsgadm8pww346n6h836dvn",
  "slug": "skill-graph-for-analogical-reasoning",
  "version": "1.0.4",
  "publishedAt": 1779936422457
}

reference.md

# Reference

## Project idea

Skill Graph for Analogical Reasoning builds a graph over `SKILL.md`-based skills and tries to retrieve skills the way a careful human would:

- one primary skill
- a few complementary supporting skills
- no naive pile of near-duplicate instructions

## Build algorithm

`build` extracts from each skill:

- description
- trigger phrases
- keywords
- tool/code references
- runtime constraints

Then it computes weakly supervised relations between skill pairs.

Stored views include:

- `similarity` — static closeness between skills
- `complementarity` — a proxy for "useful together without being redundant"

## Query algorithm

### Step 1: choose one primary skill

Primary-skill ranking uses signals such as:

- intent match
- trigger match
- object match
- readiness
- specificity
- lexical match

### Step 2: choose complementary support

Supporting-skill ranking uses:

- `task_relevance`
- `complementarity`
- `execution_support`
- `redundancy_with_primary` penalty

The goal is **not** to attach several highly similar skills.
The goal is to attach only the skills that actually add missing coverage.

## Look view

`look` renders the graph and lets the user switch between:

- `Similarity`
- `Complementarity`

Edges are colored from blue (`0`) to red (`1`) in the active view.

Github ReposUpdated 3d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.

MCPOPENCLAW

Github ReposUpdated 7mo agoRank 70

CopilotKit

The Frontend for Agents & Generative UI. React + Angular