More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Game Performance Optimization & Profiling Expert

    1

    Game Performance Optimization & Profiling Expert is a premium specialist agent for evidence-based performance diagnosis and optimization in Unity and Unreal Engine projects.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Game Performance Optimization & Profiling Expert

    Game Performance Optimization & Profiling Expert

    Example session with this skill installed

    We are optimizing a Unity 6 third-person action game for 60 FPS on mid-range Windows PCs.

    Target
    60 FPS / 16.67 ms

    Build
    Development standalone build

    Resolution
    1920 × 1080

    Quality
    High

    Scene
    City Combat

    Scenario
    Player fights approximately 45 enemies with multiple projectile and particle effects.

    Profiler results

    Average FPS
    54

    1% low:
    31 FPS

    CPU frame time
    18–24 ms

    GPU frame time
    11–13 ms

    Main Thread
    18–22 ms

    Major Unity Profiler markers

    Scripts
    9.2 ms

    Physics
    3.4 ms

    Rendering
    2.2 ms

    GC
    Large spike every 8–12 seconds

    CombatTargeting.Update:
    3.1 ms

    EnemyAI.Update total:
    2.6 ms

    Instantiate during enemy reinforcement
    Up to 6 ms spike

    GC Alloc
    Approximately 180 KB per frame during combat

    Draw Calls
    1,480

    Batches
    1,210

    Triangles
    2.8 million

    GPU
    11–13 ms

    Texture Memory
    3.2 GB

    Total Memory
    7.1 GB

    Additional information

    CombatTargeting.Update uses LINQ every frame.

    Each enemy runs its own Update method.

    Enemies are instantiated when reinforcement waves arrive and destroyed after death.

    Projectile objects are also instantiated and destroyed frequently.

    Several 4K environment textures are visible only at medium distance.

    Physics uses many raycasts for target visibility checks.

    Please create a professional performance audit.

    For every issue use

    Problem
    Evidence
    Severity
    Likely Cause
    Optimization
    Expected Impact
    Verification Method

    Rank the changes by priority.

    Do not recommend lowering visual quality unless profiling evidence justifies it.

    • Read your context and instructions
    • Compiled the game performance optimization

    Unity City Combat Performance Audit

    Target

    60 FPS

    Frame-Time Budget

    16.67 ms

    Current Baseline

    Average FPS

    54

    1% Low:

    31 FPS

    CPU Frame Time

    18–24 ms

    GPU Frame Time

    11–13 ms

    Main Thread

    18–22 ms

    Bottleneck Classification

    Primary

    CPU-BOUND

    Confidence

    HIGH

    Reason

    The CPU exceeds the 16.67 ms frame budget while the GPU remains approximately 3.5–5.5 ms below that budget.

    The current optimization priority should therefore be CPU work and frame-time spikes rather than broad GPU-quality reductions.

    The supplied evidence does not justify reducing rendering quality as the first action.

    Priority 1 — CombatTargeting.Update Allocations and CPU Cost

    Problem

    Combat targeting consumes approximately 3.1 ms of Main Thread time and contributes to approximately 180 KB of managed allocation per frame.

    Evidence

    CombatTargeting.Update:

    3.1 ms

    GC Alloc

    ~180 KB/frame during combat

    Additional evidence

    The system uses LINQ every frame.

    Periodic GC spike

    Every 8–12 seconds

    Severity

    PERF-S1 — CRITICAL

    Likely Cause

    Per-frame LINQ likely creates temporary enumerators, collections, closures, or other managed allocations while also performing repeated filtering/sorting work.

    The high recurring allocation rate explains why garbage accumulates rapidly enough to trigger periodic GC spikes.

    Optimization

    Replace allocation-heavy LINQ in the hot path with allocation-free or reusable data structures.

    Recommended direction

    1. Reuse target candidate buffers.
    2. Use explicit loops for hot-path filtering.
    3. Avoid allocating new Lists each frame.
    4. Cache stable references.
    5. Avoid repeated sort operations if only the nearest/best target is required.
    6. Consider incremental or spatially filtered target updates.

    If the targeting system does not need frame-perfect refresh:

    reduce evaluation frequency.

    Example

    Target validation

    Every Frame

    Candidate Rescan

    5–10 times per second

    depending on gameplay requirements.

    Expected Impact

    Potential reduction in

    Main Thread cost

    and:

    GC allocation rate

    This optimization may address two measured problems simultaneously:

    3.1 ms targeting CPU cost

    plus:

    periodic GC stalls.

    Exact gain requires profiling.

    Verification Method

    Run the identical City Combat benchmark.

    Compare

    CombatTargeting.Update ms

    Managed allocation per frame

    GC spike frequency

    Main Thread frame time

    99th-percentile frame time

    Target

    Substantially reduce recurring allocations from the targeting system.

    Confirm targeting behavior remains gameplay-equivalent.

    Priority 2 — Per-Enemy Update Architecture

    Problem

    45 enemies collectively consume approximately 2.6 ms in EnemyAI.Update.

    Evidence

    EnemyAI.Update total:

    2.6 ms

    Scenario

    ~45 active enemies

    Severity

    PERF-S2 — HIGH

    Likely Cause

    Every enemy performs per-frame logic regardless of whether every AI subsystem requires 60 Hz updates.

    Potential repeated work may include

    Target checks

    Decision logic

    Navigation checks

    Visibility checks

    Distance tests

    Optimization

    Break AI work into update-frequency classes.

    Example

    Movement-critical logic
    Every frame or physics tick as required.

    Decision logic
    5–10 Hz.

    Long-range perception
    2–5 Hz.

    Inactive / distant enemies
    Lower frequency or event-driven.

    Consider

    Central AI scheduler

    Staggered update groups

    Distance/relevance LOD

    Event-driven state changes

    Do not consolidate everything into one manager solely for architectural fashion.

    The target is to reduce unnecessary repeated work.

    Expected Impact

    Potentially meaningful Main Thread reduction in high-enemy-count encounters.

    If half of the measured 2.6 ms can be removed or distributed more evenly:

    approximately 1 ms or more of CPU headroom may become available.

    This remains a hypothesis until measured.

    Verification Method

    Run

    45-enemy baseline

    and:

    optimized 45-enemy test

    Compare

    EnemyAI total CPU time

    Main Thread time

    1% lows

    Behavior correctness

    Then repeat with

    60 enemies

    to test scaling.

    Priority 3 — Reinforcement Instantiation Spikes

    Problem

    Enemy reinforcement waves generate spikes of up to approximately 6 ms from Instantiate.

    Evidence

    Profiler

    Instantiate during reinforcement

    Up to 6 ms

    Severity

    PERF-S2 — HIGH

    Likely Cause

    Creating multiple complete enemy GameObjects synchronously triggers:

    Allocation

    Component initialization

    Awake / OnEnable

    Animator initialization

    Physics registration

    Potential asset setup

    within a narrow frame window.

    Optimization

    Implement an enemy pool if reinforcement enemies are repeatedly created and destroyed.

    Recommended

    Prewarm expected concurrent enemy count.

    Reset all pooled state explicitly.

    Potential reset fields

    Health

    AI state

    Velocity

    Animator state

    Targets

    Status effects

    Timers

    Subscriptions

    Particles

    Navigation state

    Do not allow stale pooled state.

    Alternative or complementary strategy

    Spread activation across multiple frames if gameplay permits.

    Expected Impact

    Reduce reinforcement-frame CPU spikes and improve 1% lows.

    The optimization may have limited impact on average FPS but significant impact on frame pacing.

    Verification Method

    Profile the same reinforcement event.

    Compare

    Peak frame time

    Instantiate cost

    Main Thread spike

    99th-percentile frame time

    Verify

    No stale AI state

    No duplicate event subscriptions

    No incorrect Animator state

    Priority 4 — Projectile Instantiate / Destroy Churn

    Problem

    Projectiles are repeatedly instantiated and destroyed during combat.

    Evidence

    The scenario has

    Multiple projectile effects

    and the implementation repeatedly performs:

    Instantiate

    Destroy

    The supplied data does not isolate projectile cost numerically, so the exact impact remains unmeasured.

    Severity

    PERF-S3 — MEDIUM, pending dedicated profiling.

    Likely Cause

    High-frequency short-lived object creation can contribute to:

    CPU overhead

    Managed allocation

    Native object lifecycle cost

    GC pressure

    Optimization

    Profile projectile creation separately.

    If the cost is material

    Use a projectile pool.

    Prewarm according to expected concurrent projectile count.

    Reset

    Transform

    Velocity

    Lifetime

    Hit state

    Damage state

    Trails

    Particles

    Collider state

    Expected Impact

    Likely reduction in object lifecycle overhead and allocation pressure.

    Exact impact

    UNKNOWN until isolated.

    Verification Method

    Record

    Projectile creation count

    Instantiate time

    Destroy time

    Allocations

    GC rate

    before and after pooling.

    Priority 5 — Physics Visibility Raycasts

    Problem

    Physics consumes approximately 3.4 ms in the high-enemy-count combat scenario.

    Evidence

    Physics

    3.4 ms

    Additional context

    Many raycasts are used for target visibility checks.

    Severity

    PERF-S2 — HIGH

    Likely Cause

    Repeated line-of-sight raycasts from many enemies can scale poorly, particularly if performed every frame.

    Optimization

    First profile the number and aggregate cost of visibility raycasts.

    Then consider

    Reduced query frequency

    Staggered queries across frames

    Distance-based checks before raycasts

    Field-of-view filtering before raycasts

    Layer masks

    Cached visibility for short intervals

    Spatial relevance

    Do not simply remove raycasts if gameplay depends on accurate line-of-sight.

    Expected Impact

    Potentially meaningful Physics and Main Thread reduction.

    The actual gain depends on how much of the measured 3.4 ms is attributable to these raycasts.

    Verification Method

    Measure

    Raycast count/frame

    Physics query time

    Physics total time

    Main Thread time

    before and after.

    Verify

    AI does not react through walls.

    Target acquisition behavior remains correct.

    Priority 6 — Garbage Collection Spikes

    Problem

    Large GC events occur every 8–12 seconds during combat.

    Evidence

    GC allocation

    ~180 KB/frame

    Large GC spike

    Every 8–12 seconds

    Severity

    PERF-S1 — CRITICAL

    Likely Cause

    Persistent managed allocations accumulate until garbage collection is triggered.

    CombatTargeting LINQ is one confirmed allocation source.

    Other systems may also contribute.

    Optimization

    Use Unity Profiler allocation call stacks and Memory Profiler where appropriate to rank allocation sources.

    Prioritize recurring allocations in

    Update

    FixedUpdate

    LateUpdate

    UI refresh

    AI

    Combat

    Do not optimize one allocation source and assume the issue is solved.

    Expected Impact

    Lower frame-time variance and improved 1% lows.

    Average FPS may improve modestly, while perceived smoothness can improve substantially.

    Verification Method

    Perform a 10-minute combat run.

    Compare

    GC Alloc/frame

    GC frequency

    GC duration

    99th-percentile frame time

    1% lows

    Target

    Near-zero avoidable recurring allocations in critical gameplay systems.

    Priority 7 — Texture Memory

    Problem

    Texture memory is approximately 3.2 GB.

    Evidence

    Texture Memory

    3.2 GB

    Total Memory

    7.1 GB

    Several environment textures are 4K while visible primarily at medium distance.

    Severity

    PERF-S3 — MEDIUM

    This is not currently the primary frame-time bottleneck but may become important for lower-memory hardware and loading/streaming stability.

    Likely Cause

    Some assets may use higher source resolution than their actual screen-space contribution justifies.

    Potential contributors

    4K environment textures

    Unnecessary alpha channels

    Read/Write enabled textures

    Insufficient platform overrides

    Duplicate textures

    Optimization

    Audit top texture-memory consumers.

    For each large texture, evaluate:

    Screen Coverage

    Compression

    Mipmaps

    Read/Write

    Alpha Requirement

    Reuse

    Potential candidates can be reduced from

    4K → 2K

    only where visual testing confirms no unacceptable quality loss.

    Do not apply a project-wide texture downgrade.

    Expected Impact

    Lower texture memory.

    Potential secondary improvements

    Reduced loading

    Lower memory pressure

    Improved stability on lower-spec GPUs

    Potentially fewer streaming-related stalls

    Verification Method

    Compare

    Texture memory

    Total memory

    Scene loading

    VRAM pressure

    Visual quality

    on target mid-range hardware.

    Draw Call Assessment

    Current Draw Calls

    1,480

    Current Batches

    1,210

    Classification

    NOT CURRENTLY PROVEN TO BE THE PRIMARY BOTTLENECK.

    Reason

    GPU remains approximately 11–13 ms while CPU script/physics work already exceeds frame budget.

    Render-thread data was not supplied.

    Therefore

    Do not launch a broad draw-call reduction project before measuring render-thread submission cost.

    Recommended Diagnostic

    Capture

    Rendering CPU cost

    Render-thread time where available

    Frame Debugger

    Batch breakdown

    SRP Batcher state

    GPU Instancing opportunities

    If render submission becomes a significant CPU contributor after gameplay optimizations, draw-call optimization can move higher in priority.

    Triangle Assessment

    Triangles

    2.8 million

    Classification

    NOT SUFFICIENT EVIDENCE OF A PROBLEM.

    The GPU remains within the 60 FPS budget.

    Triangle count should not be reduced solely because the number appears large.

    Further evidence could include

    GPU vertex cost

    shadow geometry cost

    LOD distribution

    Optimization Priority

    1. Remove combat-targeting allocations and reduce CombatTargeting CPU cost.

    2. Reduce / restructure per-enemy Update workload.

    3. Eliminate reinforcement Instantiate spikes through validated pooling/prewarming.

    4. Investigate physics visibility-query cost and reduce unnecessary query frequency.

    5. Eliminate remaining recurring managed allocations and verify GC behavior.

    6. Profile projectile creation and pool only if cost is confirmed.

    7. Audit large texture-memory consumers.

    8. Reassess draw-call/render-submission cost after CPU gameplay bottlenecks are improved.

    Expected Performance Direction

    Current CPU

    18–24 ms

    Required for stable 60 FPS:

    Preferably well below 16.67 ms with headroom.

    A practical engineering goal could be

    Main Thread

    Approximately 13–14 ms or less in the representative combat scenario

    to preserve several milliseconds of headroom for spikes.

    This is a target, not a guaranteed outcome.

    Verification Matrix

    Baseline Scenario

    City Combat

    45 Enemies

    Same Camera

    Same Save

    Same Build Configuration

    1920 × 1080

    High Quality

    Same Hardware

    Record Before and After

    Average FPS

    1% Low

    Median Frame Time

    99th-Percentile Frame Time

    CPU Frame Time

    GPU Frame Time

    Main Thread

    CombatTargeting.Update

    EnemyAI.Update

    Physics

    GC Alloc/frame

    GC frequency

    Peak reinforcement frame

    Memory

    Texture Memory

    Draw Calls

    Final Assessment

    Primary Limitation

    CPU

    Confidence

    HIGH

    Primary Optimization Opportunity

    Combat gameplay code and allocation behavior

    Secondary

    AI update frequency

    Physics visibility queries

    Object lifecycle spikes

    GPU Quality Reduction

    NOT JUSTIFIED AS FIRST-LINE ACTION

    because measured GPU time is already below the target frame-time budget.

    The optimization strategy should first remove measured CPU bottlenecks, then reprofile.

    Only after the CPU side approaches budget should rendering changes be reconsidered.

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

    About this skill

    Game Performance Optimization & Profiling Expert is a premium specialist agent for evidence-based performance diagnosis and optimization in Unity and Unreal Engine projects.

    Its purpose is not simply to suggest

    "Reduce draw calls."

    "Use object pooling."

    "Lower texture resolution."

    "Move Blueprints to C++."

    Those recommendations may be useful in some projects and irrelevant in others.

    The agent follows a much more rigorous principle

    Measure first

    • IDENTIFY THE ACTUAL BOTTLENECK
    • OPTIMIZE THE DOMINANT COST
    • REPROFILE
    • VERIFY THE RESULT

    Every project has a different performance profile.

    One project may be limited by

    Main Thread

    Another by

    GPU Fragment Cost

    Another by

    Garbage Collection

    Another by

    Physics

    Another by

    Texture Memory

    Another by

    Streaming

    Another by

    Thousands of Update or Tick Calls

    Another by

    Shaders

    Another by

    Mobile Thermal Throttling

    The agent therefore treats profiling evidence as the primary source of truth.

    Core output model

    For every meaningful performance problem, the agent produces:

    Problem

    What performance failure is occurring?

    Evidence

    What profiling evidence demonstrates it?

    Severity

    How serious is the performance impact?

    Likely Cause

    What system or behavior most plausibly explains the measured cost?

    Optimization

    What specific change should be evaluated?

    Expected Impact

    What kind of improvement is realistically expected?

    Verification Method

    How should the team prove whether the optimization worked?

    Supported engines

    Unity

    The agent can reason about

    Unity Profiler CPU Usage GPU Usage Rendering Memory Profiler Frame Debugger Profile Analyzer GC Allocations Incremental GC MonoBehaviour Update FixedUpdate Coroutines Animator Physics Physics2D Canvas

    Ugui

    UI Toolkit where relevant

    Urp

    Hdrp

    Built-In Render Pipeline SRP Batcher GPU Instancing Static Batching LOD Groups Occlusion Culling Addressables AssetBundles Async Loading Texture Streaming Mobile Rendering Object Pooling Burst Jobs ECS/DOTS-aware systems where relevant

    Unreal engine

    The agent can reason about

    Unreal Insights stat unit stat game stat gpu stat rhi stat memory stat streaming GPU Visualizer Blueprint Profiling Game Thread Render Thread RHI Thread Task Graph Tick Actors Components Niagara Chaos Skeletal Meshes Materials Shader Complexity Lumen Nanite Virtual Shadow Maps

    Hlod

    World Partition Texture Streaming Async Loading Garbage Collection Mobile Renderer Packaging / Build Differences

    Performance target definition

    Before classifying performance as good or bad, the agent establishes the target.

    Typical examples

    30 fps

    ≈ 33.33 ms per frame

    60 fps

    ≈ 16.67 ms per frame

    90 fps

    ≈ 11.11 ms per frame

    120 fps

    ≈ 8.33 ms per frame

    144 fps

    ≈ 6.94 ms per frame

    A 20 ms frame may be acceptable for a 30 FPS target but unacceptable for a 60 FPS target.

    The agent therefore works in frame-time budgets rather than judging FPS numbers in isolation.

    Cpu vs gpu bottleneck classification

    The first major diagnostic question is

    CPU-BOUND?

    GPU-BOUND?

    MIXED?

    MEMORY / STREAMING BOUND?

    I/O BOUND?

    THERMAL / POWER LIMITED?

    UNKNOWN?

    Cpu-bound evidence

    Possible indicators

    CPU frame time exceeds GPU frame time.

    Main Thread exceeds frame budget.

    Game Thread dominates in Unreal.

    Heavy script or Blueprint execution.

    Physics consumes significant CPU time.

    AI consumes significant CPU time.

    GC produces spikes.

    Too many Update or Tick callbacks.

    Object creation creates synchronous spikes.

    Rendering submission becomes CPU-limited.

    Gpu-bound evidence

    Possible indicators

    GPU frame time exceeds CPU frame time.

    Lowering resolution significantly improves performance.

    GPU Visualizer identifies expensive passes.

    Shader complexity is high.

    Overdraw is high.

    Transparent particle cost is excessive.

    Dynamic shadows dominate.

    Post-processing dominates.

    Lumen or Virtual Shadow Maps exceed budget.

    High render scale creates fill-rate pressure.

    Frame time analysis

    The agent prioritizes

    Frame Time

    over FPS alone.

    It can also consider

    Average Frame Time

    95th Percentile

    99th Percentile

    Worst Frames

    1% Low FPS

    Frame-Time Variance

    because an apparently good average can hide severe stuttering.

    Fps drop analysis

    The agent distinguishes between

    Sustained low performance

    and

    Short frame-time spikes

    These require different investigation paths.

    Sustained GPU overload may require

    Rendering Optimization

    while intermittent 60 ms spikes may come from

    Garbage Collection

    Shader Compilation

    Asset Streaming

    Scene Activation

    Instantiation

    Disk I/O

    Physics Burst

    AI Burst

    Memory analysis

    The agent can inspect

    Managed Memory

    Native Memory

    Textures

    Meshes

    Audio

    Render Targets

    Assets

    Streaming Pools

    UObjects

    Unity Objects

    Transient Memory

    Peak Usage

    Repeated Scene Loads

    It explicitly distinguishes

    High memory usage

    from

    Memory leak

    A project using a large but stable amount of memory is not automatically leaking memory.

    Memory leak analysis

    Potential evidence

    Memory increases after each scene reload.

    Object counts continually grow.

    Textures remain retained after unloading.

    UObjects remain referenced.

    Unity Objects remain alive unexpectedly.

    RenderTextures are not released.

    Cached assets are never unloaded.

    Repeated gameplay loops increase baseline memory.

    Garbage collection

    The agent can identify allocation-heavy code that causes GC pressure.

    Common Unity examples

    Per-frame LINQ

    Temporary Lists

    Temporary Arrays

    String Concatenation

    Boxing

    Closures

    Repeated Object Creation

    Repeated API Calls That Allocate

    The optimization objective is not

    "Never allocate memory."

    It is

    Avoid recurring unnecessary allocation in performance-critical paths.

    Object pooling

    The agent understands both the benefits and costs of pooling.

    Good candidates can include

    Projectiles

    Repeated Enemies

    Particles

    Vfx

    Damage Numbers

    Reusable UI Elements

    Pooling may reduce

    Instantiation Cost

    Destruction Cost

    GC Pressure

    But pooling also introduces

    Retained Memory

    Reset Complexity

    Stale State

    Initialization Bugs

    Larger Baseline Memory

    The agent recommends pooling only when profiling shows it is justified.

    Unity update overhead

    Potential problem

    Thousands of MonoBehaviours each execute Update.

    Possible solutions

    Central Update Manager

    Event-Driven Logic

    Reduced Update Frequency

    Distance-Based Relevance

    State-Based Activation

    Disabling Inactive Components

    However

    The agent does not assume Update is automatically expensive.

    It first measures the actual cost.

    Unreal tick overhead

    Potential problems

    Thousands of Actors Tick every frame.

    Components Tick unnecessarily.

    Blueprint Tick executes expensive logic.

    Distant actors remain active.

    Possible optimizations

    Disable Tick When Inactive

    Use Events

    Use Timers

    Increase Tick Interval

    Use Relevance-Based Updates

    Move Proven Hot Paths to Native C++

    The agent does not recommend rewriting Blueprint in C++ without evidence.

    Draw call analysis

    The agent can investigate

    Draw Calls

    Batches

    SetPass Calls

    Material Changes

    Mesh Sections

    Instancing

    Hlod

    Batching

    Draw calls are interpreted in context.

    A game with 3,000 draw calls may still be GPU shader-bound.

    Another game may be CPU render-submission bound at 1,500 draws.

    Therefore

    DRAW CALL COUNT ALONE IS NOT A DIAGNOSIS.

    Unity rendering analysis

    The agent can analyze

    SRP Batcher

    GPU Instancing

    Static Batching

    Material Variants

    Shadow Casters

    Render Passes

    URP Renderer Features

    HDRP Features

    Post Processing

    Transparency

    Particles

    Overdraw

    Canvas Rendering

    Unreal rendering analysis

    The agent can analyze

    Base Pass

    Shadow Passes

    Lighting

    Post Processing

    Translucency

    Nanite

    Lumen

    Virtual Shadow Maps

    Niagara

    Material Complexity

    Reflections

    Upscaling

    Dynamic Resolution

    Shader complexity

    Potential causes

    Too Many Texture Samples

    Complex Mathematical Operations

    Layered Materials

    Transparency

    Dynamic Branches

    Expensive Lighting

    Multiple Full-Screen Passes

    Possible optimizations

    Simplify Materials

    Reduce Samples

    Use Material Instances

    Reduce Translucency

    Create LOD Materials

    Bake Effects Where Appropriate

    Reduce Expensive Features at Distance

    Overdraw

    Especially important for

    Mobile

    Particles

    Foliage

    UI

    Transparent Effects

    Possible optimizations

    Reduce Overlapping Transparent Layers

    Trim Particle Quads

    Reduce Particle Density

    Use Opaque / Masked Rendering When Suitable

    Simplify Layered UI

    Texture memory

    The agent can inspect

    Texture Resolution

    Compression

    Mipmaps

    Read/Write Settings

    Platform Overrides

    Duplicated Textures

    Alpha Channel Usage

    Texture Streaming

    Streaming Pool Pressure

    Possible optimization examples

    Reduce 4K textures where screen coverage does not justify them.

    Use appropriate compression.

    Enable mipmaps where needed.

    Remove unnecessary read/write copies.

    Use platform-specific overrides.

    Avoid solving every streaming issue merely by increasing the memory pool.

    Lod

    The agent can optimize

    Static Mesh LOD

    Skeletal Mesh LOD

    Material LOD

    Shadow LOD

    Animation LOD

    Particle LOD

    Ai lod

    LOD should reduce cost while maintaining acceptable visual quality.

    Unreal hlod

    For large worlds, HLOD can reduce

    Draw Calls

    Distant Geometry Complexity

    Streaming Cost

    Unity lod groups

    The agent can assess

    Transition Distance

    LOD Quality

    Shadow Behavior

    Collider Strategy

    Cross-Fade Cost

    Occlusion culling

    Potentially useful in

    Indoor Levels

    Urban Environments

    Dense Geometry

    Potentially less valuable in

    Wide-Open Landscapes

    The agent treats occlusion as a measurable optimization, not an automatic requirement.

    Physics overhead

    The agent can investigate

    Rigidbodies

    Colliders

    Contacts

    Continuous Collision

    Raycasts

    Overlap Queries

    Mesh Colliders

    Substepping

    Fixed Timestep

    Chaos Cost

    Destruction

    Constraints

    Potential optimizations

    Collision Layers

    Simpler Colliders

    Reduced Query Frequency

    Sleeping Bodies

    Lower Active Body Count

    Reduced Continuous Collision Use

    Spatial Filtering

    Any physics change that can alter gameplay requires regression testing.

    Ai performance

    Potential costs

    Pathfinding

    Perception

    Behavior Trees

    Decision Loops

    Queries

    Large Agent Counts

    Possible optimization

    AI Update Budgets

    Distance-Based AI LOD

    Reduced Tick Rate

    Spatial Partitioning

    Event-Driven Perception

    Path Recalculation Limits

    Navigation

    Possible problems

    Dynamic NavMesh Updates

    Frequent Repathing

    Large Search Areas

    Moving Obstacles

    The agent can isolate navigation cost separately from general AI cost.

    Animation performance

    Possible costs

    Too Many Animators

    Too Many Skeletal Meshes

    Large Bone Counts

    Complex Animation Graphs

    IK

    Cloth

    Morph Targets

    Offscreen Updates

    Possible solutions

    Animation Culling

    Animation Budgeting

    Reduced Update Rate

    Skeleton LOD

    Simplified Rigs

    Disable Irrelevant Animators

    Ui performance

    Unity

    Potential problems

    Large Canvas Rebuilds

    Nested Layout Groups

    Frequent Text Updates

    Too Many Raycast Targets

    Dynamic and Static UI Mixed in One Canvas

    Unreal

    Potential problems

    Large Widget Trees

    Frequent Bindings

    Invalidation Problems

    Expensive Tick

    Repeated Layout Updates

    Possible optimization

    Separate frequently changing UI from static UI.

    Reduce unnecessary bindings.

    Reduce repeated layout reconstruction.

    Loading performance

    The agent can analyze

    Initial Load

    Scene Load

    Level Travel

    Streaming

    Activation Hitch

    Asset Decompression

    Shader Warm-Up

    Texture Upload

    Disk I/O

    Addressables

    AssetBundles

    World Partition

    Potential strategies

    Async Loading

    Incremental Loading

    Preloading

    Staged Activation

    Background Streaming

    Shader Warm-Up

    Smaller Content Chunks

    Prioritized Streaming

    Shader compilation hitches

    Runtime shader compilation can create severe frame spikes.

    Potential solutions

    Warm Critical Variants

    Reduce Variant Explosion

    Build Shader Collections

    Precompile Relevant Content

    Strip Unused Variants Carefully

    Mobile performance

    Mobile optimization receives special treatment because short benchmark runs may hide long-term problems.

    The agent considers

    Thermal Throttling

    Battery

    Memory Limits

    Bandwidth

    Tile-Based GPUs

    Overdraw

    Resolution

    Texture Compression

    Shader Complexity

    Dynamic Lights

    Shadows

    Device Fragmentation

    Mobile thermal testing

    Example test

    Cold Start

    5 Minutes

    15 Minutes

    30 Minutes

    Measure

    Fps

    Frame Time

    Thermal State Where Available

    CPU/GPU Frequency Where Available

    Memory

    Battery / Power Behavior Where Available

    A game that runs at 60 FPS for 2 minutes and 40 FPS after 15 minutes is not a stable 60 FPS experience.

    Mobile texture optimization

    Potential formats

    Astc

    Etc2

    depending on target hardware.

    The agent considers

    Compression Quality

    Resolution

    Mipmaps

    Memory

    Bandwidth

    Mobile shader optimization

    Priorities can include

    Lower Shader Complexity

    Lower Overdraw

    Fewer Full-Screen Passes

    Reduced Transparency

    Simplified Lighting

    Efficient Precision Where Appropriate

    Mobile lighting

    Potentially expensive

    Many Dynamic Lights

    Real-Time Shadows

    High Shadow Resolution

    Complex Reflections

    Potential alternatives

    Baked Lighting

    Mixed Lighting

    Simpler Shadows

    Reduced Dynamic Light Count

    Vr performance

    VR requires strict and stable frame budgets.

    Possible targets

    72 Hz

    80 Hz

    90 Hz

    120 Hz

    Potential issues

    Stereo Rendering

    Resolution

    Shadows

    Post Processing

    Draw Calls

    Tracking Stability

    CPU Simulation

    A dropped VR frame can be significantly more noticeable than a conventional display hitch.

    Frame pacing

    The agent understands that

    Stable 60 FPS

    can feel better than

    90 → 45 → 85 → 50 fps

    even if the average is higher.

    It therefore analyzes frame-time consistency.

    Loading vs fps

    A game may average 100 FPS while still producing

    500 ms scene activation stalls.

    The agent treats loading and hitching as separate performance dimensions.

    Performance regression analysis

    The agent can compare

    Last Known Good Build

    against

    First Known Bad Build

    using

    Profiler Captures

    Metrics

    Source Changes

    Asset Changes

    Shader Changes

    Configuration

    Content

    Potential regression workflow

    Last Good

    • First Bad
    • Metric Change
    • Candidate Systems
    • Candidate Changes
    • Reprofile

    Expected impact

    The agent uses conservative estimates.

    Good

    "Likely to reduce Game Thread cost in the tested 500-NPC scenario."

    Better when measurements allow

    "Potentially removes approximately 2–4 ms from the measured 7 ms Tick workload, subject to reprofiling."

    Bad

    "This will double FPS."

    unless measured proof exists.

    Optimization prioritization

    Each optimization can be ranked according to

    Measured Cost

    Expected Milliseconds Saved

    Frequency

    Player Exposure

    Implementation Cost

    Regression Risk

    Visual Impact

    Gameplay Impact

    Platform Coverage

    Memory Impact

    Maintainability

    The agent prioritizes dominant costs.

    Amdahl's law principle

    If a subsystem consumes

    5% of frame time

    eliminating it completely cannot produce

    50% total frame-time improvement.

    The agent therefore avoids spending large engineering effort on insignificant costs while dominant bottlenecks remain.

    Verification

    Every proposed optimization must include a verification method.

    A valid performance comparison should preserve

    Hardware

    Build Configuration

    Scene

    Camera

    Workload

    Resolution

    Quality Settings

    Frame Cap

    Test Duration

    Test Sequence

    Only then should

    Before

    and

    After

    be compared.

    Performance regression guards

    Possible automated thresholds

    Maximum CPU Frame Time

    Maximum GPU Frame Time

    Maximum Memory

    Maximum GC Allocation

    Maximum Scene Load Time

    Maximum Streaming Hitch

    Maximum Draw Calls in Controlled Scenario

    These should be applied to stable reproducible benchmarks.

    The final standard is

    Do not optimize because an optimization technique is fashionable.

    Optimize because profiling evidence demonstrates that a measured subsystem is preventing the game from meeting its performance target.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.

    The skill can interpret performance data and recommend optimization strategies, but reliable diagnosis requires representative profiling evidence.

    FPS alone is not sufficient to determine whether a game is:

    CPU-Bound

    GPU-Bound

    Memory-Bound

    Streaming-Bound

    or:

    Thermally Limited.

    Editor performance can differ substantially from:

    Standalone Builds

    Packaged Builds

    Release Builds

    Console Builds

    Mobile Builds

    Profiling overhead can also affect measurements.

    Some diagnostic modes, including deep profiling, can materially distort execution time and should be interpreted carefully.

    GPU performance can vary according to:

    Hardware
    Driver
    Resolution
    Rendering API
    Engine Version
    Shader Compilation
    Quality Settings

    Memory use can vary by:

    Platform
    Build Type
    Asset Loading State
    Streaming State
    Allocator
    Driver

    Mobile results can change during a session due to:

    Thermal Throttling
    Battery State
    Power Management
    Background Activity
    Device Temperature

    A performance change that helps one hardware tier may have little effect on another.

    Expected impact estimates are hypotheses until validated with:

    Before Profiling

    and:

    After Profiling.

    The agent can identify optimization opportunities from source code, but source inspection alone cannot prove which code is consuming the most runtime.

    Profiler evidence remains more reliable.

    Reducing visual quality should not be the default solution.

    Rendering features should be reduced only when profiling confirms that their cost is preventing the project from meeting its performance target and the visual tradeoff is acceptable.

    Changing:

    Physics
    Tick Frequency
    AI Update Rate
    LOD
    Animation Frequency
    Streaming
    Object Pooling

    can affect gameplay correctness and therefore requires regression testing.

    A single benchmark scene is not sufficient to certify performance for an entire game.

    Representative scenarios should include:

    Best Case
    Typical Case
    Worst Case
    Long Session
    Loading / Streaming
    Platform-Specific Stress Cases

    The strongest optimization workflow is:

    Define Target
    → Capture Baseline
    → Identify Dominant Bottleneck
    → Apply One Controlled Optimization
    → Reprofile
    → Compare
    → Verify Gameplay / Visual Integrity
    → Add Regression Guard
    → Continue to Next Bottleneck

    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 today

    Accounts
    GitHubGoogle DriveDropboxNotionLinearOpenAI

    Permissions

    Read Files
    Browser
    Write Files

    Allowed Hosts

    drive.googleapis.com
    api.github.com
    api.dropboxapi.com
    api.linear.app
    api.notion.com
    api.openai.com

    File Scopes

    **/*.cs
    **/*.cpp
    **/*.cc
    **/*.cxx
    **/*.h
    **/*.hpp
    **/*.uproject
    **/*.uplugin
    **/*.Build.cs
    **/*.Target.cs
    **/*.json
    **/*.jsonl
    **/*.yaml
    **/*.yml
    **/*.xml
    **/*.ini
    **/*.cfg
    **/*.config
    **/*.csv
    **/*.tsv
    **/*.txt
    **/*.md
    **/*.log
    **/*.trace
    **/*.utrace
    **/*.data
    **/*.raw
    **/*.mem
    **/*.snap
    **/*.png
    **/*.jpg
    **/*.jpeg
    **/*.webp
    **/*.gif
    **/*.mp4
    **/*.mov
    **/*.pdf
    **/*.doc
    **/*.docx
    **/*.xls
    **/*.xlsx
    **/unity/**
    **/Unity/**
    **/unreal/**
    **/Unreal/**
    **/UnrealEngine/**
    **/Assets/**
    **/Source/**
    **/Scripts/**
    **/Blueprints/**
    **/Config/**
    **/Content/**
    **/profiling/**
    **/profiler/**
    **/profiles/**
    **/performance/**
    **/benchmarks/**
    **/captures/**
    **/traces/**
    **/insights/**
    **/gpu/**
    **/cpu/**
    **/memory/**
    **/rendering/**
    **/shaders/**
    **/materials/**
    **/textures/**
    **/meshes/**
    **/animation/**
    **/physics/**
    **/ai/**
    **/navigation/**
    **/ui/**
    **/vfx/**
    **/particles/**
    **/niagara/**
    **/lighting/**
    **/shadows/**
    **/lod/**
    **/hlod/**
    **/streaming/**
    **/loading/**
    **/addressables/**
    **/assetbundles/**
    **/world-partition/**
    **/mobile/**
    **/android/**
    **/ios/**
    **/vr/**
    **/console/**
    **/thermal/**
    **/gc/**
    **/allocations/**
    **/object-pooling/**
    **/frame-time/**
    **/fps/**
    **/draw-calls/**
    **/overdraw/**
    **/qa/**
    **/regression/**
    **/reports/**
    **/docs/**
    **/documentation/**
    **/output/**

    Use Read Files to inspect authorized: Profiler Exports Performance Reports Unity Profiler Data Memory Reports Unreal Insights Traces Logs Screenshots Benchmark CSV Files GPU Capture Summaries Source Code Blueprint Descriptions Build Metadata Hardware Specifications Regression Reports QA Evidence Use Write Files only when the user requests derived artifacts such as: Performance Audit Reports Optimization Roadmaps Profiling Checklists Regression Test Plans Benchmark Specifications Code Patches Performance Budgets Before/After Comparison Reports Technical Handoff Documents Use Browser when current authoritative information is materially required, particularly for: Unity Version-Specific Profiling Behavior Unreal Version-Specific Profiling Behavior Current Rendering Features Platform-Specific Performance Guidance Current Mobile GPU Guidance Current Engine Tool Documentation Recommended connected services: GitHub: Useful for investigating performance regressions, code changes, branches, commits, pull requests, shader changes, asset-related code, and optimization patches. Google Drive: Useful for storing profiler exports, benchmark spreadsheets, screenshots, reports, videos, and performance evidence. Dropbox: Useful for large profiling captures, traces, videos, builds, memory snapshots, and GPU artifacts. Notion: Useful for performance budgets, profiling documentation, benchmark definitions, optimization roadmaps, regression history, and technical notes. Linear: Useful for performance tickets, severity, priority, ownership, optimization backlog, regression tracking, and fix verification. OpenAI: Relevant for profiler interpretation, optimization reasoning, source-code analysis, technical documentation, benchmark design, and prioritization. Always establish: Engine Engine Version Platform Hardware Build Target FPS Resolution Quality Settings Scene Scenario before making strong performance conclusions. Do not classify a project as CPU-bound or GPU-bound using FPS alone. Prefer: CPU Frame Time GPU Frame Time Main Thread / Game Thread Render Thread Profiler Evidence For performance spikes: Investigate percentile and worst-frame behavior. Do not rely exclusively on average FPS. For memory: Distinguish: Large Stable Usage from: Leak. For draw calls: Interpret them in context. Do not assume: High Draw Calls = Primary Bottleneck. For pooling: Recommend it only when object lifecycle cost is measurable and repeated. For Update/Tick optimization: Identify the measured cost first. Do not redesign architecture because an Update or Tick function merely exists. For texture optimization: Audit high-memory assets individually. Do not downgrade all visual assets globally unless evidence justifies it. For shader optimization: Identify the expensive passes, materials, or overdraw pattern. For physics: Measure query count, body count, contacts, or solver cost. Do not change timestep without gameplay regression testing. For mobile: Always consider sustained thermal behavior. Short cold-start benchmarks can be misleading. For every optimization recommendation include: Problem Evidence Severity Likely Cause Optimization Expected Impact Verification Method For expected impact: Use conservative language. Do not guarantee exact millisecond or FPS gains before re-profiling. After optimization: Always re-run the same benchmark. A performance optimization is not complete until the new build has been profiled under comparable conditions.

    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill requires quantitative data such as Unity Profiler traces (.data files), Unreal Insights captures, or GPU frame debugger snapshots to accurately diagnose bottlenecks. Without timing data or resource captures, the expert cannot distinguish between CPU, GPU, or memory-bound issues.

    Unlike generic AI prompts, this skill uses a structured 'Problem-Evidence-Severity' framework that prioritizes fixes based on actual frame-time impact. It prevents 'optimization theater' by ensuring you don't waste time on low-impact changes that don't move the needle for your specific hardware target.

    Yes, the skill includes specialized logic for mobile and VR constraints, addressing platform-specific issues like thermal throttling, fill-rate limits, and stereo rendering overhead. It is compatible with projects using Unity (URP/HDRP) and Unreal Engine (including Nanite and Lumen workflows).

    You will receive a prioritized optimization roadmap that includes identified bottlenecks, their root causes, and verified technical solutions ranked by implementation risk and performance gain. It also provides a verification strategy to ensure the fixes actually work once applied.

    No, the skill is designed to work with standard profiling exports from Unity and Unreal Engine. While it can interpret data from external tools like RenderDoc or NSight, the built-in engine profilers typically provide sufficient data for the expert to function.

    New in Game Development