AI Agents Explained: How Autonomous AI Systems Work and What They Can Do

ReAct Loop:

Thought: "I need to find current information about Python frameworks."
Action: web_search("Python web frameworks comparison 2026")
Observation: "FastAPI, Django, Flask, Tornado, Sanic are the top frameworks..."

Thought: "I should look at each framework's GitHub stars for popularity data."
Action: web_search("FastAPI GitHub stars")
Observation: "FastAPI: 74,000 stars..."

Thought: "Let me continue for each framework..."
[... more iterations ...]

Thought: "I have enough information to write the comparison table."
Final Answer: [comparison table]

import json
import requests
from openai import OpenAI

client = OpenAI()

# Tool implementations
def web_search(query: str) -> str:
    """Search DuckDuckGo for information."""
    try:
        response = requests.get(
            "https://api.duckduckgo.com/",
            params={"q": query, "format": "json", "no_html": "1"},
            timeout=5
        )
        data = response.json()
        results = []
        if data.get("Abstract"):
            results.append(f"Summary: {data['Abstract']}")
        for topic in data.get("RelatedTopics", [])[:3]:
            if isinstance(topic, dict) and topic.get("Text"):
                results.append(f"- {topic['Text'][:200]}")
        return "\n".join(results) if results else "No results found."
    except Exception as e:
        return f"Search error: {e}"

def calculate(expression: str) -> str:
    """Evaluate a mathematical expression safely."""
    try:
        allowed_names = {"abs": abs, "round": round, "min": min, "max": max}
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return str(result)
    except Exception as e:
        return f"Calculation error: {e}"

def write_file(filename: str, content: str) -> str:
    """Write content to a file."""
    with open(filename, "w") as f:
        f.write(content)
    return f"File written: {filename}"

# Tool schemas for the LLM
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for current information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Calculate mathematical expressions",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Math expression like '2 + 2 * 3'"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write content to a file",
            "parameters": {
                "type": "object",
                "properties": {
                    "filename": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["filename", "content"]
            }
        }
    }
]

TOOL_FUNCTIONS = {
    "web_search": web_search,
    "calculate": calculate,
    "write_file": write_file
}

def run_agent(task: str, max_iterations: int = 10) -> str:
    """Run an agent on a task until completion or max iterations."""
    
    messages = [
        {
            "role": "system",
            "content": """You are a helpful AI agent. Use tools to complete tasks.
Think step by step. Use tools when you need current information or to perform actions.
When you have enough information to complete the task, provide your final answer."""
        },
        {"role": "user", "content": task}
    ]
    
    for iteration in range(max_iterations):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=TOOLS,
            tool_choice="auto"
        )
        
        choice = response.choices[0]
        print(f"\n[Iteration {iteration + 1}] Finish reason: {choice.finish_reason}")
        
        if choice.finish_reason == "stop":
            return choice.message.content
        
        elif choice.finish_reason == "tool_calls":
            messages.append(choice.message)
            
            for tool_call in choice.message.tool_calls:
                func_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)
                
                print(f"  → Calling {func_name}({args})")
                result = TOOL_FUNCTIONS[func_name](**args)
                print(f"  ← Result: {result[:100]}...")
                
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
    
    return "Max iterations reached without final answer"

# Run the agent
result = run_agent(
    "Research the three most popular Python web frameworks and create a "
    "comparison.md file with a table comparing them on: speed, learning curve, "
    "use case, and GitHub stars."
)
print(f"\nFinal Result: {result}")

from typing import Optional

class AgentMemory:
    """Four types of memory for a complete agent."""
    
    def __init__(self):
        # 1. Sensory: immediate context (current window)
        self.current_messages = []
        
        # 2. Short-term: current task state
        self.task_state = {}
        
        # 3. Long-term: persistent facts (vector DB in production)
        self.facts = []
        
        # 4. Episodic: past conversations (database)
        self.conversation_history = []
    
    def add_fact(self, fact: str):
        self.facts.append({"fact": fact, "timestamp": "now"})
    
    def get_relevant_facts(self, query: str, max_facts: int = 5) -> list[str]:
        # In production: use embedding similarity search
        return [f["fact"] for f in self.facts[-max_facts:]]
    
    def get_context_prompt(self) -> str:
        facts = self.get_relevant_facts("current task")
        if not facts:
            return ""
        return "\n\nWhat I know:\n" + "\n".join(f"- {f}" for f in facts)

Use a Chain when:
  ✓ Steps are known in advance
  ✓ You need deterministic, reproducible output
  ✓ Cost per run must be predictable
  ✓ Debugging requires clarity on each step
  ✓ The task is well-defined and doesn't require exploration

Use an Agent when:
  ✓ You don't know what steps will be needed
  ✓ The task requires information retrieval before knowing the next step
  ✓ Success requires adapting to unexpected results
  ✓ You want to handle varied inputs with different solutions
  ✓ The task involves problem-solving, not just execution