- Home
- Skills
- Game Development
- Game Performance Optimization & Profiling Expert
More screenshots
Works with the AI Agents you already use
Game Performance Optimization & Profiling Expert
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
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
- Reuse target candidate buffers.
- Use explicit loops for hot-path filtering.
- Avoid allocating new Lists each frame.
- Cache stable references.
- Avoid repeated sort operations if only the nearest/best target is required.
- 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
-
Remove combat-targeting allocations and reduce CombatTargeting CPU cost.
-
Reduce / restructure per-enemy Update workload.
-
Eliminate reinforcement Instantiate spikes through validated pooling/prewarming.
-
Investigate physics visibility-query cost and reduce unnecessary query frequency.
-
Eliminate remaining recurring managed allocations and verify GC behavior.
-
Profile projectile creation and pool only if cost is confirmed.
-
Audit large texture-memory consumers.
-
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
GitHub
Google Drive
Dropbox
Notion
Linear
OpenAI
Permissions
Allowed Hosts
File Scopes
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.