Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    forge refine

    1

    Automated lifecycle management for agent skill libraries using evidence-based retention and consolidation rules.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    forge refine

    forge refine

    Example session with this skill installed

    A new skill 'api-auth-handler' in the 'security' domain just passed the gate with a VERIFIED tier. Record the promotion and check if the library is still within size limits.

    • Read your context and instructions
    • Compiled the forge refine

    I have promoted the api-auth-handler skill to the library and updated the ledger state. A snapshot of the previous version (if any) has been stored in the version history.

    Skill Promotion and Library Audit

    ActionEntityStatusDetails
    Promotionapi-auth-handlerSUCCESSMoved to library/ from candidates/
    Tier Assignmentsecurity domainVERIFIEDInitial retention counter set to 3
    Versioning_versions/api-auth-handler/CREATEDSnapshot of current state archived
    Compile CheckLibrary SizePASSTotal active skills: 14 / 20 cap
    Domain DensitysecurityOPTIMAL2 active skills (below consolidation threshold)

    Next steps

    1. Monitor the next 3 calibration runs to observe the "hit" rate for the new api-auth-handler.
    2. If another security skill is created, trigger a merge via skill-creator to maintain consolidation discipline.
    3. Run python scripts/compile_check.py before the next deployment to ensure word-count compliance.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Maintaining a high-performing agent skill library requires strict discipline. This skill manages the lifecycle of your library by promoting successful candidates, tracking hit/miss ratios, and enforcing size constraints to prevent performance degradation.

    What it does

    • Ledger management tracks which skills are active, their domain, and their current performance tier.
    • Automated promotion moves gated candidates into production folders while snapshotting prior versions for safety.
    • Evidence-based retention implements a hit/miss counter that automatically archives underperforming skills before they propagate errors.
    • Library consolidation flags redundant skills in the same domain to force merges, optimizing for the highest possible performance lift.
    • Constraint enforcement runs periodic checks to ensure word counts and library size caps are never exceeded.

    How it works

    1. Promote candidates by running the ledger script with the gate verdict tier to move files from staging to the library.
    2. Record outcomes after every task attempt to update the retention counter based on success or failure.
    3. Audit the library using compilation checks to detect violations of size or word-count discipline.
    4. Trigger merges when the system identifies sibling skills in the same domain, handing them back to the creator for consolidation.

    Frameworks & tools

    The skill interfaces with local file systems and Python-based CLI tools (ledger.py, compile_check.py). It follows the SkillFlow architecture for automated skill evolution and archival.

    Why this beats prompting it yourself

    Manual library management leads to "skill bloat" where too many overlapping prompts confuse the agent. This skill uses a mathematical leash—based on the SkillFlow arXiv:2604.17308 findings—to prune failures and merge redundancies automatically, ensuring your agent's context remains lean and effective.

    Use cases

    • Lifecycle automation for multi-agent systems that generate and test their own tools.
    • A/B testing prompts by tracking real-world "hit" rates and archiving losers.
    • Version control for agent capabilities by maintaining a structured snapshot history.
    • Performance optimization by preventing library accumulation from exceeding architectural limits.

    Known limitations

    This skill does not write or edit prompt content itself. It requires the existence of ledger.py and compile_check.py scripts to perform file operations and audits.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Does not write or edit skill content. Requires local Python scripts for ledger and compilation checks. Lifecycle transitions are evidence-driven, not manual.

    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 buying a skill.

    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 6 days ago

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    Forge Refine prevents 'skill bloat' by using an evidence-based retention system that tracks the hit/miss ratio of your prompts, automatically archiving those that underperform to keep your agent's context lean.

    This skill is designed for systems following the SkillFlow architecture and requires a Python environment to run the included `ledger.py` and `compile_check.py` CLI tools for file management.

    No, Forge Refine focuses on the structural lifecycle—moving files, tracking performance tiers, and enforcing size constraints—rather than rewriting the actual prompt text.

    The system identifies 'sibling skills' within the same domain and flags them for consolidation, ensuring you don't have redundant or conflicting instructions competing for the agent's attention.

    You receive the core Forge Refine logic, the necessary Python-based ledger and compilation scripts, and the configuration templates required to implement the SkillFlow evolution architecture.

    New in Agents & Orchestration