What is an AI agent?
AI agents are software systems that use AI to pursue goals and complete tasks on behalf of users. They show reasoning, planning, and memory and have a level of autonomy to make decisions, learn, and adapt. Their capabilities are made possible in large part by the multimodal capacity of generative AI and AI foundation models. AI agents can process multimodal information like text, voice, video, audio, code, and more simultaneously; can converse, reason, learn, and make decisions. They can learn over time and facilitate transactions and business processes. Agents can work with other agents to coordinate and perform more complex workflows. Google Cloud
Short, technical definition
An AI agent is a system that uses an LLM to decide the control flow of an application. LangChain
Key features of an AI agent
- Reasoning: using logic and available information to draw conclusions, make inferences, and solve problems. Google Cloud
- Acting: the ability to take action or perform tasks (digital actions like sending messages, updating data, or triggering processes). Google Cloud
- Observing: gathering information about the environment via perception (NLP, vision, sensors). Google Cloud
- Planning: developing strategic plans to achieve goals and anticipating future states. Google Cloud
- Collaborating: working with humans or other agents to coordinate and perform complex workflows. Google Cloud
- Self-refining / Learning: adapting behavior from experience using machine learning or optimization techniques. Google Cloud
Building blocks, workflows, and agent patterns (summary)
The basic building block of agentic systems is an LLM enhanced with augmentations such as retrieval, tools, and memory. From there, common patterns include: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. These patterns can be combined or simplified depending on task complexity. Anthropic
- Prompt chaining: decompose a task into a sequence of steps where each LLM call processes the previous output.
- Routing: classify input and direct it to specialized followup tasks.
- Parallelization: run independent subtasks in parallel or run multiple attempts and aggregate (voting).
- Orchestrator-workers: a central LLM breaks down tasks, delegates to worker LLMs, and synthesizes results.
- Evaluator-optimizer: one LLM generates a response while another provides evaluation and feedback in a loop.
(Descriptions above quoted from: Anthropic)
When (and when not) to use agents
“When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. Agentic systems often trade latency and cost for better task performance, and you should consider when this tradeoff makes sense. Workflows offer predictability for well-defined tasks; agents are better when flexibility and model-driven decision-making are needed at scale.” Anthropic
AGENTS.md — a README for coding agents
AGENTS.md is a simple, open format for guiding coding agents, used by over 20k open-source projects. Think of AGENTS.md as a README for agents: a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project. Create an AGENTS.md at the repository root and include project overview, build and test commands, code style guidelines, testing instructions, and deployment steps. For large monorepos, use nested AGENTS.md files for subprojects—the closest file takes precedence. AGENTS.md
How to build a simple agent (example: Google ADK content assistant)
From the tutorial “Your First AI Agent (Google ADK Tutorial)”:
Setup and prerequisites (verbatim excerpts):
python3 -m venv venv
source venv/bin/activate # macOS/Linux
.\venv\Scripts\activate # Windows
pip install google-generativeai google-ad-agents
Project structure example (verbatim excerpt):
my-agent-project/
├── agent.py
├── __init__.py
└── .env
Example excerpt from agent.py (verbatim excerpt):
# agent.py
import os
from dotenv import load_dotenv
import google.generativeai as genai
from google.adk.agents import LlmAgent, SequentialAgent
load_dotenv(dotenv_path=os.path.join(os.path.dirname(__file__), ".env"))
api_key = os.getenv("GOOGLE_API_KEY")
if not api_key:
raise RuntimeError("Missing GOOGLE_API_KEY in .env")
genai.configure(api_key=api_key)
def generate_ideas(topic: str) -> str:
model = genai.GenerativeModel(model_name="gemini-2.0-flash")
resp = model.generate_content(f"Brainstorm 4–6 creative blog post ideas for the topic:\n\n{topic}")
return resp.text
# ... (write_content, format_draft functions) ...
topic_agent = LlmAgent(
name="IdeaAgent",
model="gemini-2.0-flash",
description="Brainstorms blog post ideas.",
instruction=("Call generate_ideas(topic) with the exact topic string you receive "
"and return only the ideas."),
tools=[generate_ideas],
output_key="ideas"
)
root_agent = SequentialAgent(
name="ContentAssistant",
sub_agents=[topic_agent, /* draft_agent, format_agent */],
description="Takes a user topic → generates ideas → writes draft → formats as Markdown"
)
Run inside the terminal or use ADK web UI: adk run [your-project-folder] or adk web. GitHub - proflead/how-to-build-ai-agent
Practical advice from frameworks and vendors
- “Start with simple prompts; optimize with evaluation; add multi-step agentic systems only when simpler solutions fall short.” Anthropic
- “An agentic system can be viewed as a spectrum — the more an LLM decides how the system behaves, the more agentic it is.” LangChain
- Distinguish agents vs assistants vs bots by autonomy, complexity, and learning capability. Google Cloud
Share Your Thoughts
- What is an AI agent in your work or project context? LangChain
- What is the difference between AI agents, AI assistants, and bots in your view? Google Cloud
- When (and when not) would you choose an agentic system over a simple workflow? Anthropic
- How could AGENTS.md improve collaboration between human developers and coding agents in your repo? AGENTS.md