Autonomous Coder Agent

    2

    A local agentic software repair engine using Ollama and LanceDB to diagnose, repair, and verify codebases via a closed-loop ReAct system.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Autonomous Coder Agent

    Example session with this skill installed

    There is a bug in the discount calculation logic. It seems to be applying the discount twice. Please use search_codebase to find the logic, patch the bug, and run the tests to verify the fix.

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

    Summary

    I successfully located, patched, and verified the double-discount calculation bug in src/billing.py using the local ReAct loop and execution sandbox.

    MetricBefore PatchAfter Patch
    Test Results (test_billing.py)1 Failed, 2 Passed3 Passed, 0 Failed
    Code StateDouble deductionSingle deduction
    
    # The corrected logic applied to src/billing.py
    def calculate_discount(price, discount_rate):
        """
        Calculates the final price after applying the discount rate.
        """
        # Fixed: Removed the redundant secondary subtraction that caused the bug
        return price - (price * discount_rate)
    

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

    About this skill

    Software repair is often slowed down by manual context switching and slow feedback loops. This skill delivers an autonomous, local-first engine that diagnoses bugs and applies verified patches within your environment.

    What it does

    • Semantic Code Search indexes your codebase using LanceDB and HuggingFace embeddings to find relevant files by architectural intent.
    • Automated Patching applies structural code modifications directly to local workspace files based on identified issues.
    • Closed-Loop Verification runs pytest suites via subprocess and feeds terminal logs back into the reasoning engine.
    • Failure Mitigation uses a specialized JSON brace parser to handle schema inconsistencies from smaller open-weights models.
    • Iterative Debugging implements a ReAct loop to observe test results and re-attempt repairs until the suite passes.

    How it works

    1. Index the codebase into a local vector store to enable RAG-based context retrieval.
    2. Search for the specific code modules or functions relevant to the reported bug or feature request.
    3. Execute a repair cycle where the agent reads the code, applies a patch, and runs the test harness.
    4. Iterate automatically if tests fail, using the console output to refine the logic.

    Frameworks & tools

    Built for local environments using Ollama, LanceDB, and HuggingFace (all-MiniLM-L6-v2). It integrates with Python projects using pytest for validation.

    Why this beats prompting it yourself

    Prompting alone lacks the stateful loop required to verify if a suggested fix actually runs. This skill bridges the gap between LLM reasoning and OS-level execution, ensuring code is not just written, but validated against your existing test suite.

    Use cases

    • Fix failing unit tests in local Python repositories.
    • Refactor legacy code by searching for patterns and applying verified updates.
    • Scaffold and test new feature implementations without manual terminal commands.
    • Resolve architectural inconsistencies across large codebases using semantic search.

    Known limitations

    Requires a local Ollama instance and Python environment with pytest installed. Best suited for qwen2.5-coder or similar models capable of structured JSON output.

    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 local Ollama and LanceDB setup. Designed specifically for Python codebases using pytest. Performance depends on the local model's ability to follow JSON schemas.

    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

    1 use

    Times used to date

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    • Free with an Agensi account

    Software
    OllamaPython 3.10+

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Requires Ollama running locally with the qwen2.5-coder:7b model pulled prior to execution.

    Listed14 days ago

    What's inside

    Frequently Asked Questions

    The Autonomous Coder Agent is a local software repair engine that uses a ReAct loop to diagnose bugs, apply patches, and run test suites until a verified fix is achieved, eliminating manual context switching.

    The skill is optimized for local execution via Ollama; for best results, we recommend using the qwen2.5-coder model, though other open-weights models capable of structured JSON output are supported.

    You will receive the complete agent logic, the RAG indexing system powered by LanceDB, and the ReAct execution harness designed to integrate with your local Python environment and pytest.

    While it is primarily designed for Python due to its native pytest integration, the semantic search and patching logic can be adapted for other languages that follow similar testing patterns.

    You must have a local Ollama instance, a Python environment, and pytest installed; the agent uses LanceDB and HuggingFace embeddings locally, so no external API keys are required for core functionality.

    No, this skill is designed for local-first execution, keeping your codebase and terminal output entirely within your own environment for maximum security and privacy.

    New in Agents & Orchestration

    Free