Agent skill

Convergence Monitoring

by hashgraph-online in hashgraph-online/awesome-codex-plugins

Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling.

Apache-2.0Auto-check passed

Install Convergence Monitoring

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill convergence-monitoring -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins convergence-monitoring --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/JuliusBrussee/blueprint/skills/convergence-monitoring .claude/skills/convergence-monitoring && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
convergence-monitoring
GitHub stars
1.3k
Token cost
~4.2k tokens
SKILL.md length
1,281 words
Files
1
Skills in repo
716
Repo updated
First seen
Licence
Apache-2.0

At a glance

Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling.

  • Works in 9 steps: What Is Convergence? → What Is a Ceiling? → Non-Convergence Signals → …
  • Phrases: convergence
  • SKILL.md covers 1. What Is Convergence?, 2. What Is a Ceiling?, 3. Non-Convergence Signals and 4. Test Pass Rate as…, plus 4 more sections
  • Calls git

What it does

Convergence Monitoring is an agent skill from hashgraph-online/awesome-codex-plugins. Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling. Covers convergence signals, ceiling detection, non-convergence diagnosis, test pass rate as a convergence metric, and forward progress tracking for large projects. Trigger phrases: "convergence", "is the agent converging", "ceiling detection", "when to stop iterating", "diminishing returns"

Its SKILL.md is about 4.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is Apache-2.0.

When your agent uses it

  • Phrases: convergence
  • Is the agent converging
  • Ceiling detection
  • To stop iterating

Example prompts

  • “convergence”
  • “is the agent converging”
  • “ceiling detection”
  • “/convergence-monitoring”

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. What Is Convergence?
  2. What Is a Ceiling?
  3. Non-Convergence Signals
  4. Test Pass Rate as Convergence Signal
  5. Forward Progress Metrics
  6. When to Stop Iterating
  7. Monitoring During Iteration Loops
  8. Non-Convergence Recovery
  9. Convergence and Revision

What it can do on your machine

Read from SKILL.md and the folder at commit 3e1456a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Convergence Monitoring loads about 4.2k tokens when it runs. Until then it costs about 103 tokens; SKILL.md has 1,281 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~103
When it runs · the whole SKILL.md, loaded when a task matches
~4.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hashgraph-online/awesome-codex-plugins at commit 3e1456a, republished under its Apache-2.0 licence (© hashgraph-online). 1,281 words, ~4,209 tokens.

