# First 15 Minutes

Level: Beginner

## Goal

Create a no-code Flow Core Hello World that reads a string from a Local Blackboard and prints it to the Unity Console when Play Mode starts.

This tutorial is intentionally small. It teaches the core visual loop: author a graph, bind it to a scene object, provide data through a Blackboard, start from a Trigger, and observe the result.

## Prerequisites

* A scene with a GameObject you can modify.
* Flow Core menus are visible in Unity.
* The Unity Console window is available.

## What You Will Build

You will create a scene object with two components:

* `FlowCoreProcess`, which runs the Flow Graph asset at runtime.
* `Blackboard`, which stores the local `String` value the graph will read.

Then you will build a graph with:

* A `Trigger` node set to Unity `Start`.
* An `Action` node connected from `Trigger.Out`.
* A `Log String` instruction that reads Local Blackboard index `0`, key `Say`.

When you enter Play Mode, the Console prints:

```
Hello Flow Core
```

## Steps

1. Create a Flow Graph asset.

   Use `Assets/Create/Flow Core/Flow Graph` and name it `Hello_FlowCore`.

   The graph asset stores the nodes and connections. It does not run by itself until a scene object owns it through `FlowCoreProcess`.
2. Create the scene object.

   Create an empty GameObject and name it `Hello Flow Core`.

   This object will be the runtime owner for the graph and the Local Blackboard. Keeping both on one GameObject makes the first data path easy to inspect.
3. Add the runtime process.

   Select the `Hello Flow Core` GameObject, add a `FlowCoreProcess` component, and assign the `Hello_FlowCore` graph asset to it.

   The process is the bridge between the asset and the scene. If the graph is not assigned here, nothing in the scene will run it.
4. Add a Local Blackboard.

   Add a `Blackboard` component to the same GameObject. In the Blackboard Inspector, add a `String` value, set `Key` to `Say`, and set `Value` to `Hello Flow Core`.

   This value is intentionally data-driven. The graph will read the text from the Blackboard instead of hard-coding it inside the node.
5. Bind the Blackboard to the process.

   In the `FlowCoreProcess` component, find `Local Blackboards` and add the `Blackboard` component from the same GameObject.

   Local Blackboard index `0` now points to this Blackboard. Later, the `Log String` instruction will use scope `Local`, index `0`, key `Say`.
6. Open the Flow Graph editor.

   Use `Tools/Flow Core/Flow Graph Editor`, open the `Hello_FlowCore` graph, and set Debug Context to the `Hello Flow Core` GameObject.

   Debug Context does not change the graph asset. It tells the editor which scene object to use when previewing Blackboard-backed values and summaries.
7. Add the start Trigger.

   Right-click the canvas and add a `Trigger` node. Set `Trigger Bus Type` to `Unity` and set `Unity Event` to `Start`.

   This means Unity lifecycle will start the graph when the scene object reaches `Start` in Play Mode.
8. Add the Action node.

   Add an `Action` node and connect `Trigger.Out` to `Action.In`.

   The Trigger starts the chain. The Action performs visible work after the chain enters it.
9. Add the log instruction.

   Select the `Action` node and add `Log String` from `Debug/Value/String`.

   Configure the instruction value:

   * Source: `Blackboard`
   * Scope: `Local`
   * Blackboard index: `0`
   * Key: `Say`

   The instruction now reads the same Blackboard value you created on the scene object.

## Verify the Result

1. Open the Unity Console.
2. Enter Play Mode.
3. Confirm the Console prints `Hello Flow Core`.

This result proves four things at once:

* The graph asset is assigned to a live `FlowCoreProcess`.
* The Unity `Start` Trigger fired.
* The Action node executed its instruction list.
* The instruction resolved a `String` value from the Local Blackboard.

Change the Blackboard value from `Hello Flow Core` to another short string, enter Play Mode again, and confirm the Console output changes without changing the graph structure.

## Common Mistakes

| Symptom                                             | Check                                                                                                                   |
| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Nothing prints in the Console.                      | Confirm the graph asset is assigned on `FlowCoreProcess`, the component is enabled, and the Trigger uses Unity `Start`. |
| The Action node does not run.                       | Confirm `Trigger.Out` is connected to `Action.In`.                                                                      |
| The value is empty, null, or not the expected text. | Confirm the Blackboard is listed in `Local Blackboards`, index `0`, and the key is exactly `Say`.                       |
| The key exists but does not resolve as text.        | Confirm the Blackboard value type is `String`, not another value type.                                                  |
| Editor summaries look wrong.                        | Set Debug Context to the same GameObject that has `FlowCoreProcess` and the Blackboard.                                 |
| You do not see the log line.                        | Check Console filters, collapse mode, and whether Play Mode actually restarted.                                         |

## Next Steps

* [Run a Flow Graph in a Scene](/flow-core-docs/documentation/tutorials/run-a-flow-graph-in-a-scene.md)
* [Blackboard UI](/flow-core-docs/documentation/editor-guide/blackboard-ui.md)
* [Graph Editor](/flow-core-docs/documentation/editor-guide/graph-editor.md)
* [Debug Context](/flow-core-docs/documentation/editor-guide/debug-context.md)
* [Beginner Glossary](/flow-core-docs/documentation/reference/glossary.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/tutorials/first-15-minutes.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.