# Flow Node Kinds

## Summary

Flow Node Kinds are the editor-facing families used to group nodes in search, catalog pages, and generated registries. Use this page when you know what kind of behavior you need, but you are not sure which node family to start from.

Node kind is not the same thing as runtime behavior. It helps you navigate the catalog. The exact ports, parameters, return semantics, and failure behavior live on each node page.

## Use When

* You are choosing the first node for a new graph.
* You are deciding whether a rule belongs in Flow, BT, FSM, Stack, or GOAP.
* You are searching the node catalog and want the right family name.
* You are reviewing a graph and need to understand why a node is grouped where it is.

## Choose by Job

| Job                                                            | Start with                                     | Why                                                                                           |
| -------------------------------------------------------------- | ---------------------------------------------- | --------------------------------------------------------------------------------------------- |
| Start a graph from Unity lifecycle, an Entry call, or an event | Core, System Triggers, Input, UI               | These nodes create chains from scene, user, save/load, input, or UI activity.                 |
| Run authored work in order                                     | Core, Control                                  | These nodes execute instructions, route branches, wait, retry, gate, or combine logic.        |
| Handle timing without writing scheduler code                   | Timer                                          | Timer nodes turn intervals, countdowns, windows, cooldowns, and stopwatches into visual flow. |
| Bind logic to UI objects                                       | UI Component Triggers, UI EventSystem Triggers | These nodes listen to Unity UI component values or EventSystem pointer/navigation events.     |
| Split long-lived modes from short actions                      | Graph/State, Stack, FSM-related nodes          | These nodes help compose subgraphs, states, and stacked gameplay modes.                       |
| Make priority decisions                                        | BT                                             | BT nodes choose, sequence, decorate, service, and interrupt behavior tree branches.           |
| Plan toward goals                                              | GOAP                                           | GOAP nodes describe goals, actions, costs, facts, and planner roots.                          |

## Categories

| Category                | Node kinds                                                                                                                                                                                                                                                                                                                                                                    | Choose this when                                                                                                 |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| Core                    | Enter, Exit, Trigger, Action, Comment                                                                                                                                                                                                                                                                                                                                         | You need the basic shape of a Flow graph: start, do work, finish, or document intent.                            |
| System Triggers         | OnCacheTrigger, OnCacheApplyTrigger, OnSaveTrigger, OnLoadTrigger, OnLoadFailedTrigger, OnBlackboardValueChangedTrigger                                                                                                                                                                                                                                                       | You want a graph to respond to persistence, cache, or Blackboard-change events.                                  |
| Control                 | IfElse, Loop, Switch, Flags, Combiner, Spinner, WeightedRandom, Gather, Once, Gate, Wait, Abort, Relay, RemoteIn, RemoteOut, TryCatchFinal                                                                                                                                                                                                                                    | You need routing, repetition, gating, waiting, remote routing, cancellation, or failure handling inside a chain. |
| Timer                   | TimerInterval, TimerStopwatch, TimerCountdown, TimerDelay, TimerCooldown, TimerTimeWindow                                                                                                                                                                                                                                                                                     | You need time-based flow without hand-writing timing code.                                                       |
| UI Component Triggers   | UiButtonTrigger, UiToggleTrigger, UiSliderTrigger, UiDropdownTrigger, UiInputFieldChangedTrigger, UiInputFieldSubmitTrigger, UiInputFieldSelectTrigger, UiInputFieldDeselectTrigger, UiScrollRectTrigger, UiScrollbarTrigger, UiTmpDropdownTrigger, UiTmpInputFieldChangedTrigger, UiTmpInputFieldSubmitTrigger, UiTmpInputFieldSelectTrigger, UiTmpInputFieldDeselectTrigger | You want a graph to react to a specific UI component value or submit/select event.                               |
| UI EventSystem Triggers | UiPointerEnterTrigger, UiPointerExitTrigger, UiPointerDownTrigger, UiPointerUpTrigger, UiPointerClickTrigger, UiPointerMoveTrigger, UiBeginDragTrigger, UiDragTrigger, UiEndDragTrigger, UiDropTrigger, UiScrollTrigger, UiMoveTrigger, UiSelectTrigger, UiDeselectTrigger, UiSubmitTrigger, UiCancelTrigger, UiUpdateSelectedTrigger, UiInitializePotentialDragTrigger       | You want pointer, drag, scroll, navigation, select, submit, or cancel events from the EventSystem.               |
| Input                   | InputOldTrigger, InputNewTrigger                                                                                                                                                                                                                                                                                                                                              | You want keyboard, mouse, gamepad, or Input System activity to start chains.                                     |
| Graph/State             | SubFlowGraph, FsmState                                                                                                                                                                                                                                                                                                                                                        | You want to reuse a graph section or place a graph-backed state inside a larger behavior.                        |
| BT                      | BtRoot, BtSequence, BtSelector, BtParallel, BtParallelPlus, BtParallelWeighted, BtCondition, BtAction, BtLoop, BtDecorator, BtService, BtSubGraph                                                                                                                                                                                                                             | You want priority, sequence, interruptible decision logic, services, decorators, or reusable BT subgraphs.       |
| Stack                   | StackRoot, StackLayer                                                                                                                                                                                                                                                                                                                                                         | You want push/pop mode layers such as modal UI, gameplay modes, input contexts, or tutorial overlays.            |
| GOAP                    | GoapRoot, GoapGoal, GoapAction                                                                                                                                                                                                                                                                                                                                                | You want goal-oriented planning driven by facts, costs, preconditions, and effects.                              |

## Reading a Node Kind

* Category names help you search; node pages define behavior.
* A node may belong to one authoring family but still interact with another module. For example, a BTAction can hand off to Flow, and a Stack Layer can run authored Flow branches.
* Trigger nodes usually start chains. Control nodes usually transform, delay, cancel, or route chains. Module nodes usually provide a larger runtime pattern.
* If you are choosing between Flow, FSM, and BT, start with the design responsibility before choosing the node.

## Common Selection Mistakes

| Symptom                                                 | Likely mismatch                                  | Better direction                                                |
| ------------------------------------------------------- | ------------------------------------------------ | --------------------------------------------------------------- |
| A BT graph is doing a long cinematic sequence.          | BT is owning orchestration instead of decisions. | Use Flow for the sequence, then let BT choose when to enter it. |
| A Flow graph has many mutually exclusive mode branches. | Flow is acting like a long-lived state owner.    | Use FSM or Stack for sustained mode ownership.                  |
| A UI graph polls every frame for button state.          | UI events are being treated as manual checks.    | Use UI Component or UI EventSystem Trigger nodes.               |
| A cooldown is implemented with ad hoc waits and flags.  | Timing is scattered across control nodes.        | Start with Timer or Cooldown nodes.                             |

## Related

* [Node Reference](/flow-core-docs/documentation/reference/nodes.md)
* [Invoke and Reject Modes](/flow-core-docs/documentation/reference/invoke-and-reject-modes.md)
* [Concepts Overview](/flow-core-docs/documentation/core-concepts/concepts-overview.md)
* [Flow, FSM, and BT Patterns](/flow-core-docs/documentation/gameplay-modules/flow-fsm-bt-patterns.md)
* [Stack Root and Stack Layer](/flow-core-docs/documentation/gameplay-modules/stack-root-and-layer.md)
* [GOAP Authoring](/flow-core-docs/documentation/gameplay-modules/goap-authoring.md)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://flow-core.gitbook.io/flow-core-docs/documentation/reference/flow-node-kinds.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
