AI Agents & Agentic Systems - Learn AI | TechLead

What are AI Agents?

AI Agents are autonomous systems that go beyond simple question-answering. They can reason about problems, plan multi-step solutions, use external tools, and execute actions in the real world — all with minimal human intervention.

🧠 Agent = LLM + Tools + Memory + Planning

An LLM becomes an agent when it can decide what to do next, which tool to use, observe the result, and iterate until the task is complete.

Agent Architecture

🧠 The ReAct Pattern

The most common agent architecture: Reasoning + Acting in an interleaved loop.

1. Thought: The LLM reasons about what to do next
2. Action: The LLM selects a tool and provides inputs
3. Observation: The tool executes and returns results
4. Repeat: until the task is complete or max iterations reached

🔧 Tool Use (Function Calling)

Agents extend LLM capabilities by calling external functions:

// Defining tools for an AI agent
const tools = [
  {
    name: "search_web",
    description: "Search the web for current information",
    parameters: {
      type: "object",
      properties: {
        query: { type: "string", description: "Search query" }
      },
      required: ["query"]
    },
    execute: async (args) => {
      const results = await searchAPI(args.query);
      return results.map(r => r.snippet).join('\n');
    }
  },
  {
    name: "run_code",
    description: "Execute JavaScript code and return the output",
    parameters: {
      type: "object",
      properties: {
        code: { type: "string", description: "JavaScript code to execute" }
      },
      required: ["code"]
    },
    execute: async (args) => {
      return await sandbox.run(args.code);
    }
  },
  {
    name: "read_file",
    description: "Read contents of a file",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "File path to read" }
      },
      required: ["path"]
    },
    execute: async (args) => {
      return await fs.readFile(args.path, 'utf-8');
    }
  }
];

// Agent loop
async function runAgent(task, tools, maxSteps = 10) {
  const messages = [
    { role: "system", content: "You are an agent that can use tools to complete tasks. Think step by step." },
    { role: "user", content: task }
  ];

  for (let step = 0; step < maxSteps; step++) {
    const response = await llm.chat({
      messages,
      tools: tools.map(t => ({
        type: "function",
        function: { name: t.name, description: t.description, parameters: t.parameters }
      })),
    });

    const choice = response.choices[0];

    // If the model wants to call a tool
    if (choice.finish_reason === "tool_calls") {
      for (const toolCall of choice.message.tool_calls) {
        const tool = tools.find(t => t.name === toolCall.function.name);
        const args = JSON.parse(toolCall.function.arguments);

        console.log(`🔧 Using tool: ${tool.name}`, args);
        const result = await tool.execute(args);

        messages.push(choice.message);  // assistant's tool call
        messages.push({
          role: "tool",
          tool_call_id: toolCall.id,
          content: String(result)
        });
      }
    } else {
      // Agent is done — return final answer
      return choice.message.content;
    }
  }
  return "Max steps reached.";
}

Agent Memory

💬 Short-term Memory

The conversation history / context window. Limited by the LLM's token limit (4K–200K tokens). Recent interactions guide next actions.

🗄️ Long-term Memory

External storage (vector databases, key-value stores). Agents can save and retrieve information across sessions using embeddings + similarity search.

Multi-Agent Systems

Complex tasks benefit from multiple specialized agents collaborating:

👨‍💼

Orchestrator Agent: Breaks the task into subtasks, assigns them to specialists, aggregates results.

🔍

Research Agent: Searches the web, reads documents, gathers information.

💻

Coding Agent: Writes, reviews, and debugs code. Runs tests.

✅

Critic Agent: Reviews outputs for quality, accuracy, and completeness.

Frameworks: LangGraph, CrewAI, AutoGen, Swarm

Agent Safety & Guardrails

🛡️ Sandboxing: Run code execution in isolated containers, never on the host machine
🔒 Permissions: Limit tool access — an agent shouldn't be able to delete production databases
⏱️ Rate limiting: Cap API calls and execution time to prevent runaway costs
👁️ Human-in-the-loop: Require approval for high-impact actions (payments, deployments)
📝 Audit logging: Record every tool call, input, and output for debugging and compliance

🔑 Key Takeaways

• Agents = LLM + Tools + Memory + Planning loop
• The ReAct pattern (Reason → Act → Observe) is the most common architecture
• Tool use / function calling lets agents interact with external systems
• Multi-agent systems divide complex tasks among specialized agents
• Always implement guardrails: sandboxing, permissions, human-in-the-loop