Glossary
The words the editor uses, defined once, with the name another asset gives the same idea where that helps you search.
On this page
These are the words on the canvas and in these guides. Where another behavior tree asset calls the same thing something else, that name is in parentheses so a search you already know still lands.
Action
A leaf node that asks your game to do something and reports a result (a task, elsewhere). A state also holds lifecycle action rows.
Active node
The deepest node reached in the most recently observed tick. Ancestors can be Running without carrying the active marker.
Agent
One running graph owner (an owner, elsewhere). On the GameObject host that is a Behavior Agent component; on the entity host a BehaviorEntityRuntime attaches instances to matching entities.
Any State
A transition rule that applies from every state in a machine, evaluated before a state’s own outgoing list.
Authored identity
The stable id stored with a node or a reference. Renaming a label leaves it untouched, which is what makes renaming safe.
Authority
A baked gate on a node or a blackboard write. It decides who may run or write, and it carries no networking of its own.
Bake
Turning a valid graph file into the executable data the runtime ticks. It runs on the explicit Save and on import, and it is blocked while validation reports a structural or parameter violation. Informational notes do not block it.
Behavior version
The %% behavior-version: header you control in a graph file. A subgraph and its parent have to agree on it.
Binding
A saved contract from a graph node to an exact member of your code, with its target, arguments, result, and direction (a reflection task, elsewhere, though nothing here is discovered by reflection at runtime).
Blackboard
A graph’s own named memory (variables, elsewhere). It holds declared variables and the values bindings surface into it.
Blocked
A result meaning a read-only guard is false right now. Control flow treats it as a missed choice while the rail keeps the precise word.
Breakpoint
An editor preference on a graph and a node that pauses one ordinarily scheduled GameObject follower when that node is entered.
Composite
A node that owns ordered children: Selector, Random Selector, Sequence, Parallel.
Conditional
The decorator that admits its child only while a condition holds, and can interrupt the child when the condition turns false.
Conflict
The save state raised when the graph file changed on disk after your editor session loaded it. Resolve it with Open diff, Reload, or Keep local.
Continuous
The transition evaluation choice that re-reads its condition every tick (reactive evaluation, elsewhere). The alternative is On finish.
Cursor
Where a running composite got to in its children. A tree resumes at its cursor on the next tick instead of restarting, and an interruption resets the cursors inside the branch it took away.
Decorator
A single-child wrapper that changes admission or result: Conditional, Inverter, Repeat, Time Limit.
Direct failure
A Random Selector’s optional weighted outcome that is not a child. When it wins, the selector reports Failure without running anything.
Entity host
The runtime path that uses BehaviorEntityRuntime, entity queries, unmanaged storage, and generated entity member scheduling.
Executable content fingerprint
A deterministic identity for a complete baked graph. Live uses it so it cannot draw one graph beside a different running artifact.
Fault
A break in configuration or execution: a bound member throws, a coroutine throws, a held target is destroyed. It is terminal for that agent and never an authored Failure.
Follower
One running graph instance, identified by a follower id. Pause, Step, tracing, and breakpoints on the GameObject host act on this identity.
GameObject host
The runtime path that uses a Behavior Agent, MonoBehaviours, managed composition, and a generated member provider.
Graph file
The .bqbehavior text that records your nodes, settings, references, and layout. It is the thing you edit and ship. Imported caches are derived from it.
Graph file format
The %% source-format: bitquirky.behavior/1.x marker naming which records one graph file uses. Separate from the package version and the behavior version.
Imported cache
The executable data Unity derives from a graph file. It is rebuildable, and it is never patched by hand.
Interruption
Cancellation of running work by the graph’s own rules: a reactive abort, a timeout, a state exit, a reset. Distinct from Failure.
Inverter
The decorator that turns a child’s Success into Failure and Failure into Success.
Label
The display text on a node. Yours to change; the node’s identity does not move with it.
Live
The editor mode that observes one exact running instance (visual debugging, elsewhere). Eligible GameObject member values accept instance-only edits here; entity values are read-only. Static is the authoring mode.
Lower Priority
The abort scope where a higher-priority branch takes the running branch away from a lower-priority one (a conditional abort, elsewhere). Self is the scope where a node interrupts its own running child.
Member node
A node bound straight to a method, property, field, message, condition, or event in your code, with no wrapper class to write.
Member provider
The generated C# a graph’s bindings call through, composed on the host: a component on a Behavior Agent, or a generated pair supplied at entity registration. It carries a fingerprint of the graph it came from, so a stale one is reported instead of guessed around.
Package version
The installed io.bitquirky.behavior release. A graph carries its own behavior version and file format marker, which are separate. See upgrading.
Parallel
The composite that groups children which all have to succeed. In this release it visits them in Children order, as what it does not do yet explains.
Pending external
A request a graph has emitted that is waiting for your game to finish it.
Projected binding
A graph-level binding that surfaces a named value into the blackboard for any node to read.
Push and Return
The state machine control that enters a state, remembers where it came from, and returns there afterwards.
Random Selector
The composite that picks one child by weight (a probability selector, elsewhere), with optional Direct failure.
Reference Scan
The project-wide reader that resolves saved node, member, variable, and service identities in the graphs your project owns, open or closed.
Remapping
The Reference Scan follow-up that replaces one exact stale identity with one current identity everywhere it occurs, after a preview you approve.
Repeat
The decorator that runs its child again (a repeater, elsewhere), on Count, Until Success, Until Failure, or Forever.
Runtime generation
A counter on a GameObject agent’s runtime. Reset, reinitialization, and graph replacement advance it, so Live cannot confuse an old instance with a new one.
Runtime path
The host a graph is authored for, GameObject or entity, recorded in the graph file and checked before it runs.
Selector
The composite that tries children in order until one succeeds.
Sequence
The composite that runs children in order until one fails.
Service
A named boundary a graph uses to ask your game for longer-lived work. Your code supplies the handler.
Static
The editor mode that authors a graph and owns its undo, autosave, validation, and layout.
Subgraph
A graph referenced and composed inside another graph (a sub-tree, elsewhere). Composition checks the behavior version and the host.
Tick
One evaluation step of a running graph. A GameObject Step grants one follower tick; an entity Step advances one Unity frame, which may contain whatever entity work your game scheduled.
Time Limit
The decorator that gives its child a bounded number of seconds (a timeout, elsewhere).
Trace
The compact runtime reading of active node, result, transition, pending work, and authority that the editor draws on the canvas and in the rail.
Unmanaged data
A value shape storable without managed references. Entity blackboard storage requires it.
Watched value
A blackboard value surfaced in the Live rail for observation. Watching changes no ownership and grants no write.