> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ovalbee.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ovalbee.com/_mcp/server.

# Edges

An **edge** is an arrow on the canvas. It means *run the target after the source succeeds*, and nothing else. Data reaches a node through its inputs, which can [reference](/concepts/references) any other node's output. If you've used n8n or a similar tool, where each arrow passes a payload to the next step, this is the part to unlearn.

```mermaid
flowchart TB
  split["Train/val split"] --> train["Train detector"] --> predict["Predict"] --> eval["Evaluate"]
  split -. "val split" .-> predict
  split -. "val split as ground truth" .-> eval
```

In this flow the arrows fix the order: split, train, predict, evaluate. The dotted lines are references, which aren't drawn on the real canvas: `Predict` runs the new model on the validation split, and `Evaluate` compares its predictions with that same split as ground truth — neither is next to the node it reads the split from. Even the model `Predict` uses is a reference to the training node's output. The arrow between them only says *after*.

Draw an edge by dragging from a handle on one node to another node. When a node's run **succeeds**, OvalBee starts every node its outgoing flow edges point to, and each of those does the same when it succeeds. That chain is how work travels through a flow.

* **Branching.** A node with several outgoing edges starts all of them.
* **Joining.** A node with several incoming edges runs each time *any* of them finishes. When it should wait until all of its upstream branches are done, put a [Wait](/node-library/nodes/flow-control-wait) node in front of it.
* **Failures stop the chain.** A failed node doesn't start anything downstream. Some nodes also end the chain on purpose when there's nothing to do, for example when no new images arrived.
* **Loops are allowed.** Rework cycles and retraining loops are normal. A loop keeps going until a node in it fails, stops the chain, or has nothing new to process.
* **Isolated runs** ignore edges entirely. See [Runs and automation](/concepts/runs).

## Visual edges

A **visual edge** is drawn dashed and never starts anything. It exists for the reader: to show that rejected images go back to the pool, that two branches belong together, that a report is about a certain dataset.

Hold **Alt** while dragging to draw a visual edge, or right-click any edge and choose **Convert to visual edge** (and **Convert to flow edge** to turn it back).

> **Tip**
>
> The classic use is a rework loop. In a labeling flow, the path from *Rejected* back to the labeling pool is a visual edge: the drawing shows the loop, while a separate Move node returns the images when you run it or when its schedule comes due. The loop is visible, and it never spins by itself.

## Edge labels

Double-click an edge, or right-click it and choose **Edit edge label**, to write a short label such as *Accepted*, *Rejected* or *only if mAP improved*. Labels are for people reading the flow and don't change behavior.

Hover an edge to get a **+** button that inserts a new node in the middle of it.

## Related pages

* [References](/concepts/references) — how data actually gets from one node to another.
* [Runs and automation](/concepts/runs) — manual, scheduled and isolated runs, and what happens downstream.
* [Flow editor](/build/editor) — drawing, selecting and rearranging on the canvas.