Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Autonomous Agent Harness & Evaluation Suite

    1

    Automate file optimization and code tuning through continuous, metric-driven experiment loops.

    $19.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Autonomous Agent Harness & Evaluation Suite

    Autonomous Agent Harness & Evaluation Suite

    Example session with this skill installed

    Set up an experiment to optimize the p50 latency of src/api/search.py. The evaluation command is 'pytest bench.py' and lower is better.

    • Read your context and instructions
    • Compiled the autonomous agent harness

    I have initialized the autoresearch experiment. The environment is prepared, and a dedicated branch has been created for the optimization loop.

    Experiment Configuration: engineering/api-speed

    PropertyValue
    Domainengineering
    Experiment Nameapi-speed
    Target Filesrc/api/search.py
    Evaluation Commandpytest bench.py --tb=no -q
    Metricp50_ms
    Directionlower (minimize)
    Storage Scopeproject (.autoresearch/)
    Branchautoresearch/engineering/api-speed

    Next steps

    1. Run /ar:ar-run to perform a single manual test iteration and verify the evaluator.
    2. Start a continuous optimization loop with /ar:loop engineering/api-speed 1h.
    3. Check the progress dashboard at any time using /ar:ar-status.

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

    About this skill

    This package provides an autonomous agent suite designed to optimize files through continuous experimentation and measurable metrics. It solves the problem of manual performance tuning, prompt engineering, and code optimization by automating the edit-evaluate-loop cycle. The agent makes targeted changes, runs custom evaluation scripts, and uses git to persist improvements while discarding regressions.

    What it does

    • Autonomous optimization runs continuous loops to improve code speed, bundle size, or prompt quality.
    • Metric-driven evaluation executes custom commands to measure success and decide whether to keep or discard changes.
    • Experiment management tracks history in .autoresearch directories, providing dashboards for runs, best results, and deltas.
    • Knowledge extraction converts technical documentation and books into structured agent skills with framework indices.
    • Specialized assistance includes human-like tone modulation for communication and Boost.Asio support for C++ networking.

    How it works

    1. Initialize an experiment using /ar:setup to define the target file, evaluation command, and success metric.
    2. Execute iterations manually with /ar:ar-run or start an automated background loop via /ar:loop with scheduled intervals.
    3. Monitor progress through /ar:ar-status to view the experiment dashboard and current performance gains.

    Frameworks & tools

    Built for environments using Git for version control and Python for orchestration scripts. Supports C++ networking via Boost.Asio and handles various document formats including PDF, EPUB, and Markdown for skill conversion.

    Why this beats prompting it yourself

    Manual prompting requires you to evaluate every output and manage file states yourself. This skill automates the feedback loop, ensuring only measured improvements are committed to your codebase while you focus on other tasks.

    Use cases

    • Optimizing API response times or frontend bundle sizes overnight.
    • Refining LLM prompts by looping through evaluation benchmarks.
    • Converting internal company documentation into an interactive agent knowledge base.
    • Writing portable asynchronous C++ networking code across varying Boost versions.

    Known limitations

    Requires a functional Git repository to manage experiment branches and state. Evaluation commands must return a single, clear numerical metric for the agent to determine success.

    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.

    Requires a Git repository. Evaluation commands must output a clear numerical metric. Skill conversion performance depends on source document structure.

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

    Software
    PythonGit

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Network Access
    Environment Variables
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    This suite automates the 'edit-test-refine' cycle by running continuous experiment loops that make targeted code changes and only persist them if your specific success metrics (like speed or file size) improve.

    The suite is designed for environments using Git for version control and Python for orchestration; it integrates seamlessly with any CLI-based evaluation tool that outputs numerical metrics.

    The evaluation command must return a single, clear numerical metric (such as execution time in milliseconds or total byte count) so the agent can objectively determine if a change is an improvement or a regression.

    Yes, the suite includes specialized modules for converting technical documentation (PDF, EPUB, Markdown) into structured agent knowledge and writing portable asynchronous C++ code using Boost.Asio.

    You receive the full autonomous agent suite, the experiment management dashboard, the knowledge extraction tools, and a set of specialized commands for initializing and monitoring automated loops.

    The agent requires a functional Git repository to manage state; it creates a dedicated `.autoresearch` directory to track your experiment history, deltas, and best-performing results without cluttering your main codebase.

    New in Agents & Orchestration