Parallel tool execution in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to run two tools in parallel using asyncio.

Agentic AI

import asyncio

async def run_tools():
    task1 = asyncio.create_task(tool1())
    task2 = asyncio.create_task([1])
    await task1
    await task2

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

Atool2()

Btool1()

Ctool3()

Dtool4()

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same tool function twice.

Not calling the function (missing parentheses).

Awaiting tasks before creating both.

We create a task for tool2() to run it in parallel with tool1().

2fill in blank

medium

Complete the code to gather results from two parallel tool executions.

Agentic AI

import asyncio

async def run_tools():
    results = await asyncio.gather(tool1(), [1])
    return results

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

Atool1()

Btool3()

Ctool2()

Dtool4()

Attempts:

3 left

💡 Hint

Common Mistakes

Repeating the same tool twice.

Forgetting parentheses to call the function.

Using a non-async function.

asyncio.gather runs tool1() and tool2() concurrently and collects their results.

3fill in blank

hard

Fix the error in the code to run tools in parallel and collect results.

Agentic AI

import asyncio

async def run_tools():
    tasks = [tool1, [1]]
    results = await asyncio.gather(*[task() for task in tasks])
    return results

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

Atool2

Btool3()

Ctool4

Dtool1

Attempts:

3 left

💡 Hint

Common Mistakes

Including parentheses in the tasks list.

Mixing function calls and references.

Passing non-callable objects.

The tasks list should contain function references without parentheses to call them later.

4fill in blank

hard

Fill both blanks to create tasks for three tools and run them concurrently.

Agentic AI

import asyncio

async def run_tools():
    task1 = asyncio.create_task(tool1())
    task2 = asyncio.create_task([1])
    task3 = asyncio.create_task([2])
    await asyncio.gather(task1, task2, task3)

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

Atool2()

Btool3()

Ctool4()

Dtool1()

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same tool multiple times.

Missing parentheses in function calls.

Not awaiting all tasks together.

Create tasks for tool2() and tool3() to run all three tools in parallel.

5fill in blank

hard

Fill all three blanks to run tools in parallel and collect their results in a dictionary.

Agentic AI

import asyncio

async def run_tools():
    results = await asyncio.gather(tool1(), [1], [2])
    return {"tool1": results[0], [3]: results[1], "tool3": results[2]}

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

Atool2()

B"tool2"

Ctool3()

D"tool1"

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect keys in the dictionary.

Forgetting parentheses in function calls.

Mixing up the order of results.

Run tool2() and tool3() in parallel with tool1(), then map results to keys 'tool2' and 'tool3'.

Practice

1.

What is the main benefit of parallel tool execution in AI workflows?

easy

A. It makes tools run slower but more accurately.

B. It runs tools one after another to avoid errors.

C. It only works if tasks depend on each other.

D. It runs multiple tools at the same time to save time.

Solution

1. Step 1: Understand parallel execution

   Parallel execution means running many tasks at once, not one by one.

2. Step 2: Identify the benefit in AI workflows

   Running tools simultaneously saves time and improves efficiency.

3. Final Answer:

   It runs multiple tools at the same time to save time. -> Option D

4. Quick Check:

   Parallel execution = run many tools at once [OK]

Hint: Parallel means many at once, so it saves time [OK]

Common Mistakes:

• Thinking parallel means slower execution
• Believing tasks must depend on each other
• Confusing parallel with sequential execution

2.

Which of the following is the correct way to start parallel execution of two tools toolA and toolB in Python using concurrent.futures?

import concurrent.futures

with concurrent.futures.ThreadPoolExecutor() as executor:
    # What goes here?

easy

A. executor.parallel(toolA, toolB)

B. executor.run(toolA, toolB)

C. executor.submit(toolA); executor.submit(toolB)

D. executor.execute(toolA & toolB)

Solution

1. Step 1: Recall ThreadPoolExecutor usage

   The method to run functions in parallel is submit() for each function.

2. Step 2: Check the options

   Only executor.submit(toolA); executor.submit(toolB) correctly submits both tools for parallel execution.

3. Final Answer:

   executor.submit(toolA); executor.submit(toolB) -> Option C

4. Quick Check:

   Use submit() to run functions in parallel [OK]

Hint: Use submit() for each tool to run in parallel [OK]

Common Mistakes:

• Using non-existent methods like run() or execute()
• Trying to pass multiple tools in one call
• Confusing parallel execution syntax

3.

Given the code below, what will be the output?

import concurrent.futures
import time

def tool1():
    time.sleep(2)
    return 'Done1'

def tool2():
    time.sleep(1)
    return 'Done2'

