Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Unity Screenshot Verify

    1

    Give your agent eyes on Unity: four framed angles, one contact sheet, plus a bounds report.

    Free

    1 useSecurity scanned
    Unity Screenshot Verify

    Unity Screenshot Verify

    Example session with this skill installed

    I rescaled the kart prefab and changed its paint material. Capture front, side and back views and tell me whether the wheels still sit on the ground.

    • Read your context and instructions
    • Compiled the unity screenshot verify
    • Generated the document

    Summary

    Captured 4 views and read the bounds report. The wheels float: the lowest rendered point sits at Y = 0.35 while the prefab pivot is at Y = 0. Materials render normally (no pink), so the shader path is intact and the rescale is the only regression.

    Views

    viewfilewhat it shows
    front_leftCaptures/shot_front_left.pngfull chassis, all four wheels visible
    frontCaptures/shot_front.pngleft/right wheel gap equal
    leftCaptures/shot_left.pngground line 0.35 m below the tyres
    back_rightCaptures/shot_back_right.pngspoiler intact, no clipping into the body

    Contact sheet: Captures/contact_sheet.png (1024x1024, 2x2, cells 512 px).

    Bounds report

    target=Kart
    center=(0.0, 0.71, 0.0)
    size=(1.40, 1.06, 2.32)
    min=(-0.70, 0.35, -1.16) max=(0.70, 1.41, 1.16)
    groundY=0.35
    

    groundY=0.35 is the bug: once the prefab is placed on the track surface the kart hovers by 0.35 m.

    Fix

    Move the child body transform to Y = -0.35, or move the prefab pivot down to the tyre contact plane. Re-run the same command and confirm groundY reads 0.0 before committing.

    shot_front_left.png

    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

    The problem

    Your coding agent edits Unity C# or scene data, then reports "done" without ever seeing the Game view. You press Play, find a sunken mesh, a pink material or clipped UI, and the loop restarts.

    What this skill does

    It gives the agent eyes and a repeatable loop:

    1. Detect the editor path and the render pipeline (Built-in / URP / HDRP) instead of guessing.
    2. Install a small editor-only harness (references/AgentCapture.cs) and prove it works with AgentCapture.SelfTest, which captures three throwaway primitives and deletes them again.
    3. Capture four deterministic views framed from the target's world bounds, in batch mode, no player build needed.
    4. Compose them into one labelled 2x2 contact sheet with scripts/contact_sheet.py.
    5. Read the bounds report (center, size, min/max, ground Y) so a scale regression cannot hide behind a good-looking frame.

    Why not just take a screenshot

    • Views are framed from world bounds, never from Camera.main, so runs are comparable change to change.
    • Exit codes mean something: 0 captured, 3 target not found, 4 nothing renderable, 1 exception. A run that cannot see the subject fails instead of writing four identical background frames.
    • The pitfalls are the ones agents actually hit: pink shaders from shader stripping, procedural meshes that do not exist in batch mode yet, DontSaveInEditor leftovers, Screen Space Overlay canvases that no camera renders, -nographics black frames, and a stale first frame that needs a warm-up render.

    Scope

    Meshes, props, characters, procedurally generated geometry, UI layouts and whole scenes. The four view labels are a starting set; edit the Views array for your own angles.

    Requires GPU for non-black images. Does not support Screen Space - Overlay UI. Procedural meshes must be instantiated before capture. Import must finish before GUIDs resolve.

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

    • Free with an Agensi account

    Requires

    Unity Editor 2021.3+
    Windows
    macOS
    Linux
    Python 3.8+
    Pillow
    Graphics device or software renderer
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed24 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as 'eyes' for your AI coding agent, allowing it to autonomously verify that C# or shader changes actually look right in Unity without you having to manually open the Editor and press Play.

    The skill is designed for use with any LLM or AI agent that has file system access and terminal execution capabilities, such as Claude (via MCP), AutoGPT, or custom Python-based agents.

    You receive the core Editor-side capture harness, the Python image processing suite for contact sheet generation, and the orchestration logic that bridges your AI agent to the Unity batch-mode process.

    No manual setup is required; the skill automatically detects your project's Unity version, active Render Pipeline (URP, HDRP, or Built-in), and world-space bounds to ensure perfect framing every time.

    It requires a machine with a GPU (or a software renderer) because Unity's batch mode still needs a graphics device to render textures, and it does not support Screen Space - Overlay UI.

    The skill identifies 'magenta' shader errors, clipping issues, and scale discrepancies by comparing the rendered visuals against a text-based world-space bounds report.

    New in Game Development