ai-agents skill

---
name: AI Agents
description: Autonomous systems that use language models to perform tasks, make decisions, and interact with users or other systems using ReAct patterns, tool calling and memory systems.
---

# AI Agents

## Overview

AI agents are autonomous systems that use language models to perform tasks, make decisions, and interact with users or other systems. They combine reasoning (thinking) with action (doing) in iterative loops, enabling them to solve complex problems by breaking them down into smaller steps, using tools, and learning from feedback.

## Why This Matters

- **Reduces Downtime**: AI agents provide 24/7 automated responses, reducing system downtime
- **Reduces Manual Effort**: Automates repetitive tasks, freeing human time for complex work
- **Increases Gross Margin**: Automated workflows reduce operational costs
- **Consistent Quality**: Agents follow defined processes consistently
- **Scalability**: Can handle many simultaneous requests without degradation

---

## Core Concepts

### 1. ReAct Pattern (Reason + Act)

Core agent loop pattern:

- **Thought**: Agent thinks about what to do next
- **Action**: Agent executes action based on thought
- **Observation**: Agent observes result of action
- **Loop**: Repeat until goal achieved or max iterations reached

### 2. Tool Calling

Agents can use external tools:

- **API Calls**: Query external APIs for information
- **Database Queries**: Read and write to databases
- **File Operations**: Read, write, create, delete files
- **Code Execution**: Run code to perform computations
- **Web Browsing**: Search and read web pages

### 3. Memory Systems

Agent memory for context retention:

- **Short-Term Memory**: Conversation buffer, recent interactions
- **Long-Term Memory**: Vector store for persistent knowledge
- **Hybrid**: Combines both for optimal performance

### 4. Agent Architecture

Components of an AI agent system:

- **LLM Integration**: Language model for reasoning (GPT-4, Claude, etc.)
- **Tool Registry**: List of available tools and their schemas
- **Memory System**: Storage and retrieval of information
- **Agent Executor**: Controls execution loop and iteration limits
- **State Management**: Tracks agent state and conversation context
- **Observability**: Logging, monitoring, tracing for debugging

## Quick Start

1. **Choose LLM**: Select model based on requirements (GPT-4, Claude, etc.)
2. **Define Tools**: Create tools for agent to use (APIs, databases, file ops)
3. **Design Memory**: Choose memory architecture (token-based, vector-based, hybrid)
4. **Implement Agent**: Build agent using LangChain or custom framework
5. **Define Prompt**: Create system prompt with agent personality and constraints
6. **Test Agent**: Test with various scenarios and edge cases
7. **Deploy**: Deploy with monitoring and error handling
8. **Monitor**: Track agent performance, errors, and user satisfaction

```typescript
// Basic agent structure
import { OpenAI } from 'openai';
import { Tool } from './tools';

class Agent {
  private llm: OpenAI;
  private tools: Map<string, Tool>;
  private maxIterations: number = 10;

  constructor(llm: OpenAI, tools: Tool[]) {
    this.llm = llm;
    this.tools = new Map(tools.map(t => [t.name, t]));
  }

  async run(goal: string): Promise<string> {
    let observations = goal;
    let iterations = 0;

    while (iterations < this.maxIterations) {
      // Thought
      const thought = await this.think(observations);
      console.log(`Thought ${iterations}:`, thought);

      // Action
      const action = await this.decideAction(thought, observations);
      console.log(`Action ${iterations}:`, action);

      if (action.type === 'FINAL_ANSWER') {
        return action.content;
      }

      // Execute tool
      const tool = this.tools.get(action.toolName);
      if (!tool) {
        throw new Error(`Tool not found: ${action.toolName}`);
      }

      const result = await tool.execute(action.input);
      observations = `Tool ${action.toolName} returned: ${result}`;
      iterations++;
    }

    return `Max iterations (${this.maxIterations}) reached`;
  }

  private async think(observations: string): Promise<string> {
    const response = await this.llm.chat.completions.create({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: 'You are a helpful assistant. Think step by step.' },
        { role: 'user', content: `Observations: ${observations}\n\nWhat should I do next?` }
      ],
    });
    return response.choices[0].message.content || '';
  }

  private async decideAction(thought: string, observations: string): Promise<any> {
    // Parse thought into structured action
    // This would use more sophisticated parsing in production
    const actionRegex = /Action: (.+)/;
    const match = thought.match(actionRegex);
    return match ? JSON.parse(match[1]) : { type: 'FINAL_ANSWER', content: thought };
  }
}
```

## Production Checklist

- [ ] LLM configured with appropriate model and parameters
- [ ] Tools defined with clear schemas and error handling
- [ ] Memory system implemented and tested
- [ ] Agent executor with iteration limits and timeout handling
- [ ] State management for conversation context
- [ ] Logging and monitoring configured
- [ ] Error handling and fallbacks in place
- [ ] Tool execution safety measures (input validation, output sanitization)
- [ ] Rate limiting implemented to prevent abuse
- [ ] Cost tracking for LLM usage
- [ ] Testing completed with various scenarios
- [ ] Documentation complete
- [ ] Deployment pipeline configured

## Anti-patterns

1. **No Tool Validation**: Allowing arbitrary tool execution is dangerous
2. **Infinite Loops**: No iteration limits cause runaway execution
3. **Missing Error Handling**: Unhandled errors crash the agent
4. **Poor Tool Design**: Tools with unclear interfaces are hard to use
5. **No Memory**: Agents forget important context without memory systems
6. **Over-Relying on LLM**: LLMs can hallucinate; need verification
7. **Ignoring Cost**: Unlimited LLM calls can become very expensive
8. **No Observability**: Without logs, debugging is impossible

## Integration Points

- **LLM Providers**: OpenAI, Anthropic, Google, for language models
- **Tool Frameworks**: LangChain, LangGraph for agent orchestration
- **Memory Systems**: Pinecone, Weaviate, Chroma for vector storage
- **Monitoring**: LangSmith, custom dashboards for agent tracking

## Further Reading

- [LangChain Documentation](https://python.langchain.com/)
- [ReAct Paper](https://arxiv.org/abs/2210.03629)
- [Agent Design Patterns](https://lilianweng.github.io/posts/2023-06-23-agent/)
- [OpenAI Function Calling](https://platform.openai.com/docs/guides/function-calling)