Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    longrun universal

    1

    A harness-neutral playbook for multi-session, unattended agentic development with durable state and verification gates.

    Free

    Security scanned
    longrun universal

    longrun universal

    Example session with this skill installed

    Start a longrun for the new authentication module. I have a 50 dollar budget and want to use a feature branch. Use the universal playbook.

    • Read your context and instructions
    • Compiled the longrun universal
    • Generated the document

    I have initialized the LONGRUN development environment. A new feature branch feat/authentication-module has been created, and the durable state files are now tracking the run intent and initial task backlog.

    LONGRUN Initialization Report

    ComponentStatusDetails
    PlaybookActivereferences/LONGRUN-universal.md
    BranchCreatedfeat/authentication-module
    State FilesInitializedTASKS.md, FEATURES.json, LOG.md
    Budget GateSet$50.00 USD
    Run IntentLoggedImplement core auth module with JWT support and bcrypt hashing.

    Initial Task Backlog

    1. Define User schema and migration scripts.
    2. Implement password hashing utility with bcrypt.
    3. Create JWT generation and validation service.
    4. Build login endpoint and integration tests.

    Next steps

    • Review the FEATURES.json file to ensure the acceptance criteria match your requirements.
    • The agent will now begin the first task in the queue.
    • To run this unattended, execute the driver script: ./scripts/longrun-driver.sh -n 10 -- [your-agent-command]

    longrun-universal.pdf

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Long-running agentic tasks often fail when context windows fill up, sessions time out, or the agent loses track of the original intent during unattended runs. This skill implements the LONGRUN playbook to enable multi-session, unsupervised development that survives context loss and hardware reboots.

    What it does

    • State persistence manages project progress through TASKS.md, FEATURES.json, and LOG.md files that serve as the ground truth across sessions.
    • Evidence-based verification enforces a strict loop where no task is marked done without verifiable command output or test results.
    • Automated driver integration supports headless execution via a driver script to run back-to-back sessions until the backlog is cleared.
    • Reversibility management ensures all work happens on feature branches with frequent commits to prevent destructive state loss.
    • Stop-rule enforcement monitors for loop exhaustion or blocking issues, halting the agent to wait for human intervention rather than burning tokens.

    How it works

    1. Start by initializing the run intent, creating a feature branch, and scaffolding the state files from provided templates.
    2. Resume at the start of any new session by reading the on-disk state and reconciling the current git head with TASKS.md.
    3. Execute the work loop by picking the next task, applying changes, and capturing evidence of success.
    4. End by writing a session retrospective and updating the durable state files before the process exits.

    Frameworks & tools

    This tool is harness-agnostic, requiring only a shell, git, and file system access. It includes a longrun-driver.sh script for Unix-like environments (macOS/Linux) to manage headless agent cycles.

    Why this beats prompting it yourself

    Standard prompts forget the "why" and "how" after a few thousand tokens of terminal output. This skill forces the agent to treat its own instructions as a persistent protocol, ensuring it doesn't skip tests or hallucinate progress when you aren't watching.

    Use cases

    • Executing a large backlog of refactoring tasks overnight.
    • Managing complex feature migrations that span multiple days of development.
    • Maintaining project continuity when switching between different LLM providers or agent interfaces.
    • Running autonomous agents in headless environments with strict verification gates.

    Known limitations

    Does not support concurrent background jobs in headless mode. Requires an agent harness that allows automated git commits and file writes to maintain the state loop.

    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.

    No support for concurrent background jobs in headless mode. Requires agent permission to commit to git and write files without interactive prompts to function unattended.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 11 days ago

    • Free with an Agensi account

    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'context drift' problem where agents lose track of complex goals over time. It uses a structured state management system (LONGRUN playbook) to ensure the agent maintains intent and verifies work through durable files like TASKS.md, even across reboots or session timeouts.

    The skill is harness-neutral, meaning it works with any AI agent that has file system and shell access. It has been tested across various LLM providers and includes a universal driver script for Unix-like environments to manage headless cycles.

    You receive the full LONGRUN playbook architecture, including state file templates (TASKS.md, FEATURES.json, LOG.md), the `longrun-driver.sh` automation script, and the protocol instructions that enforce the verification gates.

    Setup is minimal: you simply need to provide the agent access to the playbook files and the driver script within a git-initialized repository. The agent then uses these files to self-initialize the feature branch and state tracking without manual configuration.

    No, the current version is optimized for sequential, verifiable task execution to maintain state integrity. It focuses on deep, multi-session progress rather than parallel background processes which could cause git conflicts or state desynchronization.

    The skill enforces a 'Stop-Rule' that monitors for repetitive loops or blocking errors that it cannot resolve. Instead of wasting tokens on failed attempts, the agent will pause, save its current state to LOG.md, and wait for human intervention to clear the path.

    New in Agents & Orchestration

    Free