The AI Agents Part 1: A Starter's Technical Guide

You don't even have to look around. AI Agent guides are everywhere! So, let me take the initiative to make mine unique with the simplest possible explanations, and simplest possible hands-on code samples, while still demystifying the key aspects.

Intelligence Agents are transforming enterprise workflows by autonomously executing tasks, making decisions, and dynamically interacting with systems. This guide explores what AI agents are, their key types, and practical use cases.

AI agents leverage large language models (LLMs) to perform complex decision-making tasks with minimal human intervention. Unlike simple automation scripts, AI agents are context-aware, adaptive, and capable of reasoning through multi-step workflows.

What is Agentic AI?

AI systems that can make decisions and take actions independently and work together to achieve complex goals unlike the reactive LLMs that stop after each output. The agents possess the ability to learn, adapt, and engage with their surroundings, reflecting intelligent behavior.

Key Characteristics

1.Autonomy (unlike waiting for next step)

2.Final Goal Oriented Behavior (unlike one-step answers)

3.Interacting With Environment (unlike just Q&A behavior)

4.Reasoning and Planning - abilities to self-organize the steps and build a plan

5.Learning and Adapting (Memory)

When to Use AI Agents

AI agents work best in situations that require handling complex tasks at scale, especially where constant attention and quick responses are needed. The table shows five key areas where they excel:

In customer support, they handle routine questions efficiently while human staff focus on complex issues. For research and data analysis, they quickly process huge datasets to find patterns. In financial trading, they make rapid decisions based on market changes. In education, they provide personalized learning experiences tailored to each student. And in software development, they speed up coding and testing while improving over time.

The key is to use AI agents when you need to combine speed, scale, and consistency in ways that would be challenging for humans alone.

In summary, AI agents are best suited for:

• Handling multi-step decision-making processes
• Automating complex workflows with changing variables
• Enhancing user experiences through personalized interactions

Let me draw an analogy. Use Agents roughly whenever you'd use a Micro-Service or a RESTful API endpoint. Notice and enjoy that the complexity of RESTful API requests - the payload, the type of requests (mostly think GET type), the header, the return code, error code, the status, the syntax, the security-semantics, the client-complexities .... are all replaced with simple English prompt sentences going to the LLM of your Agent.

When Not to Use AI Agents

AI agents are powerful tools, but they aren't always the right choice. Think of them like specialized equipment – you wouldn't use heavy machinery to water a small garden. The main situations where you should reconsider using AI agents include:

First, when dealing with simple or infrequent tasks. If you're handling straightforward processes that existing software can manage well, adding AI agents would be like using a sledgehammer to hang a picture – unnecessarily complex and costly.

Second, for tasks requiring deep human expertise. Fields like law, medicine, or high-stakes decision-making need the nuanced understanding that comes from years of professional experience. Similarly, areas like therapy, counseling, and creative writing depend heavily on human emotional intelligence and creativity – qualities that AI agents haven't mastered.

Third, when resource constraints are significant. Implementing AI agents requires substantial investment in time, money, and expertise. For small businesses or budget-conscious projects, this investment might not make economic sense. This is especially true in heavily regulated industries, where ensuring AI agents comply with complex regulations can become a resource-intensive challenge.

In essence, before deploying AI agents, carefully consider whether the complexity and cost they bring align with your actual needs and available resources.I

In summary, avoid AI agents when:

• Tasks are simple, rule-based, and infrequent
• The domain requires deep human expertise and intuition
• High regulatory and compliance risks limit automation

Types of AI Agents

1. Fixed Automation Agents

• Characteristics: Rule-based, predictable behavior
• Best Use Cases: Repetitive tasks (e.g., RPA, email autoresponders)
• Details: This [low] level of AI agents represents the simplest and rigid form of automation. These agents don’t adapt or think — they just execute pre-programmed instructions: efficient but inflexible, great for repetitive tasks, but not thinking brains at all. Perhaps just python programs with no LLMs - per me, not worthy of the name agents!
• Example:

class FixedAutomationAgent:
    def __init__(self):
        self.rules = {
            "Invoice": "Process Payment",
            "Support Ticket": "Create Ticket",
            "Feedback": "Store Feedback"
        }
    
    def process_input(self, input_data):
        return self.rules.get(input_data, "Ignore")

agent = FixedAutomationAgent()
print(agent.process_input("Invoice"))  # Output: Process Payment        

