# Concepts Overview

Level: Intermediate

## Summary

This page connects the main Flow Core concepts into one mental map. Use it after the first Hello World graph, when the individual terms are familiar but the runtime shape still needs to become clear.

The shortest version is: a `FlowCoreProcess` runs a graph, a Trigger or Entry starts a chain, nodes route that chain through branches, Guards can reject work, and Blackboard or payload data gives nodes the values they need.

## Why It Exists

Flow Core uses several families of nodes and runtime concepts. Flow graphs, Behavior Trees, FSM States, Stack layers, GOAP, Flow Character, and Flow Interaction all share the same need for explicit execution and data ownership.

This overview gives those terms a shared map so readers can move between beginner tutorials, gameplay modules, runtime guides, and reference pages without relearning the language each time.

## Mental Model

Flow Core has three repeating questions:

| Question                  | Concept to check                       | Example                                        |
| ------------------------- | -------------------------------------- | ---------------------------------------------- |
| How does execution start? | Trigger or Entry                       | Unity `Start` Trigger or Entry `SayHello`.     |
| Where does execution go?  | Chain, Branch, Node, Port              | Trigger output connects to Action input.       |
| What data does it use?    | Blackboard, payload, Target, FlowValue | `Log String` reads Local Blackboard key `Say`. |

Once those are clear, the higher-level modules become special ways of organizing the same ideas. A Behavior Tree still starts from a graph path and uses data. A Flow Character Marker still routes a timed event into graph logic. A Flow Interaction Target still turns focus or interact events into chains.

## Behavior Contract

| Term            | Contract                                                                                     |
| --------------- | -------------------------------------------------------------------------------------------- |
| Flow Graph      | Stores nodes, ports, settings, and connections. It is the authored behavior structure.       |
| FlowCoreProcess | Binds a graph to a scene object, builds runtime data, and owns Local Blackboard references.  |
| Entry           | Named graph start point, useful for code or graph-driven calls.                              |
| Trigger         | Event-driven start point, useful for Unity lifecycle, input, UI, signals, and module events. |
| Chain           | A running execution path started by an Entry or Trigger.                                     |
| Branch          | A connection route from a node output to another node.                                       |
| Guard           | A condition group checked before a node executes.                                            |
| Invoke Mode     | Busy-node policy when another chain reaches a node that is still running.                    |
| Reject Result   | The result returned when a Guard or rejectable node blocks execution.                        |
| Blackboard      | Typed key-value storage in Local, Scene, or Global scope.                                    |
| payload         | Event-provided data carried by one Trigger or Entry execution.                               |
| Debug Context   | Editor-selected process context used for previews and visual debugging.                      |

## Design Implications

Start with the smallest graph that produces a visible result. A visual result anchors the concepts. The Hello World graph proves that the process, graph asset, Local Blackboard, Trigger, Action, and instruction binding all work together.

Use names that preserve intent. Entry titles should describe the external action, such as `SayHello` or `StartEncounter`. Blackboard keys should describe the data contract, such as `Say`, `HasTarget`, or `InteractionPrompt`.

Keep module-specific concepts connected to the shared model:

* Behavior Tree child order is still graph structure.
* FSM State Enter/Update/Exit still runs instructions or graph paths.
* Stack Root and Stack Layer still route lifecycle branches.
* GOAP facts are Blackboard-backed world state.
* Flow Character Markers start chains from animation timing.
* Flow Interaction Owner and Target events start chains from interaction state.

## Common Misunderstandings

* A Branch is graph structure; a Chain is runtime execution.
* A Trigger starts from an event; an Entry is a named start point.
* A Guard decides whether a node may run; it is not general data validation.
* A payload is temporary event data; Blackboard data is scoped state.
* Debug Context helps the editor inspect a runtime owner; it is not a runtime binding.
* Subgraphs are not hidden global graphs. Their Triggers depend on activation context.

## Related

* [What Is Flow Core](/flow-core-docs/documentation/core-concepts/what-is-flow-core.md)
* [Design Levers](/flow-core-docs/documentation/core-concepts/design-levers.md)
* [Terminology](/flow-core-docs/documentation/reference/terminology.md)
* [Invoke and Reject Modes](/flow-core-docs/documentation/reference/invoke-and-reject-modes.md)
* [Stack Root and Stack Layer](/flow-core-docs/documentation/gameplay-modules/stack-root-and-layer.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/core-concepts/concepts-overview.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.