Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    finetooth

    1

    A structured, multi-agent framework for verifiable whole-repository code audits with on-disk state management.

    Free

    1 useSecurity scanned
    finetooth

    finetooth

    Example session with this skill installed

    Use finetooth to review the access-control block H1 in examples/toy. Follow the existing review manifest and project invariants. Show the findings, verification results, hypothesis verdicts, and coverage limits. Do not fix the code yet.

    • Read your context and instructions
    • Compiled the finetooth

    Access-control review: two confirmed findings

    This demonstration uses finetooth's published toy repository, which contains intentionally defective code. The results below summarize its saved hunter and verifier reports.

    The access-control block H1 has completed hunting and verification. Two findings remain open: one high severity and one medium severity. No fixes have been applied.

    Findings

    IDSeverityFindingEvidence
    H1-001MediumAn empty token role is accepted as a user sessionsessionFor("u1:") returns { userId: "u1", admin: false }
    H1-002HighExtra token segments do not prevent administrator accesscanRead("u1:admin:x", "u2") returns true

    Both findings originate in src/auth/session.ts:4. The parser splits the token at colons and uses only the first two segments, without validating the complete token format.

    Hypothesis verdicts

    HypothesisVerdictResult
    H1.1: An empty role must not produce a valid sessionChecked — defect foundEmpty role accepted; recorded as H1-001
    H1.2: Extra token segments must not grant administrator accessChecked — defect foundExtra segment ignored; recorded as H1-002
    H1.3: A non-admin must not read data belonging to an unknown ownerChecked — expected behavior observedNon-admin denied; admin allowed

    Independent verification

    The saved verifier report confirms both findings by execution and records no additional findings. It also checks a trailing-space variant: "u1:admin " is not treated as an administrator.

    Coverage and limits

    The hunter report names all three files in this block:

    • src/auth/session.ts
    • src/auth/guard.ts
    • tests/guard.test.ts

    The verifier reports independently reviewing all three files and rechecking the hypotheses.

    This is a block review, not a completed whole-repository audit. Billing block V1 remains pending. The toy repository has no live deployment environment, and the results do not establish production security.

    Next steps

    1. Define and enforce the complete valid token format.
    2. Add regression tests for empty roles and extra segments.
    3. Have a separate fixer implement the changes.
    4. Run an independent fix review and the review-state checks before closing H1.

    Findings and review progress remain recorded in docs/review/ for the next session.

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

    About this skill

    Finetooth is a structured whole-repository code review workflow for coding agents. It helps you define review blocks, map tracked files to blocks, and record project-specific hypotheses with explicit verdicts.

    Separate hunter, verifier, fixer and fix-reviewer roles support discovery, verification and remediation. Review state, findings, reports and decisions are stored in docs/review/, allowing work to resume across sessions.

    The included Python CLI generates role prompts, manages findings, checks review-state consistency and coverage records, and exports summaries and SARIF reports.

    Block boundaries, project invariants and hypotheses require human and agent judgment. Coverage records make review scope and gaps visible; they do not guarantee that every line was understood or that all defects were found.

    Free and open source under the MIT license.

    Source code: https://github.com/mikey-semy/finetooth

    What it does

    • Maps tracked files to review blocks and identifies gaps in file ownership.
    • Records project-specific hypotheses and their review verdicts.
    • Generates instructions for separate review and remediation roles.
    • Keeps findings, reports and decisions on disk across sessions.
    • Checks review-state consistency and detects stale review records.
    • Exports review summaries and SARIF reports.

    How it works

    1. Initialize the review workspace and inspect the repository inventory.
    2. Define block boundaries, project invariants and review hypotheses.
    3. Run the hunter and verifier roles using generated prompts.
    4. Import findings and record verification decisions.
    5. When fixes are needed, use a separate fixer and fix reviewer.
    6. Check review records and generate a summary with findings, accepted risks and coverage limits.

    Requirements

    • A Git repository.
    • Python 3; upstream tests target Python 3.12 and 3.14.
    • A coding agent with file access and command execution.
    • No third-party Python dependencies.

    Model access and usage are provided by your chosen agent or provider and are not included in this free download.

    Use cases

    • Structured whole-repository review of an existing codebase.
    • Resuming a review across multiple agent sessions.
    • Tracking findings through independent verification, fixes and fix review.
    • Running review-state consistency checks in CI.
    • Exporting findings as SARIF for supported integrations.

    Permissions and network behavior

    The coding agent needs to read project files, run commands and write review reports. Fixing tasks also require permission to modify project code.

    The Python review tool makes no network requests. Agents use their own configured permissions and model provider.

    The optional assets/run-role.sh runner invokes Claude Code in headless mode and sends prompts through its model provider. See SECURITY.md for details.

    Included finetooth version: 0.8.0.

    Requires a Git repository, Python 3, and a coding agent with file access and command execution. Upstream tests target Python 3.12 and 3.14; no third-party Python packages are required.

    Review blocks, project invariants, and hypotheses require human and agent judgment. Coverage records expose gaps but do not guarantee that every line was understood or that all defects were found.

    Whole-repository reviews can consume substantial model usage. AI access and credits are not included in this free skill.

    Large fix-review diffs must be split using narrower --diff ranges. The --scope flag labels an assignment but does not reduce the supplied diff.

    Agent permissions and execution capabilities depend on the chosen environment. Fixing roles can modify project code and should run under your project's approval rules.

    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 any payment.

    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 forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Python
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Reads files across the repository under review. Writes review records under docs/review/. Fixing roles may modify project source files and tests. Summary and SARIF exports may write to explicitly selected output paths. The Python review tool makes no network requests. The optional run-role.sh invokes Claude Code and sends prompts through its configured model provider.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    It maps tracked files to review blocks and checks file ownership within the declared scope. Hypothesis verdicts and report requirements provide additional review records. These checks expose gaps but do not guarantee that all defects will be found.

    Git, Python 3 and a coding agent with file access and command execution. The Python tool uses only the standard library.

    Discovery, verification, fixing and fix review have different responsibilities. Separate roles provide independent checks; the workflow requires a fresh fix reviewer rather than having the fixer approve its own changes.

    Review state, findings and reports remain in the project's docs/review/ directory. A later session can inspect the recorded state and resume. Work that was not saved may need to be repeated.

    SKILL.md, the Python CLI and modules, English and Russian role templates, setup examples, CI snippets, installation instructions and the MIT license. AI model access and credits are not included.

    New in Code Quality & Review