What Are AI Agents?

// Basic AI Agent loop in TypeScript
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

interface Tool {
  name: string;
  description: string;
  execute: (input: Record<string, unknown>) => Promise<string>;
}

async function agentLoop(
  objective: string,
  tools: Tool[],
  maxIterations: number = 10
): Promise<string> {
  const messages: { role: string; content: string }[] = [];
  let iteration = 0;

  const systemPrompt = `You are an AI agent. Your objective: ${objective}
Available tools: ${tools.map(t => `${t.name}: ${t.description}`).join("\n")}
Respond with a tool call or FINAL ANSWER when done.`;

  while (iteration < maxIterations) {
    const response = await anthropic.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 1024,
      system: systemPrompt,
      messages: messages as any,
    });

    const text = response.content[0].type === "text"
      ? response.content[0].text : "";

    if (text.includes("FINAL ANSWER")) {
      return text;
    }

    // Parse tool call and execute
    const toolCall = parseToolCall(text);
    if (toolCall) {
      const tool = tools.find(t => t.name === toolCall.name);
      const result = tool
        ? await tool.execute(toolCall.input)
        : "Tool not found";
      messages.push({ role: "assistant", content: text });
      messages.push({ role: "user", content: `Tool result: ${result}` });
    }

    iteration++;
  }

  return "Max iterations reached";
}

# Basic AI Agent loop in Python
import anthropic

client = anthropic.Anthropic()

def agent_loop(objective: str, tools: list, max_iterations: int = 10) -> str:
    messages = []
    iteration = 0

    system_prompt = f"""You are an AI agent. Your objective: {objective}
Available tools: {', '.join(t['name'] for t in tools)}
Respond with a tool call or FINAL ANSWER when done."""

    while iteration < max_iterations:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system_prompt,
            messages=messages,
        )

        text = response.content[0].text

        if "FINAL ANSWER" in text:
            return text

        # Parse tool call and execute
        tool_call = parse_tool_call(text)
        if tool_call:
            tool = next((t for t in tools if t["name"] == tool_call["name"]), None)
            result = tool["execute"](tool_call["input"]) if tool else "Tool not found"
            messages.append({"role": "assistant", "content": text})
            messages.append({"role": "user", "content": f"Tool result: {result}"})

        iteration += 1

    return "Max iterations reached"

// Simple research agent with Vercel AI SDK
import { generateText, tool } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
import { z } from "zod";

const result = await generateText({
  model: anthropic("claude-sonnet-4-20250514"),
  maxSteps: 5, // Allow up to 5 agent loop iterations
  tools: {
    searchWeb: tool({
      description: "Search the web for information",
      parameters: z.object({
        query: z.string().describe("The search query"),
      }),
      execute: async ({ query }) => {
        // Integrate with a search API (e.g., Tavily, SerpAPI)
        const response = await fetch(
          `https://api.tavily.com/search?query=${encodeURIComponent(query)}`,
          { headers: { "X-API-Key": process.env.TAVILY_API_KEY! } }
        );
        const data = await response.json();
        return data.results.map((r: any) => r.content).join("\n");
      },
    }),
    readUrl: tool({
      description: "Read the content of a URL",
      parameters: z.object({
        url: z.string().url().describe("The URL to read"),
      }),
      execute: async ({ url }) => {
        const response = await fetch(url);
        return await response.text();
      },
    }),
  },
  prompt: "Research the latest developments in AI agents for 2026",
});

console.log(result.text);