unity-agent-team

Lazy skill loading router for the Unity DOTS agent team. Use this to determine which Unity-Skills modules to load before spawning agents. Never load all modules — select only what the task requires.

Adaptive pipeline triage skill. Classify task complexity, blast radius, and domain in ≤8 file reads, then emit schema-valid workspace/triage.json that drives all downstream phase composition and agent selection.

Lightweight verification agent for small and medium complexity tasks. Mechanically runs the deterministic verification bundle from impl_result.json and emits verification_result.json. Does not design tests or edit code — replaces always-on tester for tiny/small/medium pipelines.

Structured protocol for using agentmemory as a recall layer during codebase investigation. Load when any agent would otherwise start with broad Read/Grep/Glob exploration. agentmemory accelerates orientation — it is NOT a substitute for reading current source files.

First skill using a duplicate name for testing duplicate detection.

Second skill using the same duplicate name for testing duplicate detection.

Skill fixture with platform metadata incompatible with Linux/WSL environments where the team runs.

Skill that references paths that do not exist on disk for testing path validation.

This frontmatter is intentionally broken

Skill fixture containing secret-like content for security testing. Should be flagged.

""

Skill fixture containing unsafe shell commands for security testing. Should be flagged by the validator.

A complete, well-formed test fixture skill for SkillHub validation testing. Covers basic task routing and code review for Unity projects.

Architect role brief for the Unity DOTS Agent Team. Designs ECS systems before any coding — component models, system boundaries, update order, baker strategy, performance constraints, acceptance criteria. Loaded by the `architect` agent.

Burst-safe code rules for DOTS jobs and ISystem — managed type exclusions, Mathematics-only math, shared static limitations, and Burst compilation attribute requirements. Prevents Burst compilation errors and unsafe managed access in hot-path DOTS code.

CRG-first codebase navigation skill for all agents. Load when architecture must be traced, execution flow understood, impact radius determined, or entry points located before any implementation. Always queries code-review-graph before opening files — prevents blind file reads.

Data Tool Engineer role brief for the Unity DOTS Agent Team. Builds editor tooling, data processors, validators, inspectors, and DOTS debugging utilities. Loaded by the data-tool agent only — never loads for runtime implementation agents.

ECS job scheduling patterns — IJobEntity, IJobChunk, dependency chains, ECB usage, ScheduleParallel safety. Loaded for unity-dots-dev when implementing or debugging DOTS jobs. Replaces the job-optimizer subagent anti-pattern.

Guidance for Unity data processing, editor tooling, validators, and DOTS debugging helpers. Use when building authoring workflows, diagnostics, inspectors, or developer utilities. Always isolates editor code from runtime assemblies.

Investigation skill layer for system-mapper, code-tracer, and bug-investigation agents. Covers REST-based scene reading, log analysis, compilation diagnostics, and performance snapshots. All skills are read-only Phase 1 operations unless explicitly noted otherwise.

Native container lifetime, allocator selection, and GC-avoidance rules for DOTS runtime code. Covers NativeArray/NativeList/NativeHashMap disposal patterns, Allocator.Temp vs TempJob vs Persistent guidance, and managed-allocation detection. Replaces the memory-checker subagent.

Hard write-partitioning rules for parallel agents when pipeline.parallel_allowed=true. Defines glob-based file ownership, conflict detection, and orchestrate.py ownership-check integration. Prevents concurrent agents from writing the same files.

Validation rules for Unity DOTS features — correctness, scale, determinism, regression coverage, and release-readiness checklists. Use when creating test matrices, stress scenarios, reproduction steps, or performance regression anchors.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Tester / QA role brief for the Unity DOTS Agent Team. Validates correctness, scale, determinism, regressions, and performance with evidence-backed sign-off. Loaded by the tester agent only — not for implementation or design roles.

Non-DOTS "Unity classic" skill covering MonoBehaviour, UI Toolkit, UGUI, VContainer, Addressables, pooling, DOTween, async/UniTask, and per-frame performance. Loaded exclusively by the unity-dev (non-DOTS) lane. Does NOT cover ECS/DOTS — use unity-dots-best-practices for entities and systems.

Unity Developer role brief for the Unity DOTS Agent Team. Implements ECS components, systems, jobs, bakers, and runtime logic strictly from the Architect's approved design. Loaded by the unity-dev and unity-dots-dev agents — never for architect, tester, or verifier roles.

Unity DOTS, ECS, Jobs, and Burst guidance for scalable runtime systems. Core best-practices covering components, systems, bakers, blob assets, scheduling, structural change costs, and performance-sensitive simulation patterns for Entities 1.3+.

