State graphs and transitions in Agentic AI

Introduction

State graphs help us understand how a system moves from one situation to another. They show all possible steps and choices clearly.

To model how a robot decides what to do next based on its current position.

To represent different stages in a game and how players move between them.

To track the steps in a customer support chatbot conversation.

To plan actions for an AI agent in a smart home system.

To visualize how a machine learning model changes states during training.

Syntax

Agentic AI

class State:
    def __init__(self, name):
        self.name = name
        self.transitions = {}  # Maps action to next State

    def add_transition(self, action, next_state):
        self.transitions[action] = next_state

    def next_state(self, action):
        return self.transitions.get(action, None)

# Example usage:
# state1 = State('Start')
# state2 = State('Middle')
# state1.add_transition('go', state2)
# next = state1.next_state('go')
# print(next.name)  # Output: Middle

Each state has a name and a list of possible transitions.

Transitions connect one state to another based on an action or event.

Examples

This shows a state with no transitions yet.

Agentic AI

empty_state = State('Empty')
print(empty_state.transitions)  # Output: {}

A state with one transition named 'move'.

Agentic AI

single_transition_state = State('Single')
single_transition_state.add_transition('move', State('Next'))
print(list(single_transition_state.transitions.keys()))  # Output: ['move']

States connected in a chain with transitions.

Agentic AI

start = State('Start')
middle = State('Middle')
end = State('End')
start.add_transition('go', middle)
middle.add_transition('finish', end)
print(start.next_state('go').name)  # Output: Middle
print(middle.next_state('finish').name)  # Output: End

A state that transitions back to itself, showing a loop.

Agentic AI

state = State('Loop')
state.add_transition('repeat', state)
print(state.next_state('repeat').name)  # Output: Loop

Sample Model

This program creates a simple state graph with three states and transitions. It shows moving through states by actions.

Agentic AI

class State:
    def __init__(self, name):
        self.name = name
        self.transitions = {}

    def add_transition(self, action, next_state):
        self.transitions[action] = next_state

    def next_state(self, action):
        return self.transitions.get(action, None)

# Create states
start_state = State('Start')
middle_state = State('Middle')
end_state = State('End')

# Add transitions
start_state.add_transition('go', middle_state)
middle_state.add_transition('finish', end_state)
middle_state.add_transition('repeat', middle_state)  # loop

# Print initial state
print(f"Current state: {start_state.name}")

# Move from start to middle
current_state = start_state.next_state('go')
print(f"After 'go' action, state: {current_state.name}")

# Repeat in middle state
current_state = current_state.next_state('repeat')
print(f"After 'repeat' action, state: {current_state.name}")

# Finish to end state
current_state = current_state.next_state('finish')
print(f"After 'finish' action, state: {current_state.name}")

Important Notes

Time complexity to find the next state is O(1) because transitions are stored in a dictionary.

Space complexity depends on the number of states and transitions stored.

A common mistake is forgetting to add transitions, which leads to None when moving states.

Use state graphs when you want to clearly map all possible moves and decisions in a system.

Summary

State graphs show how a system moves between different situations.

Each state has transitions triggered by actions or events.

They help plan and understand AI agent behavior step-by-step.

Practice

1. What does a state graph primarily represent in agentic AI?

easy

A. The hardware specifications needed for AI training

B. The exact code syntax for AI algorithms

C. The final output predictions of a machine learning model

D. The different situations an AI agent can be in and how it moves between them

Solution

1. Step 1: Understand the purpose of state graphs

   State graphs show different states (situations) and how an AI agent moves between them.

2. Step 2: Compare options to this definition

   Only The different situations an AI agent can be in and how it moves between them describes states and transitions; others talk about unrelated AI aspects.

3. Final Answer:

   The different situations an AI agent can be in and how it moves between them -> Option D

4. Quick Check:

   State graph = states + transitions [OK]

Hint: State graphs = states + moves between states [OK]

Common Mistakes:

• Confusing state graphs with code syntax
• Thinking state graphs show hardware details
• Assuming state graphs show final model outputs

2. Which of the following correctly shows a transition from state S1 to S2 triggered by action 'a' in a state graph?

easy

A. S1 --a--> S2

B. S1 => S2 : a

C. S1 -a- S2

D. S1 ->a S2

Solution

1. Step 1: Recall standard notation for transitions

   Transitions are often shown as State1 --action--> State2.

2. Step 2: Match options to this notation

   S1 --a--> S2 matches the standard arrow with action label; others use incorrect or unclear syntax.

3. Final Answer:

   S1 --a--> S2 -> Option A

4. Quick Check:

   Transition notation = S1 --a--> S2 [OK]

Hint: Look for arrow with action label between states [OK]

Common Mistakes:

• Using arrows without action labels
• Confusing syntax with programming code
• Ignoring the direction of the arrow

3. Given the state graph transitions:
S1 --a--> S2
S2 --b--> S3
What is the final state after actions ['a', 'b'] starting from S1?

medium

A. S3

B. S1

C. S2

D. Undefined

Solution

1. Step 1: Follow the first action 'a' from S1

   Action 'a' moves from S1 to S2.

2. Step 2: Follow the second action 'b' from S2

   Action 'b' moves from S2 to S3.

3. Final Answer:

   S3 -> Option A

4. Quick Check:

   Actions 'a', 'b' lead S1 -> S2 -> S3 [OK]

Hint: Trace actions step-by-step through states [OK]

Common Mistakes:

• Stopping after first action
• Mixing up action order
• Assuming no transitions exist

4. Consider this state graph code snippet in Python:

transitions = { 'S1': {'a': 'S2'}, 'S2': {'b': 'S3'} }
current_state = 'S1'
actions = ['a', 'c']
for act in actions:
    current_state = transitions[current_state][act]

What error will occur when running this code?

medium

A. IndexError due to list access

B. TypeError because current_state is a string

C. KeyError because action 'c' is not valid from S2

D. No error, final state is S3

Solution

1. Step 1: Check transitions for each action

   From 'S1', action 'a' leads to 'S2'. Next action 'c' is not in transitions['S2'].

2. Step 2: Identify error type

   Accessing transitions['S2']['c'] causes a KeyError because 'c' key is missing.

3. Final Answer:

   KeyError because action 'c' is not valid from S2 -> Option C

4. Quick Check:

   Missing key in dict = KeyError [OK]

Hint: Check if action exists in current state's transitions [OK]

Common Mistakes:

• Assuming all actions are valid
• Confusing KeyError with TypeError
• Ignoring dictionary key checks

5. You want to design an AI agent that can move between states S1, S2, and S3 with transitions:
S1 --a--> S2, S2 --b--> S3, and S3 --c--> S1.
Which data structure best models these transitions for easy lookup and update?

hard

A. A list of tuples with (state, action, next_state)

B. A dictionary where keys are states and values are dictionaries of actions to next states

C. A flat list of states without actions

D. A string describing all transitions

Solution

1. Step 1: Understand the need for quick lookup by state and action

   We want to find next state given current state and action quickly.

2. Step 2: Evaluate data structures

   A dictionary of dictionaries allows direct lookup: transitions[state][action] = next_state.

3. Final Answer:

   A dictionary where keys are states and values are dictionaries of actions to next states -> Option B

4. Quick Check:

   Nested dict = fast state-action lookup [OK]

Hint: Use nested dict for state-action-next_state mapping [OK]

Common Mistakes:

• Using lists which are slower for lookups
• Ignoring the action in transitions
• Storing transitions as plain strings