Download SKILL.mdSave it as .claude/skills/convergence-monitoring/SKILL.md (or your agent's skills folder).
name
convergence-monitoring
description
Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling. Covers convergence signals, ceiling detection, non-convergence diagnosis, test pass rate as a convergence metric, and forward progress tracking for large projects. Trigger phrases: "convergence", "is the agent converging", "ceiling detection", "when to stop iterating", "diminishing returns"

Convergence Monitoring

Convergence monitoring answers the most important question in iterative AI development: when should you stop iterating? The answer is not a fixed number of iterations or a time limit -- it is convergence. Convergence means the agent's output is stabilizing; each iteration produces fewer and smaller changes than the last.

Core insight: You don't need a zero-diff -- you need the remaining modifications to be inconsequential.


1. What Is Convergence?

Convergence appears as a rapid, consistent decline in the volume of changes from one iteration to the next:

Iteration 1:  ████████████████████████████████████████  300 lines changed
Iteration 2:  ████████████████                          120 lines changed
Iteration 3:  ██████                                     40 lines changed
Iteration 4:  ██                                         10 lines changed (cosmetic only)
              ^--- Convergence reached: the diff shrinks each pass until only cosmetic changes remain
Convergence indicators
SignalWhat It Means
Lines changed decreasing exponentiallyEach iteration makes roughly half the changes of the previous one
Changes become trivialRemaining changes are formatting, comments, imports -- not behavior
Tests stabilizeTest count stops increasing; pass rate approaches 100%
No new files createdThe architecture has settled; only existing files are modified
Impl tracking updates shrinkImplementation tracking changes are status updates, not new findings
Completion signal emittedAgent determines all exit criteria are met
What convergence looks like in git
bash
# Check lines changed per iteration
git log --oneline --stat

# Iteration 5: trivial changes
abc1234 Iteration 5: formatting and comment fixes
 3 files changed, 8 insertions(+), 6 deletions(-)

# Iteration 4: minor adjustments
def5678 Iteration 4: edge case handling
 5 files changed, 22 insertions(+), 8 deletions(-)

# Iteration 3: moderate changes
ghi9012 Iteration 3: complete API integration
 12 files changed, 85 insertions(+), 31 deletions(-)

# Iteration 2: significant changes
jkl3456 Iteration 2: implement core features
 18 files changed, 156 insertions(+), 42 deletions(-)

# Iteration 1: major initial work
mno7890 Iteration 1: initial implementation
 25 files changed, 312 insertions(+), 15 deletions(-)

2. What Is a Ceiling?

A ceiling is when the agent cannot make further progress due to external constraints. Like convergence, it produces small diffs -- but for fundamentally different reasons.

Convergence:  Agent is DONE      -> small diffs because work is complete
Ceiling:      Agent is STUCK     -> small diffs because agent cannot proceed
Ceiling causes
CauseExampleHow to Detect
Missing dependencyAPI not available, library not installedAgent logs errors about unavailable resources
Ambiguous specRequirement can be interpreted multiple waysAgent oscillates between implementations
Tooling limitationBuild tool does not support needed featureAgent tries workarounds that do not converge
External serviceTest requires network access, external APITests fail with connection/timeout errors
Context window exhaustionCodebase too large for one sessionAgent loses track of earlier work
Permission boundaryAgent cannot access needed files or systemsRepeated permission errors in logs
How to tell them apart
DimensionConvergence (work is finishing)Ceiling (work is stuck)
Size of diffsShrinking steadily toward zeroStaying small but not trending down
Nature of changesCosmetic -- whitespace, comments, namingFunctional but going in circles
Test resultsPass rate climbing toward full coveragePass rate plateaued below target
Agent stanceWrapping up, marking exit criteria doneRetrying the same strategies repeatedly
Tracking statusTasks moving to DONEBLOCKED items piling up
Recommended actionDeclare done, move to next phaseDiagnose the obstacle, resolve it, then continue
How to distinguish them
Check 1: Are tests passing?
  YES, and improving -> Convergence
  NO, stuck at same failures -> Ceiling

Check 2: Is the agent trying new approaches?
  NO, just polishing -> Convergence
  YES, but they all fail similarly -> Ceiling

Check 3: Are there BLOCKED tasks in impl tracking?
  NO -> Convergence
  YES -> Ceiling (read the blockers)

Check 4: Is the agent producing meaningful error messages?
  NO, just minor changes -> Convergence
  YES, about dependencies/tools/access -> Ceiling

3. Non-Convergence Signals

Non-convergence means the agent is making changes, but they are NOT decreasing. The system is not stabilizing.

Non-convergence:
Iteration 1:  ████████████████████████████████████████  250 lines changed
Iteration 2:  ██████████████████████████████████████    230 lines changed
Iteration 3:  ████████████████████████████████████████  260 lines changed
Iteration 4:  ██████████████████████████████████        220 lines changed
              ^--- NOT converging: changes are flat/oscillating
Root causes of non-convergence
Root CauseSymptomFix
Fuzzy specsAgent interprets requirements differently each iterationMake specs more precise; add concrete acceptance criteria
Weak validationAgent cannot verify correctness, so it keeps changing thingsAdd build/test/lint gates; strengthen acceptance criteria
Fighting sub-agentsMultiple agents change the same code in conflicting waysAdd file ownership tables; dispatch subagents via the Agent tool
Contradictory requirementsSpec A says X, spec B says not-XResolve contradictions in specs; add explicit priority/precedence
Missing exit criteriaAgent does not know when it is doneAdd explicit exit criteria checklists and completion signals
Over-broad scopeToo much work for one prompt/iterationSplit into smaller, focused prompts with clear boundaries
Unstable dependenciesExternal library or API keeps changingPin dependencies; mock external services in tests
The critical rule

When the loop isn't stabilizing, the problem is upstream -- fix the specifications, validation, or coordination rather than adding more passes.

Running more iterations when the system is not converging wastes time and compute. Instead:

  1. Stop the iteration loop
  2. Analyze the non-convergence pattern
  3. Fix the root cause (usually specs or validation)
  4. Resume the iteration loop

4. Test Pass Rate as Convergence Signal

Test pass rate is the most reliable quantitative convergence signal. Track these metrics:

Metrics to monitor
| Iteration | Tests | Pass | Fail | Skip | Pass Rate | Delta |
|-----------|-------|------|------|------|-----------|-------|
| 1         | 45    | 30   | 15   | 0    | 66.7%     | --    |
| 2         | 62    | 50   | 12   | 0    | 80.6%     | +13.9 |
| 3         | 78    | 70   | 8    | 0    | 89.7%     | +9.1  |
| 4         | 85    | 82   | 3    | 0    | 96.5%     | +6.8  |
| 5         | 88    | 87   | 1    | 0    | 98.9%     | +2.4  |
What to look for
PatternMeaningAction
Test count increasingAgent is adding coverageGood -- system is maturing
Pass rate approaching 100%Implementation matches specsGood -- approaching convergence
Fewer failures per iterationEach pass fixes more than it breaksGood -- healthy convergence
Pass rate plateaus < 100%Some tests consistently failCeiling -- investigate failing tests
Test count decreasingAgent is deleting testsBad -- investigate why; may be deleting inconvenient tests
Pass rate oscillatingFixes in one area break anotherNon-convergence -- check for conflicting specs
Automated convergence check
bash
# After each iteration, check convergence signals
echo "=== Convergence Check ==="

# 1. Lines changed (should be decreasing)
git diff --stat HEAD~1

# 2. Test results (should be improving)
{TEST_COMMAND} 2>&1 | tail -5

# 3. Build health (should always pass)
{BUILD_COMMAND} 2>&1 | tail -3

# 4. Files changed (should be decreasing)
git diff --name-only HEAD~1 | wc -l

5. Forward Progress Metrics

For large projects where full convergence takes many iterations, track forward progress toward eventual convergence.

Spec requirement coverage

The percentage of spec requirements with passing tests:

Spec Requirements Coverage:
  spec-auth.md:     ██████████████████████████████████████  95% (19/20 requirements)
  spec-data.md:     ████████████████████████████████        80% (16/20 requirements)
  spec-ui.md:       ██████████████████████                  55% (11/20 requirements)
  spec-api.md:      ████████████████████████████            70% (14/20 requirements)
  ─────────────────────────────────────────────────────
  Overall:          ████████████████████████████            75% (60/80 requirements)
Forward progress signals
MetricHealthy TrendUnhealthy Trend
Requirements with passing testsIncreasing each iterationFlat or decreasing
Total test countIncreasingFlat or decreasing
DONE tasks in impl trackingIncreasingFlat with BLOCKED tasks growing
Open issuesDecreasingIncreasing or flat
Dead ends documentedIncreasing slightly (learning)Exploding (thrashing)
Show full SKILL.md (495 more words)Show less
Iteration velocity

Track how much progress each iteration makes:

| Iteration | Requirements Met | New This Iteration | Velocity |
|-----------|-----------------|-------------------|----------|
| 1         | 15/80           | 15                | 15       |
| 2         | 30/80           | 15                | 15       |
| 3         | 48/80           | 18                | 18       |
| 4         | 60/80           | 12                | 12       |
| 5         | 68/80           | 8                 | 8        |
| 6         | 73/80           | 5                 | 5        |
| 7         | 76/80           | 3                 | 3        |

Velocity should decrease over time (easy requirements first, hard ones last), but should never hit zero. Zero velocity = ceiling.


6. When to Stop Iterating

Stop conditions (convergence reached)

Stop the iteration loop when ANY of these are true:

  1. Completion signal emitted: Agent outputs <all-tasks-complete>
  2. Changes are trivial: Last iteration changed fewer than ~20 lines, all formatting/comments
  3. Test pass rate is stable: Pass rate has been 95%+ for 2+ consecutive iterations
  4. All exit criteria met: Every [ ] in the exit criteria checklist is [x]
  5. Forward progress stalled positively: All spec requirements have passing tests
Continue conditions (not yet converged)

Continue iterating when ALL of these are true:

  1. Changes are still substantial (behavior changes, not just formatting)
  2. Test pass rate is still improving
  3. There are still TODO or IN_PROGRESS tasks in impl tracking
  4. The iteration count is under the maximum
Investigate conditions (possible ceiling)

Pause and investigate when ANY of these are true:

  1. Changes are small but tests are NOT passing
  2. Agent is retrying the same approach repeatedly
  3. BLOCKED tasks are accumulating in impl tracking
  4. Test pass rate is oscillating (up-down-up-down)
  5. Agent is producing error messages about dependencies or tooling

7. Monitoring During Iteration Loops

What to monitor in real time
+------------------------------------------------------+
| Convergence Dashboard                                |
+------------------------------------------------------+
| Iteration: 4/10                                      |
| Lines changed: 45 (prev: 112, trend: decreasing)    |
| Files changed: 3 (prev: 8, trend: decreasing)       |
| Test pass rate: 94.2% (prev: 87.1%, trend: up)      |
| Tests: 82 total (prev: 75, trend: up)               |
| BLOCKED tasks: 0 (prev: 1, trend: down)             |
| Status: CONVERGING                                   |
+------------------------------------------------------+
Monitoring commands
bash
# Quick convergence check after each iteration
echo "--- Lines changed ---"
git diff --stat HEAD~1 | tail -1

echo "--- Files changed ---"
git diff --name-only HEAD~1 | wc -l

echo "--- Test results ---"
{TEST_COMMAND} --summary 2>&1 | tail -3

echo "--- Impl tracking status ---"
grep -c "BLOCKED\|IN_PROGRESS\|TODO\|DONE" context/impl/impl-*.md
Automated alerts

Set up alerts for non-convergence signals:

AlertTriggerAction
OscillationLines changed increased vs previous iterationPause; check for conflicting changes
StallLines changed < 5 but tests still failingPause; likely a ceiling
RegressionTest pass rate decreasedPause; investigate what broke
RunawayLines changed > 500 for 3+ iterationsPause; scope may be too broad

8. Non-Convergence Recovery

When you detect non-convergence, follow this recovery process:

Step 1: Stop the iteration loop

Do not keep running. More iterations will not help.

Step 2: Diagnose the root cause
markdown
## Non-Convergence Diagnosis

### Symptoms
- [ ] Changes are flat (not decreasing)
- [ ] Changes are oscillating (up-down-up-down)
- [ ] Agent is retrying failed approaches
- [ ] Tests are oscillating (passing then failing)
- [ ] Multiple agents changing the same files

### Root Cause Analysis
1. Check specs: Are requirements clear and unambiguous?
2. Check validation: Can the agent verify correctness?
3. Check file ownership: Are agents conflicting?
4. Check scope: Is the prompt trying to do too much?
5. Check dependencies: Are external resources available?
Step 3: Fix the root cause
Root CauseFix
Fuzzy specsRewrite ambiguous requirements with concrete acceptance criteria
Weak validationAdd build/test/lint gates to the prompt
File conflictsAdd file ownership tables; dispatch subagents via the Agent tool
Over-broad scopeSplit into smaller prompts; reduce concurrent agents
External dependencyMock the dependency; or resolve it before resuming
Step 4: Resume the iteration loop

After fixing the root cause, resume from where you stopped. Do NOT restart from scratch -- git history preserves all progress.

bash
# Resume with the same prompt, possibly fewer remaining iterations
iteration-loop context/prompts/003-generate-impl-from-plans.md -n 5 -t 1h

9. Convergence and Revision

Revision directly improves convergence by making specs more complete:

Without revision:
  Iteration 1: 200 lines, 5 manual fixes -> specs unchanged
  Iteration 2: 180 lines, 4 manual fixes -> specs unchanged
  Iteration 3: 170 lines, 4 manual fixes -> NOT converging

With revision:
  Iteration 1: 200 lines, 5 manual fixes -> specs updated with 5 new requirements
  Iteration 2: 100 lines, 2 manual fixes -> specs updated with 2 new requirements
  Iteration 3: 50 lines, 0 manual fixes  -> CONVERGING

Frequent manual fixes without revision = non-convergence. The iteration loop keeps producing the same bugs because nothing in the specs prevents them.


Cross-References

  • Convergence patterns reference: See references/convergence-patterns.md for the complete convergence pattern catalog with examples.
  • Revision: See ck:revision skill for how tracing bugs to specs improves convergence.
  • Prompt pipeline: See ck:prompt-pipeline skill for designing prompts with proper exit criteria and completion signals.
  • Validation-first design: See ck:validation-first skill for building validation gates that provide convergence signals.
  • Impl tracking: See ck:impl-tracking skill for tracking progress and detecting ceiling conditions.

© hashgraph-online, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/JuliusBrussee/blueprint/skills/convergence-monitoring of hashgraph-online/awesome-codex-plugins.

Open the folder on GitHubat commit 3e1456a

Compare with similar skills

Convergence Monitoring next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Convergence Monitoring compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Convergence Monitoring this skillhashgraph-online/awesome-codex-plugins1.3k—~4.2kAutomated safety check: PassApache-2.0
Detect Zero Iteration FailuresHKUDS/OpenSpace7.8k—~1.3kAutomated safety check: PassMIT
Detect Zero Iteration FailureHKUDS/OpenSpace7.8k—~477Automated safety check: PassMIT
Threat Detectionalirezarezvani/claude-skills28k—~3.5kAutomated safety check: PassMIT
Resemble Detectgithub/awesome-copilot40k3 repos~4.1kAutomated safety check: PassApache-2.0
Pii Detectruvnet/ruflo74k—~350Automated safety check: NotesMIT

Similar skills

  • Identify and handle pre-execution agent failures occurring before any iterations or tool usage

    7.8k GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check passed
  • Identify and classify agent failures occurring before execution starts

    7.8k GitHub stars~477 tokensUpdated 1 mo ago
    Auto-check passed
  • Threat Detection

    alirezarezvani/claude-skills

    A skill your agent uses when hunting for threats in an environment, analyzing IOCs, or detecting behavioral anomalies in telemetry.

    28k GitHub stars~3.5k tokensUpdated 1 mo ago
    SecurityAuto-check passed
  • Resemble Detect

    github/awesome-copilot

    Official

    Deepfake detection and media safety — detect AI-generated audio, images, video, and text, trace synthesis sources, apply watermarks, verify speaker identity, and analyze media intelligence using…

    40k GitHub starsUsed in 3 repos~4.1k tokens
    Media & CreativeAuto-check passed
  • Pii Detect

    ruvnet/ruflo

    Detect and flag personally identifiable information (PII) in text, code, and configurations.

    74k GitHub stars~350 tokensUpdated yesterday
    Auto-check: notes
  • Detecting API Enumeration Attacks

    mukul975/Anthropic-Cybersecurity-Skills

    Detect API enumeration attacks (BOLA/IDOR, OWASP API1:2023) by writing SIEM detection rules that flag sequential or UUID identifier iteration, parameter tampering, and mixed 200/401/403 response…

    34k GitHub stars~3.7k tokensUpdated 1 mo ago
    SecurityAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 715 skills in this repo
  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.3k GitHub stars~922 tokensUpdated today
    Auto-check passed
  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.3k GitHub stars~1k tokensUpdated today
    Auto-check passed
  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.3k GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.3k GitHub stars~2.5k tokensUpdated today
    Auto-check passed
  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.3k GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.3k GitHub stars~618 tokensUpdated today
    Auto-check passed

Questions about Convergence Monitoring

What does Convergence Monitoring do?

Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling. Convergence Monitoring is an agent skill from hashgraph-online/awesome-codex-plugins. Detecting whether agent iterations are converging toward a stable solution or hitting a ceiling.

When should I use Convergence Monitoring?

Convergence Monitoring fits situations like: phrases: convergence; is the agent converging; ceiling detection; to stop iterating.

How do I install Convergence Monitoring in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill convergence-monitoring -a claude-code`. Or copy the skill folder (plugins/JuliusBrussee/blueprint/skills/convergence-monitoring in hashgraph-online/awesome-codex-plugins) into .claude/skills/convergence-monitoring in your project. Claude Code loads it when a task matches its description.

How do I install Convergence Monitoring in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill convergence-monitoring -a codex`. Or copy the skill folder (plugins/JuliusBrussee/blueprint/skills/convergence-monitoring in hashgraph-online/awesome-codex-plugins) into .agents/skills/convergence-monitoring in your project. Codex loads it when a task matches its description.

Can I use Convergence Monitoring in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hashgraph-online/awesome-codex-plugins --skill convergence-monitoring -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/convergence-monitoring, .gemini/skills/convergence-monitoring, .github/skills/convergence-monitoring and .opencode/skills/convergence-monitoring in your project.

What does Convergence Monitoring need to run?

Going by SKILL.md and its folder, Convergence Monitoring needs the command-line tools its instructions call (git).

Does Convergence Monitoring access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Convergence Monitoring safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Convergence Monitoring use?

Convergence Monitoring is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Convergence Monitoring use?

About 4.2k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Convergence Monitoring?

Skills that share tags, products or a category with Convergence Monitoring: Detect Zero Iteration Failures (HKUDS/OpenSpace, 7.8k stars), Detect Zero Iteration Failure (HKUDS/OpenSpace, 7.8k stars), Threat Detection (alirezarezvani/claude-skills, 28k stars) and Resemble Detect (github/awesome-copilot, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Convergence Monitoring?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,267 GitHub stars. The repository holds 716 skills in this directory. The repository was last updated on October 10, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.