AR

    Agy Review

    0

    Code review of your local git changes by Google Antigravity (agy), with read-only repo access and no permission prompts.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more
    AR

    agy-review

    Example session with this skill installed

    Use agy-review to prepare this repository for a safe release.

    1. Check that Google Antigravity and the read-only review guard are correctly configured.
    2. Independently review the current Git changes for correctness, reliability, and security vulnerabilities.
    3. Verify every finding against the actual source code. Reject unsupported or hallucinated findings.
    4. Return a prioritized report with file locations, CWE classifications where relevant, evidence, recommended fixes, and a release verdict.
    5. Check whether Graphify is installed and configured.
    6. With my approval, configure Graphify to refresh the repository knowledge graph through Antigravity in the background after commits, merges, branch switches, and rebases.
    7. Use incremental updates and avoid consuming Claude Code or Codex agent tokens for Graphify's LLM operations.
    8. Show the final review verdict, Graphify configuration, and verification commands.

    Do not modify application source code or silently install dependencies.

    • Read your context and instructions
    • Compiled the agy-review

    agy-review — Repository Review & Graphify Setup

    1. Environment Verification

    Start by checking the Antigravity environment and read-only review guard.

    bun plugins/agy-review/scripts/agy-review.mjs --check
    bun plugins/agy-review/scripts/agy-review.mjs --verify
    

    The verification must establish that read operations work and prohibited write operations are blocked before agentic review proceeds.

    A failed verification requires investigation before continuing.

    2. Independent Security Review

    Run the security review against the current changes:

    bun plugins/agy-review/scripts/agy-review.mjs \
      --security \
      --format json \
      --fail-on high \
      --output security-review.json
    

    Evidence Verification

    Model claimVerification handling
    Supporting code foundEligible for a verified finding
    Incorrect line numberCorrected against source
    Evidence not foundRejected
    Speculative findingReported separately
    Insufficient coverageInconclusive, not approved

    Security Report Structure

    Every verified finding can include

    • Severity and priority
    • CWE classification
    • Source file and line
    • Exact supporting evidence
    • Explanation and risk
    • Recommended remediation
    • Confidence and grounding status

    CI Verdict

    Exit codeMeaning
    0Successful review, no failing gate
    1Error or unparseable model response
    2Invalid usage or missing prerequisite
    3Working tree changed during agentic review
    4Inconclusive review
    10Severity gate failed

    The application code is not automatically fixed by the reviewer.

    3. Graphify Prerequisite Check

    Run

    bun plugins/agy-review/scripts/agy-review.mjs --graphify doctor
    

    Check for

    • Signed-in Antigravity CLI
    • Graphify installation
    • Python OpenAI client availability
    • Existing knowledge graph
    • Git hook configuration

    If any dependency is missing, report the required action and obtain approval before making environment changes.

    4. Configure Graphify

    After approval

    bun plugins/agy-review/scripts/agy-review.mjs --graphify setup --yes
    

    This configures the Antigravity-backed update workflow and installs background Git hooks.

    Existing unrelated hook content is preserved. By default, Graphify's own hooks are replaced to avoid competing graph writers.

    If no knowledge graph exists, initialize it once:

    bun plugins/agy-review/scripts/agy-review.mjs --graphify update --full
    

    5. Automatic Knowledge Graph Maintenance

    After setup, the following events trigger background graph refreshes:

    Git eventAction
    CommitBackground update
    MergeBackground update
    Branch checkoutBackground update on branch switch
    Rebase or amendBackground update

    Graphify parses source code locally and uses its cache to identify changed documentation.

    The Antigravity model handles semantic extraction and community naming through the temporary local bridge.

    The Git command does not wait for the graph update to finish.

    6. Inspect Graphify Status

    Run

    bun plugins/agy-review/scripts/agy-review.mjs --graphify status
    

    Inspect the configured hooks, latest result, model calls, token usage, and any errors.

    The agent may continue working with the current graph while an update is running.

    7. Remediation and Follow-Up

    For verified high-priority findings

    1. Inspect the cited code and validate the recommended fix.
    2. Apply approved changes using a separate development workflow.
    3. Repeat the independent review.
    4. Compare results with the previous JSON report.
    5. Resolve critical issues before release.
    6. Recheck Graphify status after subsequent Git operations.

    Final Deliverables

    • Evidence-verified code and security report
    • Explicit release verdict
    • List of rejected or inconclusive findings
    • CI-compatible JSON report
    • Graphify prerequisites and setup status
    • Background Git hook configuration
    • Knowledge graph status and troubleshooting information

    Outcome: Independent, verifiable review results and a Graphify workflow that moves graph-update LLM processing away from Claude/Codex agent sessions to Antigravity.

    Actual findings, setup state, and execution metrics depend on the repository and environment.

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

    About this skill

    agy-review — Evidence-Verified AI Code Review & Automatic Graphify

    Two powerful workflows. One toolkit. Powered by Google Antigravity.

    Review your code with independently verified AI findings, detect security vulnerabilities, and keep your repository's knowledge graph automatically updated—without wasting your primary coding agent's tokens on graph maintenance.

    agy-review is an open-source developer toolkit connecting Claude Code, OpenAI Codex, and terminal workflows to Google Antigravity (agy).

    It combines independent code and security reviews, multi-model analysis, task delegation, translation, CI/CD automation, and Graphify integration.

    🔍 1. Evidence-Verified Code Review

    AI code review that has to show its work.

    Every reported finding must include an exact quotation from the affected source code.

    agy-review automatically:

    • Checks quoted evidence against real repository files.
    • Corrects inaccurate line references.
    • Rejects findings whose evidence cannot be located.
    • Separates speculative or unsupported findings.
    • Calculates the final verdict from verified findings.
    • Generates Markdown or structured JSON reports.

    Review uncommitted changes, staged files, commits, branches, individual functions, classes, line ranges, or pasted snippets.

    Supported verdicts include approve, approve_with_comments, request_changes, and inconclusive.

    An inconclusive review is never silently treated as approval.

    🛡️ 2. Security Review & Vulnerability Analysis

    Go beyond ordinary code review with security-focused analysis.

    Capabilities include:

    • OWASP and CWE mapping
    • Exploitability analysis
    • Concrete attack scenarios
    • Untrusted-input data-flow reasoning
    • Secret and dangerous-pattern scanning
    • Caller and callee context analysis
    • Prioritized, evidence-backed remediation

    Run security reviews on authentication, database queries, file handling, networking, cryptography, and other security-sensitive code.

    🧠 3. Automatic Graphify Knowledge Graph Updates

    Stop spending Claude Code and Codex agent tokens refreshing your knowledge graph.

    agy-review integrates with Graphify to maintain a repository's knowledge graph automatically through Google Antigravity.

    Graphify processes code locally using Tree-sitter and maintains its graph, cache, clustering, and reports.

    agy-review redirects Graphify's LLM-dependent operations to Antigravity:

    • Semantic extraction from changed documents
    • Entity and relationship extraction
    • Community naming

    This avoids using your active Claude Code or Codex session for those graph updates.

    Automatic Git Hooks

    Graphify updates run in the background after:

    • Git commits
    • Git merges
    • Branch checkouts
    • Git rebases and amends

    Git operations return immediately without waiting for the graph refresh.

    Incremental Processing

    Graphify's existing cache detects unchanged documents and avoids sending them repeatedly to the model.

    Local Antigravity Bridge

    A temporary, loopback-only OpenAI-compatible endpoint connects Graphify to agy.

    • No separate LLM API key required
    • No Ollama required
    • Configurable Antigravity model
    • Configurable reasoning effort and concurrency
    • Temporary bearer-token authentication
    • Recognized secrets redacted before model submission

    Graphify still uses your Antigravity quota. The savings concern Claude/Codex agent tokens, not all model usage.

    Documented Graphify Benchmark

    On the author's small Windows 11 test repository:

    MetricObserved
    Git commit return0.3 seconds
    Background graph update22 seconds
    Antigravity calls1
    Claude/Codex agent tokens0
    Graph nodes10 → 14
    Graph edges9 → 12

    Results depend on repository size, changed documents, model choice, and available quota.

    🤖 4. Multi-Model Review & Agent Delegation

    Run reviews using available Antigravity models.

    • Choose models and reasoning effort.
    • Cross-check findings across multiple models.
    • Track agreement between independent reviews.
    • Delegate self-contained tasks through Antigravity.
    • Integrate reviewer and worker sub-agents into larger workflows.

    🌍 5. Translation & Localization

    Translate documentation and other content through Antigravity with configurable:

    • Target language
    • Tone and audience
    • Glossary and terminology
    • Structural preservation checks

    Verify that code snippets, URLs, placeholders, and headings survive translation.

    ⚙️ 6. CI/CD & Automated Quality Gates

    Bring evidence-based reviews into automated development workflows.

    • Structured JSON reports
    • Stable finding IDs
    • Severity-based exit codes
    • Comparison of new, persisting, and resolved findings
    • Automated review-and-fix loops
    • Explicit handling of inconclusive results

    A verified high-severity finding can trigger a failing CI gate.

    🔒 7. Security & Permissions

    Static review modes run without giving the AI model filesystem tools.

    Agentic reviews require a deny-by-default read-only guard, with verification before use and working-tree change detection.

    Graphify's Antigravity model receives text and returns text; it does not need filesystem write or execution tools. Graphify itself performs local processing and writes graph artifacts.

    These protections are not an operating-system sandbox.

    Source code and documents submitted to Antigravity are processed by Google's models. Only use the toolkit with material you are authorized to share.

    🚀 Requirements

    Core toolkit:

    • Google Antigravity CLI (agy), authenticated
    • Bun or Node.js 18.18+
    • Git for repository-based operations

    Additional Graphify requirements:

    • Graphify (graphifyy)
    • Python openai package in Graphify's environment

    The Graphify integration is optional. Code and security reviews do not require Graphify.

    💡 Who Is This For?

    • Software engineers using AI coding agents
    • Claude Code and Codex users
    • Security-conscious developers
    • Open-source maintainers
    • Teams maintaining large repositories
    • Developers building persistent code knowledge graphs
    • Engineers automating review and CI/CD workflows

    Open Source & Documentation

    MIT Licensed — Free and Open Source

    GitHub: https://github.com/Ealireza/agy-review

    Official Website: https://ealireza.github.io/agy-review/

    Graphify Documentation: https://github.com/Ealireza/agy-review/blob/main/docs/GRAPHIFY.md

    Review your code. Verify the evidence. Keep your knowledge graph fresh. Let Antigravity handle the work.

    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

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    • Free with an Agensi account

    Requires

    Git
    Python
    Windows
    Node.js

    Permissions

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

    What's inside

    Frequently Asked Questions

    Code review of your local git changes by Google Antigravity (agy), with read-only repo access and no permission prompts.

    This skill uses the open SKILL.md standard. Use it through an MCP-compatible agent connected to Agensi, and check the compatibility information on this page for confirmed agents and required capabilities.

    Connect your AI agent to Agensi through MCP, then ask it to use agy-review on your task. Your agent loads the latest approved version each time. Paid skills require a purchase or active subscription. Skill files are not available for download; your licence does not allow you to save, copy or export any part of a skill.