Agent Graph overview

By the end of this page you will know what an Agent Graph is, when to choose one, and the single idea the whole pattern rests on.

What it does

You draw the flow on a canvas. Each agent you place is a step. You connect them to say what runs after what. A connection can carry a condition, so a branch only runs when it should, and a connection can send the flow back, so work gets another pass.


                    Market Researcher
                            │
                            ▼
                       Risk Scorer
                  ┌─────────┴─────────┐
        risk is high                  risk is not high
                  ▼                   ▼
          Legal Reviewer        Content Writer ◄──────┐
                  │                   │               │
                  │                   ▼               │
                  │           Editorial Reviewer ──────┘
                  │                   │        needs rework?
                  │                   │ approved
                  └─────────┬─────────┘
                            ▼
                      Report Builder

That is a market-analysis flow. Research the market, score the risk of what was found, and then either send it for legal review or write it up — revising until an editor approves. Either way the result reaches the report.

Two conditions, one loop, and one step that two different paths lead back into.

Nothing is decided at run time except which conditions pass. The shape is yours.

Agents with no connection run together

This surprises people, so it is worth stating plainly: two agents you have not connected run at the same time. Connections express dependency, not merely order. If you want one agent to wait for another, connect them.

The one idea to hold on to: `stm`

Each agent writes its result into a shared scratchpad under an output key. Later agents read from it, and conditions test it.

You will see this written as stm.some_key — stm is that shared scratchpad, and some_key is whichever agent’s output you mean.


Editorial Reviewer writes  →  stm.editorial_reviewer_output
                                      │
                                      ▼
condition on the loop-back connection:
        '##VERDICT_REWORK##' in stm.editorial_reviewer_output

Everything else in this pattern — conditions, what a step reads, loops — is built on that one mechanism. Agents on the canvas covers where output keys come from.

When to reach for it

Choose an Agent Graph when you already know the sequence and want it to run the same way every time. Review-then-publish, extract-then-validate-then-file, draft-and-check-until-clean: these have a shape, and drawing it is cheaper and more predictable than asking a planner to rediscover it on every turn.

Choose something else when:

One specialist can answer each message on its own. Use the Conversation Router.
You cannot know which agents a goal will need. Use Planner / Executor. A graph cannot adapt its shape to the request.

💡

If you find yourself drawing every possible path and putting a condition on each one, the work probably wants a planner instead.

What a graph is made of

Piece	What it is
Agents	The steps. Each one is a member AI Agent, placed on the canvas.
Connections	What runs after what. Optionally conditional.
Loops	A connection that sends the flow back to an earlier agent, with a required repeat limit.
Graph settings	What agents share, small talk, which model answers conditions, the final answer, and safety limits.

Availability

Starter Starter plan or above, the same as every MAS pattern.

What’s in this section

Canvas tour — place agents and connect them.
Agents on the canvas — output keys, failure handling, and what each step reads.
Connections & conditions — decide when a step runs.
Loops — send work back for another pass.
Graph settings — settings for the whole graph.