Senior-level Unity DOTS baking patterns — TransformUsageFlags, Baker dependency tracking, prefab references, and additional entity creation. Use when writing or reviewing `Baker<T>`, authoring MonoBehaviours, baking systems, or any code that translates GameObject scene state into entity components.

Senior-level EntityCommandBuffer orchestration — which ECB system to record into, when playback happens, ParallelWriter rules, deterministic sort keys, and the difference between recording phase and playback phase. Use whenever code defers structural changes from jobs (AddComponent / RemoveComponent / Instantiate / DestroyEntity / SetComponentEnabled inside an `IJobEntity` / `IJobChunk`).

When to use IEnableableComponent vs structural add/remove for entity state flips. Covers the cost-model decision, query semantics (.WithAll vs .WithEnabled, IgnoreComponentEnabledState), and SetComponentEnabled inside jobs. Use when designing state that flips frequently (cooldowns, dirty flags, dead/alive, paused/active, "needs processing" tags).

Senior-level entity lifecycle — safe destruction, structural-change-during-iteration rules, ICleanupComponentData two-phase teardown, dangling Entity refs, and subscene load/unload. Use when destroying entities, designing cleanup that needs to run after destruction, or debugging "entity already destroyed" / orphan-reference bugs.

Senior-level entity spawning — batched Instantiate from prefab Entity, ECB.Instantiate from jobs, deterministic Random with CreateFromIndex, RequireForUpdate gating, and Allocator.Temp lifecycle. Use when implementing spawners, enemy waves, projectile fire, particle-like ECS entities, or any "create N entities per frame" code.

Senior-level rule for choosing between `ISystem` (unmanaged + Burst) and `SystemBase` (managed) in Entities 1.x. ISystem is the default; SystemBase is a deliberate exception. Covers Burst boundaries, the `[BurstDiscard]` silent-fallback trap, managed-field anti-patterns, and the bridge-system pattern for unavoidable managed work. Use when authoring or reviewing any runtime system, deciding whether to keep an existing `SystemBase`, or debugging "I thought this was Bursted but it's allocating GC".

Senior-level guide to selecting `TransformUsageFlags` at every `GetEntity()` call in a `Baker<T>`. Covers the four values (None / Renderable / Dynamic / ManualOverride), the silent-failure modes when the choice is wrong, archetype-bloat consequences at scale, and the `[WriteGroup(typeof(LocalToWorld))]` contract that must accompany `ManualOverride` to avoid last-writer-wins corruption with the default `TransformSystemGroup`. Use whenever you write a Baker, audit archetype memory, design a custom transform system, or debug "my entity won't move" / "my static entity is wasting transform components".

Senior-level convention that every `ISystem` / `SystemBase` gates `OnUpdate` with `state.RequireForUpdate<T>()` (or the query overload) so the system only runs when its prerequisites — config singletons, feature toggles, baked content — actually exist. Covers the AND semantics of multiple gates, the empty-tag feature-flag pattern (generalizing the sample `ExecuteXxx` tags), the `state.RequireForUpdate(query)` overload for complex prerequisites, and why this strictly beats `if (!HasSingleton<T>()) return;`. Use when authoring any system, designing a feature toggle, or debugging first-frame "Singleton not found" / `NullReferenceException` crashes.

Senior-level guide to `SystemAPI.Query<RefRW<T>, RefRO<U>, ...>()` as the default main-thread per-entity iteration inside `ISystem.OnUpdate`. Covers the RefRO/RefRW intent discipline, when to refine with `.WithAll` / `.WithNone` / `.WithEntityAccess`, the structural-change-in-iteration trap, when to promote to `IJobEntity`, and the silent-no-op of writing through a `RefRO`. Use when iterating entities on the main thread, deciding between SystemAPI.Query and IJobEntity, or debugging "my system runs but nothing changes".

Senior-level pattern for expressing world-unique data (game config, controls, frame input snapshot, prefab tables) as singleton entities with O(1) `SystemAPI.GetSingleton<T>()` / `GetSingletonRW<T>()` access, gated by `state.RequireForUpdate<T>()`. Covers the >1-instance throw, write-from-parallel safety, scene-merge collision modes, and when "this looks like a static" is actually still a singleton. Use whenever designing config, registries, input state, prefab references, or any data that should exist exactly once per world.

Index of 96 senior-level Unity DOTS/ECS skills mined from EntityComponentSystemSamples — covering entities, jobs, Burst, physics, netcode, baking, and transforms. Read ROUTING.md first to locate the right sub-skill. Do NOT load this index file as a standalone skill.

Lightweight Unity Foundation skill always loaded for architect, unity-dev, and data-tool agents. Covers asmdef design, scene lifecycle contracts, project structure, asset hygiene, and Unity-specific code quality. Does NOT replace core ECS skills — ECS guidance always takes precedence when both apply.