class FixedAutomationAgent:
    def __init__(self):
        self.rules = {
            "Invoice": "Process Payment",
            "Support Ticket": "Create Ticket",
            "Feedback": "Store Feedback"
        }
    
    def process_input(self, input_data):
        return self.rules.get(input_data, "Ignore")

agent = FixedAutomationAgent()
print(agent.process_input("Invoice"))  # Output: Process Payment        

2. ReAct (Reasoning + Acting) Agents

• Characteristics: Break down tasks, dynamic planning
• Best Use Cases: AI-powered customer service, strategic planning
• Details: Makes informed decisions grounded in accurate, domain-specific data, using RAG, making them ideal for high-stakes or precision-critical tasks (especially when you add evaluations). These agents are your ultimate trivia masters with Google search access.
• Example:

from langchain.chains import ReActChain
from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-4")
agent = ReActChain(llm=llm)

query = "How can I optimize my sales strategy?"
response = agent.run(query)
print(response)        

3. Tool-Enhanced Agents

• Characteristics: Multi-tool integration, real-time API calls
• Best Use Cases: Code generation, data analysis
• Details: Tool-enhanced agents are versatile, integrate multiple tools, leveraging APIs, databases, and software to handle complex, multi-domain workflows. They combine reasoning, retrieval, and execution for seamless, dynamic task completion - capable of combining reasoning, retrieval, and execution seamlessly!
• Example:

from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-4")
tools = [
    Tool(name="web_search", func=lambda q: f"Searching web for {q}", description="Web search tool")
]

agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
print(agent.run("Find latest AI trends"))        

Choosing the Right Framework

1. LangGraph

• Best for: Graph-based workflows, memory management
• Strengths: Supports DAG-based agent workflows, structured output
• Details: (If I had a favorite!) LangGraph is an open-source framework designed by Langchain to build stateful, multi-actor applications using LLMs. Inspired by the long history of representing data processing pipelines as directed acyclic graphs (DAGs), LangGraph treats workflows as graphs where each node represents a specific task or function.
• This graph-based approach allows for fine-grained control over the flow and state of applications, making it particularly suitable for complex workflows that require advanced memory features, error recovery, and human-in-the-loop interactions. LangGraph integrates seamlessly with LangChain, providing access to various tools and models and supporting various multi-agent interaction patterns.
• Example:

from langgraph.graph import StateGraph

def process_data(data):
    return f"Processed {data}"

def make_decision(processed_data):
    return f"Decision based on {processed_data}"

workflow = StateGraph()
workflow.add_node("data_processing", process_data)
workflow.add_node("decision_making", make_decision)
workflow.add_edge("data_processing", "decision_making")

result = workflow.execute("User Input")
print(result)        

2. AutoGen

• Best for: Conversational AI, dynamic interactions
• Strengths: Multi-agent collaboration, tool execution
• Details: Autogen supports various tools, including code executors and function callers, allowing agents to perform complex tasks autonomously. The highly customizable framework allows you to extend agents with additional components and define custom workflows. Autogen is designed to be modular and easy to maintain, making it suitable for both simple and complex multi-agent scenarios.
• Example:

from autogen import AssistantAgent, UserProxyAgent

config_list = [{"model": "gpt-4"}]
user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding"})
assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
user_proxy.initiate_chat(assistant, message="Analyze market trends for AI adoption")        

3. CrewAI

• Best for: Multi-agent collaboration, role-based execution
• Strengths: Task delegation, role specialization
• Details: Crew AI has "Agents" and "Tasks" that are lists being sent into it's constructor. You specify the LLM of your choice that needs to behave like your agent, and for every agent you define, and off you go. Again, the complexity of RESTful APIs is replaced with English sentences!
• Example:

from crewai import Crew, Agent, Task

manager = Agent(role="Project Manager", llm_config={"model": "gpt-4"})
developer = Agent(role="Software Engineer", llm_config={"model": "gpt-4"})
tester = Agent(role="QA Engineer", llm_config={"model": "gpt-4"})

task_dev = Task(description="Develop AI chatbot", agent=developer)
task_test = Task(description="Test AI chatbot", agent=tester)

crew = Crew(agents=[manager, developer, tester], tasks=[task_dev, task_test])
crew.kickoff()        

Conclusion

Selecting the right AI agent framework depends on the complexity of the workflow, the need for multi-agent collaboration, and scalability requirements. Evaluation metrics and debugging tools ensure robust and reliable AI agent deployment.

These technical guides should provide a solid foundation for AI professionals looking to understand, build, and evaluate AI agents effectively.

Disclaimer: Use of AI to generate the art work for the article. All views in my writeups are mine.