# Glossary

Level: Beginner

## Goal

Provide short definitions for the terms used in beginner tutorials and first authoring pages.

If a term here seems too short for a design or debugging decision, use [Terminology](/flow-core-docs/documentation/reference/terminology.md) as the source of truth.

## How to use

* Read this when a beginner page uses a Flow Core term you do not recognize.
* Return to the task page after checking the term.
* Use the deeper reference pages when you need exact runtime behavior.

## Terms

| Term                    | Meaning                                                                                              | Why it matters                                                                               |
| ----------------------- | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Flow Graph              | The asset that stores nodes, ports, and connections.                                                 | It is the behavior you author visually.                                                      |
| FlowCoreProcess         | The scene component that runs a Flow Graph.                                                          | A graph needs a process before it can run in a scene.                                        |
| Node                    | A unit of behavior in a graph.                                                                       | Nodes define what a chain does.                                                              |
| Action                  | A node that runs an ordered list of Instructions.                                                    | It is the common place to perform work such as logging, setting values, or calling behavior. |
| Instruction             | A configured operation inside an Action.                                                             | Instructions do work inside an Action node.                                                  |
| Condition               | A pass/fail check used by Guards, If Groups, Waits, or BTCondition nodes.                            | Conditions decide whether behavior should continue.                                          |
| Input Port              | A port that receives flow into a node.                                                               | It defines where a chain can enter.                                                          |
| Output Port             | A port that emits flow to another node.                                                              | It defines how a chain continues.                                                            |
| Entry                   | A named start point, usually an Enter node.                                                          | Code or another graph can call it by name.                                                   |
| Trigger                 | An event-based start point.                                                                          | It starts chains from Unity events, input, UI, or other events.                              |
| Chain                   | A running execution path started by an Entry or Trigger.                                             | It is the runtime behavior you observe.                                                      |
| Branch                  | An output route in the graph.                                                                        | It describes topology, not runtime state.                                                    |
| Guard                   | A condition group checked before a node runs.                                                        | It can stop a chain before the node executes.                                                |
| Reject Result           | What happens when a Guard rejects.                                                                   | It controls Abort vs Invalid behavior.                                                       |
| Invoke Mode             | What happens when a node is already busy.                                                            | It controls whether repeated execution queues, skips, aborts, or returns invalid.            |
| Blackboard              | Typed key-value storage for graph data.                                                              | Nodes and Instructions read/write through it.                                                |
| Blackboard Key          | A typed identifier in a Blackboard.                                                                  | Key spelling and type must match.                                                            |
| Scope                   | Where a Blackboard lives, such as Local, Scene, or Global.                                           | Scope affects sharing, ownership, and debugging.                                             |
| FlowValue               | A configured value source such as Literal, Blackboard, payload, TempPayload, or Target.              | It explains where a field value comes from.                                                  |
| payload                 | Data carried by the event that started the chain.                                                    | It provides event-specific values.                                                           |
| TempPayload             | Temporary data written and read during the same chain.                                               | It is useful for short handoff, but disappears when the chain ends.                          |
| Signal                  | A named runtime event that can wake or gate graph behavior.                                          | Wait and signal-based Conditions depend on matching signals.                                 |
| Debug Context           | A selected scene GameObject for editor preview and live debugging.                                   | Summaries resolve values using it.                                                           |
| Subgraph                | A graph executed from another graph.                                                                 | Its triggers only work during the active subgraph window.                                    |
| Stack Root              | The node that owns a stack of layers.                                                                | It controls top-only Update for layered UI or modes.                                         |
| Stack Layer             | A pushable layer with Push, Resume, Update, Pause, and Pop outputs.                                  | It defines what each stack layer does.                                                       |
| FSM                     | A state-machine pattern for long-lived modes.                                                        | It is good for explicit state transitions.                                                   |
| Behavior Tree (BT)      | A priority-driven branch rooted at BTRoot.                                                           | It structures repeated AI-style decisions.                                                   |
| BTRoot                  | The entry node for a BT branch.                                                                      | It owns BT ticking and returns Success/Failure to Flow.                                      |
| GOAP                    | Goal Oriented Action Planning.                                                                       | It chooses actions from goals, facts, and costs.                                             |
| Flow Character          | Character component that connects movement, State/Gesture animation, Marker events, and graph logic. | It lets gameplay graphs work with character behavior.                                        |
| State                   | Sustained Flow Character animation behavior.                                                         | It is good for locomotion, stance, and long-running identity.                                |
| Gesture                 | Short Flow Character action, optionally with Entry and exit segments.                                | It is good for attack, pickup, reload, emote, and interact actions.                          |
| Marker                  | Normalized-time animation event route on a State or Gesture.                                         | It lets graph logic respond to animation timing.                                             |
| Speed Curve             | Curve on a Clip Track that changes animation playback speed over normalized time.                    | It helps tune wind-up, impact, release, and recovery timing.                                 |
| Clip Motor Overrides    | Clip Track movement/control overrides while that track contributes animation.                        | It lets a clip change movement rules for only part of an action.                             |
| Flow Interaction Owner  | Actor-side component that selects and interacts with Flow Interaction Target.                        | Used by a player or NPC that can interact.                                                   |
| Flow Interaction Target | Object-side component that can be focused and interacted with.                                       | Used by doors, pickups, NPCs, devices, and other interactive objects.                        |

## Related

* [Terminology](/flow-core-docs/documentation/reference/terminology.md)
* [Start Here](/flow-core-docs/documentation/getting-started/start-here.md)
* [First 15 Minutes](/flow-core-docs/documentation/tutorials/first-15-minutes.md)
* [TempPayload](/flow-core-docs/documentation/runtime-guide/temp-payload.md)
* [Stack Runtime Model](/flow-core-docs/documentation/runtime-guide/stack-runtime.md)
* [Flow Character](/flow-core-docs/documentation/gameplay-modules/flow-character.md)
* [Flow Interaction](/flow-core-docs/documentation/gameplay-modules/flow-interaction.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/glossary.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.
