Assess Sensitivity logo

Assess Sensitivity

Organization
yogsoth-ai
assess-sensitivity

Perturb a specified input, assumption, model choice, analysis choice, or weight and measure sensitivity of a specified output; report convergence/instability, unstable regions, and dominant drivers.

Overview

Publisheryogsoth-ai
Repositoryde-anthropocentric-research-engine
Skill nameassess-sensitivity
Stars
505
Forks
43
Bundled files
Instructions only
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.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by yogsoth-ai on GitHub. Read the source before you install it.

Installation

Install the Assess Sensitivity 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/yogsoth-ai/de-anthropocentric-research-engine/tree/main/skills/assess-sensitivity
  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/yogsoth-ai/de-anthropocentric-research-engine.git /tmp/de-anthropocentric-research-engine
mkdir -p .claude/skills
cp -r /tmp/de-anthropocentric-research-engine/skills/assess-sensitivity .claude/skills/assess-sensitivity
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Assess Sensitivity 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 Assess Sensitivity 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 Assess Sensitivity 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.

assess-sensitivity

Purpose

Perturb a specified input, assumption, model choice, analysis choice, or weight and measure the resulting output sensitivity.

Input contract

yaml
required: [baseline_input, perturbation_axes, output, comparison_metric]
optional: [assumptions, perturbation_design, uncertainty_model, baseline_ranking]
constraints: [each perturbation is attributable to one declared axis; the output comparison metric is fixed before evaluation; preserve the caller's scale and direction]

Procedure

  1. Define the baseline input, output, perturbation axes, and comparison metric.
  2. Generate the caller-specified perturbation scenarios, including weight or leave-one-out variants where applicable.
  3. Recompute the output for each scenario and retain the scenario-level evidence.
  4. Compare scenarios, identify unstable regions and dominant drivers, and classify convergence or instability.
  5. Return a sensitivity report with rankings, effect magnitudes, and rationale.

Output contract

yaml
produces: [sensitivity_report, scenario_results, instability_regions, dominant_drivers, stability_verdict]
delta_fields: [findings, evidence_updates, decisions, uncertainties]

Quality gates

  • Preserve source weight perturbation of +/-20% per dimension, weight-vector sum 1.0 with +/-0.001 tolerance, at least 4 scenarios, and stability labels stable/sensitive/unstable with $\tau$ bands >=0.8, 0.5-<0.8, and <0.5.
  • Rank comparison reports at least one Kendall $\tau$ or Spearman $\rho$ and all alternatives differing by >=2 positions.
  • Conclusion sensitivity rates every assumption, identifies critical assumptions, reports interaction effects, and gives an overall robustness rating.
  • Fragility index retains 0.0 as robust and 1.0 as extremely fragile; do not reinterpret it as a probability.

Parameterization

The caller must provide the baseline object/output, perturbable axes, scenario generator or bounds, comparison metric, stability labels, and any fixed statistical bands. For ranking calls provide the normalized weight vector and scoring matrix; for conclusion calls provide assumptions and challenged variants; for meta-analysis calls provide included studies, outliers, and subgroup variables.

Failure and counterexamples

Reject when the baseline is undefined, scenarios change more than one undeclared axis, the comparison metric is missing, or a stability verdict is given without scenario results. Do not infer causal dominance from sensitivity alone.

Provenance map

  • resolved: hypothesis-formation/weight-perturbation
  • resolved: convergence/rank-comparison
  • resolved: convergence/method-sensitivity-report
  • resolved: deep-insight/conclusion-sensitivity-measurement
  • resolved: stress-test/fragility-measurement
  • resolved: convergence/conclusion-sensitivity
  • resolved: knowledge-acquisition/sensitivity-analysis-design
  • intermediate: Pass3/assess-rank-robustness
  • intermediate: Pass3/measure-sensitivity
  • intermediate: Pass3/design-meta-sensitivity
  • resolved: deep-insight/convergence-assessment

Verbatim source criteria excerpts

  • weight-perturbation line 22: The elements of the input weight vector must sum to 1.0 (+/-0.001 tolerance allowed)
  • weight-perturbation line 23: The number of rows in the scoring matrix (number of gaps) must be >= 2
  • weight-perturbation line 24: At least 4 perturbation scenarios must be generated (+/-20% per dimension)
  • weight-perturbation line 35: stable (all scenarios $\tau$ >= 0.8) / sensitive (any scenario 0.5 <= $\tau$ < 0.8) / unstable (any scenario $\tau$ < 0.5)
  • rank-comparison line 27: Must report at least one rank correlation metric (Kendall tau or Spearman rho), and must list all alternatives with ranking differences >= 2 positions.
  • conclusion-sensitivity line 24: Must consider interaction effects between assumptions.
  • fragility-measurement line 33: fragility_index: Overall fragility (0.0 = robust, 1.0 = extremely fragile)

Preserved source criteria ledger

sourcephysical linekindsource criterion
hypothesis-formation/weight-perturbation14numericWeight vector sums to 1.0 (+/-0.001); scoring matrix has >=2 rows; at least 4 perturbation scenarios; verdict is stable/sensitive/unstable.
hypothesis-formation/weight-perturbation21numericApply +/-20% perturbations per dimension; stable means all $\tau$ >=0.8, sensitive means any 0.5<=$\tau$<0.8, unstable means any $\tau$<0.5.
convergence/rank-comparison22numericReport Kendall tau or Spearman rho and all alternatives with ranking differences >=2 positions.
convergence/conclusion-sensitivity23gateEvery assumption receives a sensitivity rating; identify critical assumptions, interaction effects, and overall robustness.
stress-test/fragility-measurement20numericFragility index ranges from 0.0 robust to 1.0 extremely fragile.

Frequently asked questions

What does the Assess Sensitivity AI skill do?

Perturb a specified input, assumption, model choice, analysis choice, or weight and measure sensitivity of a specified output; report convergence/instability, unstable regions, and dominant drivers.

Why use Assess Sensitivity on TypingMind?

Because you install it once and use it with any model. Assess Sensitivity 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 Assess Sensitivity in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/yogsoth-ai/de-anthropocentric-research-engine/tree/main/skills/assess-sensitivity. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Assess Sensitivity?

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 Assess Sensitivity?

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

Is the Assess Sensitivity AI skill free?

Yes. It is published on GitHub by yogsoth-ai 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 👇