Scaling agents horizontally in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create multiple agents running in parallel.

Agentic AI

agents = [Agent() for _ in range([1])]

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

A1

B10

C5

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 agents means no agents run.

Using 1 agent does not scale horizontally.

We create 5 agents to scale horizontally by running multiple instances.

2fill in blank

medium

Complete the code to start all agents asynchronously.

Agentic AI

results = await asyncio.gather(*[agent.[1]() for agent in agents])

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

Astart

Bstop

Crun

Dpause

Attempts:

3 left

💡 Hint

Common Mistakes

Using stop() or pause() will not start the agents.

Using run() might be valid but here the method is start().

We use start() to begin each agent's task asynchronously.

3fill in blank

hard

Fix the error in the code to correctly collect agent outputs.

Agentic AI

outputs = [agent.[1]() for agent in agents]
results = await asyncio.gather(*outputs)

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

Arun_async

Bstart

Cexecute

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using synchronous methods causes errors with await.

Using run() or execute() may not be async.

The start() method is asynchronous and returns a coroutine to await.

4fill in blank

hard

Fill both blanks to create a dictionary of agent results filtered by success.

Agentic AI

success_results = {agent.id: result for agent, result in zip(agents, results) if result [1] [2]

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

A==

BTrue

CFalse

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using != False works but is less clear.

Using == False filters failures, not successes.

We filter results where result == True to keep only successful outputs.

5fill in blank

hard

Fill all three blanks to aggregate agent outputs into a summary dictionary.

Agentic AI

summary = [1](agent.id: [2] for agent, [3] in zip(agents, results))

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

Adict

Bresult

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same variable name for both zipped elements causes confusion.

Not using dict to convert the generator to a dictionary.

We use dict to build a dictionary from a generator expression. The loop variables are agent and item (the result).

Practice

1. What does scaling agents horizontally mean in agentic AI?

easy

A. Adding more agents to share and run tasks in parallel

B. Making one agent work faster by improving its code

C. Reducing the number of agents to save resources

D. Changing the task to fit a single agent's ability

Solution

1. Step 1: Understand the term 'scaling horizontally'

   Scaling horizontally means increasing the number of units (agents) to handle more work simultaneously.

2. Step 2: Apply to agentic AI context

   In agentic AI, this means adding more agents to share tasks and run them in parallel, speeding up processing.

3. Final Answer:

   Adding more agents to share and run tasks in parallel -> Option A

4. Quick Check:

   Scaling horizontally = Adding more agents [OK]

Hint: More agents working together means horizontal scaling [OK]

Common Mistakes:

• Confusing horizontal scaling with making one agent faster
• Thinking scaling means reducing agents
• Assuming scaling changes the task itself

2. Which of the following is the correct way to start multiple agents in parallel in Python?

easy

A. for agent in agents:
agent.start()

B. for agent in agents:
agent.run()

C. for agent in agents:
agent.execute()

D. for agent in agents:
agent.parallel()

Solution

1. Step 1: Identify the method to start agents in parallel

   In many agent frameworks, start() is used to begin an agent's process or thread asynchronously.

2. Step 2: Compare options

   run() usually runs synchronously blocking the loop, execute() and parallel() are not standard methods.

3. Final Answer:

   for agent in agents: agent.start() -> Option A

4. Quick Check:

   Use start() to launch agents in parallel [OK]

Hint: Use start() to run agents asynchronously [OK]

Common Mistakes:

• Using run() which blocks instead of start()
• Assuming execute() or parallel() are valid methods
• Not looping over all agents

3. Given this code snippet for scaling agents horizontally, what will be the output?

class Agent:
    def __init__(self, id):
        self.id = id
    def run(self):
        print(f"Agent {self.id} running")

agents = [Agent(i) for i in range(3)]
for agent in agents:
    agent.run()

medium

A. Agent 3 running

B. Agent running\nAgent running\nAgent running

C. No output, code has error

D. Agent 0 running\nAgent 1 running\nAgent 2 running

Solution

1. Step 1: Understand the Agent class and its run method

   The run method prints the agent's id with the message "Agent {id} running".

2. Step 2: Analyze the loop over agents

   There are 3 agents with ids 0, 1, 2. The loop calls run() on each, printing their messages in order.

3. Final Answer:

   Agent 0 running Agent 1 running Agent 2 running -> Option D

4. Quick Check:

   Each agent prints its id running [OK]

Hint: Each agent prints its id in order [OK]

Common Mistakes:

• Thinking all agents print the same message without id
• Assuming only one agent runs
• Believing code has syntax error

4. This code tries to scale agents horizontally but does not run agents in parallel. What is the error?

class Agent:
    def run(self):
        print("Running")

agents = [Agent() for _ in range(3)]
for agent in agents:
    agent.run()

medium

A. The list comprehension syntax is wrong

B. Agent class is missing an __init__ method

C. Agents are run sequentially, not in parallel

D. The run method should be named start

Solution

1. Step 1: Check how agents are executed

   The for loop calls run() on each agent one after another, so execution is sequential.

2. Step 2: Understand parallel execution requirement

   To scale horizontally, agents must run in parallel, e.g., using threads or async calls, not sequential calls.

3. Final Answer:

   Agents are run sequentially, not in parallel -> Option C

4. Quick Check:

   Sequential run ≠ horizontal scaling [OK]

Hint: Sequential calls don't scale horizontally [OK]

Common Mistakes:

• Thinking missing __init__ causes no parallelism
• Believing list comprehension is incorrect
• Assuming run must be renamed to start

5. You want to scale 5 agents horizontally to process independent tasks faster. Which approach best achieves this in Python?

hard

A. Run all agents sequentially in a single loop

B. Run each agent's task in a separate thread using threading.Thread

C. Use a single agent to process all tasks one by one

D. Run agents in a loop but wait for each to finish before starting next

Solution

1. Step 1: Understand the goal of horizontal scaling

   We want to run multiple agents at the same time to speed up processing independent tasks.

2. Step 2: Evaluate options for parallel execution

   Using threading.Thread runs agents concurrently, achieving horizontal scaling. Sequential loops or waiting block parallelism.

3. Final Answer:

   Run each agent's task in a separate thread using threading.Thread -> Option B

4. Quick Check:

   Threads enable parallel agent execution [OK]

Hint: Use threads to run agents in parallel [OK]

Common Mistakes:

• Running agents sequentially thinking it's parallel
• Using one agent for all tasks ignoring scaling
• Starting agents but waiting for each to finish before next