Throughout this course, you've learned the fundamentals of integrating tools with Gemini: defining tool schemas, understanding Gemini's tool use responses, and executing single tool requests. However, the approach you've used so far is limited to handling only one tool call per conversation turn. While this is sufficient for simple tasks, many real-world problems require multiple sequential steps, and often the number and nature of these steps can't be determined in advance.

In this lesson, we'll work together to transform Gemini from a single-turn tool user into an autonomous agent capable of iterative problem-solving. We'll build an agent class that can call tools, analyze results, decide what to do next, and continue this process until complex multi-step tasks are completed. This marks a shift from reactive tool usage to proactive, intelligent problem-solving — mirroring how humans approach complex challenges.

Before we start coding, let's understand how autonomous agents operate through action-feedback loops. In this pattern, each tool execution provides information that influences the next decision. This iterative process mirrors human problem-solving: we take an action, observe the result, decide what to do next, and repeat until we reach our goal. The action-feedback loop consists of four key phases that repeat until task completion:

1. Decision Phase: Gemini analyzes the current situation and determines the next action, which may include calling one or more tools.
2. Action Phase: Our agent executes the requested tool(s) based on Gemini's instructions.
3. Feedback Phase: The results from the tool execution(s) are captured and added to the conversation history.
4. Evaluation Phase: Gemini reviews the new information, decides whether the task is complete or if additional steps are needed, and the loop continues.

This loop structure enables complex problem-solving because each iteration builds upon previous results. For example, when solving a quadratic equation, Gemini might first calculate the discriminant, then use that result to determine if real solutions exist, then calculate the square root of the discriminant, and finally compute the two solutions. The key insight is that Gemini doesn't need to plan all steps in advance — it can adapt its approach based on intermediate results, just like a human mathematician working through a problem.

Now, let's start building our agent class to make this iterative process possible.

Let's begin by creating the foundation of our autonomous agent using Gemini. We'll use the Google Generative AI Python SDK and configure it to use the "models/gemini-flash-latest" model. We'll also set up tool integration using Gemini's tool-calling API.

Here's the initial class definition and constructor:

Key design decisions:

• BASE_SYSTEM_PROMPT: Instructs Gemini to use tools as needed and only show the final answer to the user.

As our agent works through complex problems, we need to manage conversation state properly. Let's add two essential helper methods for Gemini's message and response structure:

Explanation:

• _extract_text: Combines all text parts from Gemini's response, ensuring we return a clean, readable final response.
• _build_request_args: Centralizes how we construct API requests, ensuring consistent parameters and conditional inclusion of tool schemas.

These helpers keep our orchestration logic clean and focused.

Now, let's add the method that handles individual tool executions within our agent loop, using Gemini's tool call conventions:

Explanation:

• Extracts the tool name, arguments, and call ID from Gemini's tool call structure.
• Executes the tool with error handling.
• Returns the result in Gemini's expected format for tool responses.

This ensures robust, resilient tool execution within the agent loop.

Gemini's API is stateless: each call to the model includes the full conversation history. Our agent should not store state between runs. Instead, we pass the entire message history as input and work on a copy:

This design allows the same agent instance to handle multiple independent conversations and gives you full control over context management.

Now, let's add the basic loop structure for iterative problem-solving with Gemini:

Each iteration represents one action-feedback cycle, and the turn counter prevents infinite loops.

Gemini signals tool calls via the content.parts structure, where a part may have a function_call. Let's handle tool calls accordingly:

This ensures all tool calls are executed and their results are fed back into the conversation.

When Gemini doesn't request any tool calls, it means the agent has reached a final answer. Let's extract the answer and return it:

This structure ensures the agent returns the final answer and the full conversation history, or raises an exception if the loop limit is reached.

Here's the complete run method for our Gemini agent:

Let's test our Gemini-based agent on a complex quadratic equation. We'll use math tools and schemas as before. Ensure you have your GOOGLE_API_KEY set as an environment variable so the SDK can access it securely.

Sample output:

Our Gemini agent systematically applies the quadratic formula, making multiple tool calls and building upon previous results, just like a human mathematician.

Together, we've built an autonomous agent using Gemini that can tackle complex, multi-step problem-solving tasks. Our agent class manages conversation state, tool execution, and iterative decision-making in a reusable structure that can handle problems requiring many sequential operations.

This architecture enables Gemini to operate as a true autonomous agent: it can assess situations, make decisions, execute tools, learn from results, and continue iterating until complex tasks are completed. This is a significant advancement from simple tool usage to intelligent, adaptive problem-solving.

In the upcoming practice exercises, you'll implement your own autonomous agents, experiment with different system prompts and tool combinations, and tackle increasingly complex multi-step problems. You'll gain hands-on experience with debugging and optimization techniques for production agent systems, building on the solid foundation we've created together.