with concurrent.futures.ThreadPoolExecutor() as executor:
    future1 = executor.submit(tool1)
    future2 = executor.submit(tool2)
    print(future1.result())
    print(future2.result())

medium

A. Done2\nDone1

B. Done1\nDone2

C. Done1\nDone1

D. Done2\nDone2

Solution

1. Step 1: Understand parallel execution and sleep times

   tool1 sleeps 2 seconds, tool2 sleeps 1 second, both start together.

2. Step 2: Check order of result() calls

   future1.result() waits for tool1 (2s), then future2.result() waits for tool2 (1s). So output order matches calls, not completion time.

3. Final Answer:

   Done1 Done2 -> Option B

4. Quick Check:

   Results print in call order, not finish order [OK]

Hint: result() waits; output order matches calls, not finish time [OK]

Common Mistakes:

• Assuming output order matches task finish time
• Ignoring that result() blocks until done
• Confusing sleep durations with print order

4.

What is the error in the following code that tries to run two tools in parallel?

import concurrent.futures

def toolA():
    return 'A'

def toolB():
    return 'B'

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = executor.map(toolA, toolB)
    print(list(results))

medium

A. executor.map expects a function and an iterable, but toolB is not iterable.

B. executor.map cannot run more than one function at a time.

C. Missing parentheses when calling toolA and toolB.

D. ThreadPoolExecutor cannot be used with map.

Solution

1. Step 1: Understand executor.map signature

   executor.map expects one function and an iterable of inputs to apply that function to.

2. Step 2: Identify the error in arguments

   Passing two functions (toolA, toolB) is wrong; toolB is not an iterable of inputs for toolA.

3. Final Answer:

   executor.map expects a function and an iterable, but toolB is not iterable. -> Option A

4. Quick Check:

   map(func, iterable) needs iterable inputs [OK]

Hint: map needs one function and iterable inputs, not two functions [OK]

Common Mistakes:

• Passing multiple functions to map
• Confusing map with submit
• Thinking map runs multiple different functions

5.

You want to run three independent AI tools toolX, toolY, and toolZ in parallel and collect their results as a dictionary with tool names as keys. Which code snippet correctly achieves this?

def toolX(): return 'X result'
def toolY(): return 'Y result'
def toolZ(): return 'Z result'

# Choose the correct parallel execution code

hard

A. import concurrent.futures
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {name: executor.submit(func) for name, func in {'toolX': toolX, 'toolY': toolY, 'toolZ': toolZ}.items()}
results = {name: future.result() for name, future in futures.items()}
print(results)

B. import concurrent.futures
with concurrent.futures.ThreadPoolExecutor() as executor:
results = executor.map(toolX, toolY, toolZ)
print(dict(results))

C. results = {}
for tool in [toolX, toolY, toolZ]:
results[tool.__name__] = tool()
print(results)

D. import threading
results = {}
def run_tool(name, func):
results[name] = func()
threads = []
for name, func in {'toolX': toolX, 'toolY': toolY, 'toolZ': toolZ}.items():
t = threading.Thread(target=run_tool, args=(name, func))
threads.append(t)
t.start()
for t in threads:
t.join()
print(results)

Solution

1. Step 1: Check parallel execution with ThreadPoolExecutor

   import concurrent.futures with concurrent.futures.ThreadPoolExecutor() as executor: futures = {name: executor.submit(func) for name, func in {'toolX': toolX, 'toolY': toolY, 'toolZ': toolZ}.items()} results = {name: future.result() for name, future in futures.items()} print(results) uses submit() for each tool, stores futures with names, then collects results correctly.

2. Step 2: Evaluate other options

   import concurrent.futures with concurrent.futures.ThreadPoolExecutor() as executor: results = executor.map(toolX, toolY, toolZ) print(dict(results)) misuses map with multiple functions; results = {} for tool in [toolX, toolY, toolZ]: results[tool.__name__] = tool() print(results) runs tools sequentially; import threading results = {} def run_tool(name, func): results[name] = func() threads = [] for name, func in {'toolX': toolX, 'toolY': toolY, 'toolZ': toolZ}.items(): t = threading.Thread(target=run_tool, args=(name, func)) threads.append(t) t.start() for t in threads: t.join() print(results) uses threading correctly but is more complex and not asked.

3. Final Answer:

   Option A correctly runs tools in parallel and collects results as a dictionary. -> Option A

4. Quick Check:

   submit() + dict comprehension collects parallel results [OK]

Hint: Use submit() with dict comprehension to map names to results [OK]

Common Mistakes:

• Using map() with multiple functions
• Running tools sequentially instead of parallel
• Confusing threading with ThreadPoolExecutor usage