State graphs and transitions in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add a state transition from 'start' to 'processing'.

Agentic AI

state_graph = {}
state_graph['start'] = [1]

Drag options to blanks, or click blank then click option'

A['processing']

B'processing'

Cprocessing

D('processing')

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of a list for transitions.

Forgetting to use quotes around 'processing'.

The transitions for a state are stored as a list of next states. So we use a list with 'processing' inside.

2fill in blank

medium

Complete the code to check if 'end' is a valid next state from 'processing'.

Agentic AI

if [1] in state_graph['processing']:
    print('Can move to end')

Drag options to blanks, or click blank then click option'

A"processing"

Bend

C'end'

D'processing'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name without quotes.

Checking for the wrong state name.

We check if the string 'end' is in the list of next states from 'processing'.

3fill in blank

hard

Fix the error in the code to correctly add a transition from 'processing' to 'end'.

Agentic AI

state_graph['processing'] = [1]

Drag options to blanks, or click blank then click option'

A'end'

B('end')

Cend

D['end']

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning a string instead of a list.

Using parentheses which create a string, not a tuple.

Transitions must be lists of states, so we use ['end'] to add the transition.

4fill in blank

hard

Fill both blanks to create a state graph with transitions from 'start' to 'processing' and from 'processing' to 'end'.

Agentic AI

state_graph = {
    'start': [1],
    'processing': [2]
}

Drag options to blanks, or click blank then click option'

A['processing']

B'end'

C['end']

D'processing'

Attempts:

3 left

💡 Hint

Common Mistakes

Using strings instead of lists for transitions.

Mixing up the order of states.

The 'start' state transitions to ['processing'], and 'processing' transitions to ['end'], both as lists.

5fill in blank

hard

Fill all three blanks to define a function that returns the next states from a given state in the graph.

Agentic AI

def get_next_states(state_graph, state):
    return state_graph.get([1], [2])

next_states = get_next_states(state_graph, [3])

Drag options to blanks, or click blank then click option'

Astate

B[]

C'processing'

D'start'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string literal instead of the variable 'state'.

Not providing a default value for missing keys.

Passing the wrong state name when calling the function.

The function looks up the given state in the graph, returning an empty list if not found. We call it with 'start' to get its next states.

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