AI Agents: The Future of Generative AI

2024 will be the year of AI agents. So, what are AI agents? To explain this, we need to look at the various shifts in generative AI.

Compound AI

One significant shift is moving from monolithic models to compound AI systems. Monolithic models are limited by the data they've been trained on, affecting their knowledge and task-solving capabilities. They are also hard to adapt, requiring significant investment in data and resources.

Example

Consider planning a vacation. You want to know your available vacation days. A simple model cannot access your data to give an accurate answer. However, a compound AI system can. By integrating the model with a database containing your vacation data, the model generates a search query, fetches the data, and provides an accurate response.

System Approach

Compound AI systems are modular. You can combine various models (e.g., language models, and image generation models) with programmatic components. This approach makes solving complex problems easier and faster than tuning a single model. For instance, Retrieval Augmented Generation (RAG) systems combine search capabilities with language models to enhance performance.

Agents

Where do agents come in? By putting a large language model in charge of controlling the logic of a compound AI system, agents can reason and act based on complex problems. This agentic approach leverages the model's reasoning capabilities to plan, act, and adjust based on feedback, making the system more flexible and efficient.

Understanding AI Agents

1. Simple Reflex Agents: These agents operate based on predefined rules. They respond directly to percepts without any internal state.
2. Model-Based Reflex Agents: These agents maintain an internal model of the world to handle partially observable environments.
3. Goal-Based Agents: These agents take actions to achieve specific goals. They plan their actions based on a goal-oriented approach.
4. Utility-Based Agents: These agents maximize a utility function, allowing them to handle conflicting goals and uncertainties.
5. Learning Agents: These agents improve their performance based on past experiences, continually learning and adapting to their environment.

Components of an AI Agent

• Perception: Sensing the environment.
• Decision Making: Choosing an action based on the perception.
• Action: Executing the chosen action.
• Learning: Improving performance over time through experience.

Practical Coding Example

To illustrate the concept of AI agents, we’ll implement a simple AI agent using Python. This agent will be a basic reflex agent that navigates a grid environment.

First, let's define a simple grid environment. We will use a 5x5 grid where the agent starts at the top-left corner and aims to reach the bottom-right corner.

import numpy as np

class GridEnvironment:
    def __init__(self, size=5):
        self.size = size
        self.grid = np.zeros((size, size))
        self.agent_position = [0, 0]
    
    def is_done(self):
        return self.agent_position == [self.size-1, self.size-1]
    
    def reset(self):
        self.agent_position = [0, 0]
        return self.agent_position
    
    def step(self, action):
        if action == "up" and self.agent_position[0] > 0:
            self.agent_position[0] -= 1
        elif action == "down" and self.agent_position[0] < self.size-1:
            self.agent_position[0] += 1
        elif action == "left" and self.agent_position[1] > 0:
            self.agent_position[1] -= 1
        elif action == "right" and self.agent_position[1] < self.size-1:
            self.agent_position[1] += 1
        
        return self.agent_position, self.is_done()

env = GridEnvironment()
print("Initial State:", env.reset())
        

Defining the Simple Reflex Agent

Next, we’ll define a simple reflex agent that can navigate the grid. The agent will follow a set of predefined rules to move toward the goal.

class SimpleReflexAgent:
    def __init__(self):
        pass
    
    def choose_action(self, position):
        if position[0] < env.size - 1:
            return "down"
        elif position[1] < env.size - 1:
            return "right"
        else:
            return "done"

agent = SimpleReflexAgent()

# Run the agent in the environment
state = env.reset()
while not env.is_done():
    action = agent.choose_action(state)
    state, done = env.step(action)
    print(f"Action: {action}, New State: {state}")

print("Goal Reached!")
        

Let's explore a more complex real world scenario

Asking an LLM to "Plan a week-long family vacation to India for 2 adults and 2 toddlers under $8000, including flights, hotels, visits to the Taj Mahal, and a few kid-friendly places," may yield a decent itinerary. However, it is unlikely to meet all constraints and preferences in the first iteration comprehensively.

In this scenario, an AI agent would:

1. Gather Requirements: Understand the budget, number of travelers, and preferences for flights, hotels, and activities.
2. Query Data Sources: Access flight databases, hotel booking platforms, and activity listings.
3. Generate Options: Create an initial plan with multiple options for each component.
4. Iterate Based on Feedback: Adjust the plan based on user feedback and constraints, refining it until it meets all requirements.

class VacationPlannerAgent:
    def __init__(self, budget, travelers, duration):
        self.budget = budget
        self.travelers = travelers
        self.duration = duration
        self.itinerary = []

    def plan_vacation(self):
        # Step 1: Gather requirements (already done via initialization)
        
        # Step 2: Query data sources (mocking data retrieval here)
        flights = self.get_flights()
        hotels = self.get_hotels()
        activities = self.get_activities()
        
        # Step 3: Generate options
        self.itinerary.append(flights)
        self.itinerary.append(hotels)
        self.itinerary.append(activities)
        
        # Step 4: Iterate based on feedback (mocking iteration)
        self.refine_plan()

        return self.itinerary

    def get_flights(self):
        # Mocking a flight retrieval
        return "Flights: Round trip tickets from your city to India"

    def get_hotels(self):
        # Mocking hotel retrieval
        return "Hotels: 5-night stay at a family-friendly hotel"

    def get_activities(self):
        # Mocking activity retrieval
        return "Activities: Taj-mahal,Zoo visit, museum tour, and park outings"

    def refine_plan(self):
        # Mocking plan refinement
        self.itinerary[0] = "Flights: Updated round trip tickets to delhi considering preferred times"
        self.itinerary[1] = "Hotels: Updated to a hotel with a kids' pool"

# Initialize the agent and plan the vacation
agent = VacationPlannerAgent(budget=8000, travelers=["2 adults", "1 toddler"], duration=7)
itinerary = agent.plan_vacation()
print(itinerary)
        

Conclusion

AI agents are transforming industries by automating tasks, improving customer interactions, and advancing decision-making processes. Understanding their capabilities and challenges is crucial for leveraging their full potential.