Execution Graphs

Early agent systems relied on simple control loops:

Observe → Reason → Act → Observe → ...

These loops work well for basic tasks, but they struggle with real-world complexity — branching decisions, parallel tool calls, conditional logic, and the need to revisit earlier states.

Modern agent architectures solve this by modeling workflows as execution graphs — directed graphs where nodes represent steps and edges define transitions and control flow.

From Loops to Graphs

A simple loop is inherently linear and reactive.
An execution graph is explicit, structured, and flexible.

Simple linear graph:

Start → Collect Data → Analyze → Generate Report → End

Complex graph with branching and merging:

          Start
            ↓
      Collect Data
       /         \
      /           \
 Analyze A     Analyze B
      \           /
       \         /
        Combine Results
             ↓
          Report

Graphs naturally support:

• Conditional branching
• Parallel execution
• Cycles (revisiting states)
• Merging of multiple paths

What Is an Execution Graph?

An execution graph consists of:

• Nodes — Individual computation steps (reasoning, tool calls, analysis, reflection, etc.)
• Edges — Transitions between nodes, often with conditions
• State — Shared data passed between nodes (observations, intermediate results, memory)

Each node receives the current state, performs its work, and returns an updated state for the next node.

This design makes workflows visible, controllable, and easier to debug compared to reasoning hidden inside a loop.

Key Advantages of Execution Graphs

These properties make graphs especially valuable for complex, long-running, or high-stakes agent systems.

Nodes as Reusable Functions

In practice, nodes are often simple functions that operate on a shared state object.

def collect_market_data(state):
    results = web_search(state["query"])
    state["raw_data"] = results
    return state

def analyze_trends(state):
    analysis = llm.generate(f"Analyze trends in this data: {state['raw_data']}")
    state["analysis"] = analysis
    return state

def generate_report(state):
    report = llm.generate(f"Write a market report based on: {state['analysis']}")
    state["final_report"] = report
    return state

fn collect_market_data(state: &mut AgentState) {
    let results = web_search(&state.query);
    state.raw_data = results;
}

fn analyze_trends(state: &mut AgentState, llm: &LLMClient) {
    let prompt = format!("Analyze trends: {}", state.raw_data);
    state.analysis = llm.generate(&prompt);
}

The graph runtime orchestrates calling these nodes in the correct order, handling conditions and parallelism.

Graphs and State Machines

Execution graphs are closely related to state machines. Each node represents a state, and edges define valid transitions based on conditions or events.

This combination gives developers fine-grained control while still allowing the LLM to drive intelligent decisions inside individual nodes.

Execution Graphs in Modern Frameworks

Graph-based execution has become a standard pattern in production-grade agent systems. The Python and Rust ecosystems take slightly different approaches.

Python Ecosystem

Rust Ecosystem

Note: In the Rust ecosystem, the combination of graph-flow and Rig is currently one of the closest equivalents to LangGraph. It offers type-safe, high-performance graph execution with support for cycles, conditional routing, and human-in-the-loop patterns.

However, Rust-based tools are generally less mature and less battle-tested compared to their Python counterparts. The ecosystem has fewer high-level abstractions, smaller community support, and fewer production case studies. Developers often need to build more infrastructure themselves, which gives greater control and performance but requires more engineering effort.

This trade-off makes Rust a strong choice when performance, safety, or resource efficiency is critical, while Python frameworks remain more accessible for rapid development and complex orchestration.

Loops Inside Graphs

Interestingly, graphs can still contain cycles. For example:

Collect Data → Analyze →
    ↓ (if data insufficient)
Collect More Data → ...

This allows the best of both worlds: the structure and control of graphs combined with the flexibility of loops.

Looking Ahead

Execution graphs represent a major evolution in agent design — moving from implicit, probabilistic loops to explicit, engineerable workflows.

This shift brings agents closer to traditional software systems while preserving the intelligence of LLMs.

Next Steps

• Python track: Continue to 3.6 — Building Agents with LangGraph — a practical guide to implementing stateful, graph-based agent architectures using one of the most popular modern frameworks.

• Rust track: Continue to 3.6 — Building Agents with Rig and Custom Graphs — a practical guide to implementing high-performance, type-safe graph-based agents using Rig and Ollama.