the official unity muse and sentis documentation is incomplete so i wrote the guide i wish had existed when i started
Unity's official documentation for Muse and Sentis covers the what but skips most of the how and almost all of the what goes wrong. I spent three months working through both tools with the official docs open alongside and keeping notes every time the docs did not cover something I needed. This is the practical guide built on top of the official documentation, covering the gaps, the version specific details that are missing, and the workflow questions the docs do not answer.
Priya Nair
June 27, 2026
How this guide is structured: each section covers a specific topic that the official Unity documentation either omits entirely or explains at too high a level to be actionable. I link to the official doc page where one exists and then add what I learned from actually using the feature. This is not a replacement for reading the official docs. It is what to read after the official docs when things are not working the way the docs imply they should.
Muse Chat: What the Official Docs Do Not Tell You
- The docs say: Muse Chat answers questions about Unity development. What the docs skip: Muse Chat does not have context from your project. You must paste relevant code into the chat window for any project-specific question. Treating Muse Chat as a project-aware tool leads to generic answers. Treating it as a Unity documentation expert that you provide context to produces much more useful responses.
- The docs say: sign in with your Unity account to access Muse Chat. What the docs skip: you need to sign in inside the Unity Editor specifically, not just have a browser session open. Go to Edit > Sign In to Unity Account and confirm the displayed email matches the account with the Muse subscription.
- The docs do not cover: the prompt format that produces the most accurate Muse Chat responses. I use: Unity 6, [specific component], [specific behavior or API call], [my specific question]. The more specific the question the more version-accurate the answer. Vague questions produce generic answers that mix Unity versions.
- The docs do not cover: Muse Chat has a usage limit that resets monthly. I have not hit it in five months of daily use but developers doing very high volume question sessions have reported hitting it. The limit is not published in the documentation.
Muse Behavior: What the Official Docs Do Not Tell You
- The docs say: describe your desired NPC behavior in natural language. What the docs skip: the description format matters significantly. Describing states explicitly produces better trees than describing behaviors narratively. Use this format: State 1 name, condition to enter, actions in this state. State 2 name, condition to enter, actions in this state. The structured format produces cleaner trees than conversational descriptions.
- The docs say: generated action nodes can be customized. What the docs skip: every generated action node that references your specific game systems needs a custom implementation script. The node is generated as a shell. Connecting it to your DamageSystem or QuestManager requires writing the implementation manually. Budget 10 to 30 minutes per custom action node for the implementation script.
- The docs do not cover: the required components that need to be on the NPC GameObject before generating. NavMeshAgent for movement-related behaviors, a health component for health-based conditions, and a reference to the player transform for detection. Generating the tree without these present creates reference errors in the generated nodes.
- The docs do not cover: runtime debugging. The behavior tree visualizer shows which node is currently active. To access it during play mode, select the NPC in the Hierarchy and look for the Behavior Tree Debug panel. This is the most useful Muse Behavior feature the docs barely mention.
Sentis: What the Official Docs Do Not Tell You
# Sentis practical notes beyond the official documentation
# Three months of working notes condensed
## Finding your model's input and output layer names
The docs tell you to reference layers by name in your C# code.
The docs do not tell you how to find those names.
Method 1: Netron browser tool (recommended)
1. Go to netron.app in your browser
2. Open your .onnx file
3. Click the first node: that is your input layer name
4. Click the last node: that is your output layer name
5. Use exactly these names in your C# code, including underscores
Method 2: Python after training
In your Python training script after model export:
import onnx
model = onnx.load('your_model.onnx')
print('Inputs:', [n.name for n in model.graph.input])
print('Outputs:', [n.name for n in model.graph.output])
## The memory leak the docs warn about but do not explain well
The official docs say: dispose of tensors when done.
What this means in practice:
WRONG (causes memory leak):
var tensor = new TensorFloat(shape, data);
worker.SetInput("input", tensor);
worker.Schedule();
var output = worker.PeekOutput("output") as TensorFloat;
// tensor never disposed
CORRECT:
using var tensor = new TensorFloat(shape, data);
worker.SetInput("input", tensor);
worker.Schedule();
var output = worker.PeekOutput("output") as TensorFloat;
output.CompleteOperationsAndDownload();
// tensor disposed automatically at end of using block
// output should also be disposed if not kept for longer
## BackendType selection the docs gloss over
GPUCompute: fastest on desktop GPU, not supported on all mobile GPUs
GPUCommandBuffer: alternative GPU path, better iOS and Android support
CPU: slowest, works on all platforms
What the docs do not say:
Test your target platform's BackendType before designing your
AI system around a specific inference speed.
On a mid-range Android device GPUCommandBuffer inference for a
small classifier takes 8 to 15 milliseconds.
Designing a system that requires 2ms inference on a PC GPU
will not work on mid-range mobile.
## Converting .onnx to .sentis format
The docs mention this conversion exists.
The docs do not explain why you would do it.
Reason: .sentis format is Unity's proprietary format that loads
faster and integrates more cleanly with Unity's asset system.
For models you will ship with the game, convert to .sentis.
For models you are still iterating on, keep .onnx.
Conversion: select the .onnx file in the Project window,
Inspector will show a Convert button.Using Cursor Alongside the Official Documentation
One workflow that the official documentation obviously cannot cover is how Cursor integrates into the Muse and Sentis development process. When Muse Behavior generates action node shells, I take those shells into Cursor and ask it to implement the action logic using my existing game scripts. Cursor sees the generated node code and sees my existing scripts and connects them correctly. When Sentis inference produces output values, the game logic that responds to those values is written in Cursor which knows how those values connect to my enemy state machine and the rest of the game architecture. The official documentation describes each tool in isolation. The workflow where they work together is what you build from experience.
Questions the Official Docs Do Not Answer at All
- How many enemies can run Sentis inference simultaneously without frame rate impact: not in the docs. My testing: 6 enemies running inference every 0.1 seconds with a small classifier model adds approximately 3ms to the frame time on an RTX 3070 using GPU backend. On mid range mobile with CPU backend, the same 6 enemies add approximately 40ms. Test your hardware.
- Whether Muse Behavior trees persist between play sessions: they do, as Unity ScriptableObject assets in your project. Behavior trees are saved as asset files in your project. They load with the scene.
- What happens to Muse Chat conversations: they do not persist between Editor sessions. Each time you open the Unity Editor the Muse Chat panel starts with an empty conversation history. If you have useful context from a previous session you need to repaste it.
- Whether Sentis models increase build size: yes, significantly for larger models. My small classifiers (under 2MB) added minimal build size. A 15MB ONNX file added approximately 15MB to the build, as expected. Large models need to be weighed against their gameplay value.
Final Thoughts
Three months with the official Unity Muse and Sentis documentation produced this gap document. The official docs are accurate as far as they go. The workflow questions, the memory management specifics, the layer name lookup process, and the practical guidance on BackendType selection are where the docs fall short for a developer implementing these tools in a real game. This post is my attempt to fill those gaps from actual implementation experience.