What are AI agents?

Key Concepts

• AI Agent: Software capable of reasoning, planning, and taking autonomous actions to achieve a goal.
• ReAct (Reasoning + Acting): A framework where models reason step-by-step, perform actions (tools/APIs), observe results, and adjust accordingly.
• Shared State: A centralized data structure where agents store and retrieve information to pass between steps.
• Loop Agent: A workflow pattern that automatically retries a task if validation fails.
• Root Agent: The primary controller that orchestrates sub-agents and tools to complete a complex task.

---

1. Understanding AI Agents

An AI agent differs from a traditional chatbot by its ability to decide and act. Instead of a single-turn response, it follows a cycle of:

1. Reasoning: Analyzing the request and determining necessary steps.
2. Acting: Executing code or calling APIs.
3. Observing: Evaluating the output of the action.
4. Adjusting: Deciding the next move based on the observation.

Agent Patterns

• Sequential Agents: Rigid, assembly-line execution (Step 1 → Step 2 → Step 3). Best for predictable flows.
• Reactive Agents: Flexible, decision-making in the moment based on current state. Best for dynamic environments.
• Deliberate/Planning Agents: Pause to sketch a plan before execution. Best for multi-step goals with dependencies (e.g., travel booking).

---

2. Building a Blog Writing Agent (Step-by-Step)

The project uses Google’s SDK to build a multi-agent system for generating blog posts.

Phase 1: The Planning Loop

• Blog Planner: An LLM-powered agent instructed to create a markdown outline (title, intro, 4–6 sections, conclusion). Output is saved to blog_outline in the shared state.
• Outline Validation Checker: A strict agent that verifies the outline against the requirements. It returns "OK" or "retry" with specific feedback.
• Robust Blog Planner: A Loop Agent that wraps the planner and checker, allowing up to three retries if the validation fails.

Phase 2: The Writing Loop

• Blog Writer: Takes the blog_outline and generates a full post tailored for software engineers, including code snippets and proper headings. Output is saved to blog_post.
• Blog Post Validation Checker: Verifies the draft against the outline and quality standards.
• Robust Blog Writer: A Loop Agent that manages the writing/validation cycle with a three-retry limit.

Phase 3: Orchestration

• Root Agent (Blogger): The final controller. It is given access to the Robust Blog Planner and Robust Blog Writer as tools.
• Workflow: The user provides a topic → Root agent calls the Planner tool → Root agent calls the Writer tool → Root agent generates final titles and hooks.

---

3. Implementation Details

• Environment Setup: Requires uv for package management and the Google SDK.
• Execution: The agent is launched via adk web, which provides a UI to monitor the reasoning process and state transitions in real-time.
• Technical Logic: By defining output_key in the agent configuration, the system ensures seamless data hand-offs between sub-agents via the shared state.

---

4. Key Arguments and Perspectives

• Reliability through Validation: The presenter argues that by using "Checker" agents, developers can create a "safety net" that significantly improves the quality of LLM outputs compared to single-shot generation.
• Modularity: By wrapping agents as tools, the system remains clean and controlled. The root agent does not need to know the internal logic of the sub-agents, only how to invoke them.

---

5. Synthesis and Conclusion

The video demonstrates that modern AI agents are not just about prompting; they are about workflow engineering. By combining reasoning models with structured loops and validation checks, developers can transform unpredictable LLM outputs into reliable, automated systems. The core takeaway is the transition from "chatting" to "orchestrating," where the developer defines the constraints and the agent manages the execution path to achieve the desired outcome.