AI Agent Frameworks

AI agent frameworks are tools and platforms that help developers build intelligent agents capable of performing tasks autonomously, making decisions and interacting with users or systems. These frameworks simplify the development of agent‑based applications by providing components for reasoning, memory and tool integration.

1. LangGraph

LangGraph is a framework used to build advanced AI agents that handle complex, stateful workflows. It uses graph-based execution, enabling step-by-step and branching logic for better control over agent behavior.

• Workflow Control: Design step-by-step and branching workflows, supporting multi-agent and sequential execution.
• Statefulness: Maintains state across steps, allowing agents to track progress and continue tasks smoothly.
• Adaptive RAG: Enables context-aware reasoning by integrating retrieval into workflows.
• Extensible Design: Easily integrates with LLMs, tools and external systems for custom workflows.

Use Case: Automating support ticket where agent receives input, gathers context and autonomously routes and resolves queries, escalating only when necessary.

Implementation:

This example shows how to build a simple LangGraph workflow using LangChain and an LLM to generate a motivational quote.

• Install Packages: Install LangGraph and LangChain libraries.
• Define Function: Create a function using GPT-4o-mini to generate a motivational quote.
• Create Graph: Build a StateGraph with a single node calling the function.
• Set Flow: Use the same node as both the start and end point.
• Run Graph: Compile and execute the graph to get the output.

!pip install -q langgraph langchain langchain-openai

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph

def ask_question(state):
    llm = ChatOpenAI(model="gpt-4o-mini",
    api_key="your_api_key_here")
    response = llm.invoke("Give me one motivational quote.")
    return {"output": response.content}

graph = StateGraph(dict)
graph.add_node("ask", ask_question)
graph.set_entry_point("ask")
graph.set_finish_point("ask")

app = graph.compile()
result = app.invoke({})
print(result["output"])

Output:

2. AutoGen

AutoGen is a Microsoft-backed framework for building multi-agent systems where AI agents collaborate with each other and humans to automate complex tasks through dynamic conversations.

• Multi-Agent Conversations: Enables agents to interact autonomously or with human input for collaboration, debate and problem solving.
• Role-Based Agents: Agents can be assigned specific roles, personas and responsibilities.
• Flexible Interaction Flow: Supports both fully automated and human-in-the-loop workflows.
• Task-Oriented Collaboration: Agents coordinate to break down and solve complex tasks step-by-step.

Use Case: AI agents automatically research and draft a technical report with one gathering data, another summarizing and a human reviewer finalizing the content for accuracy and clarity.

Implementation:

This example shows how to create a simple multi agent interaction using AutoGen with an assistant and a user agent.

• Install Package: Install AutoGen from GitHub.
• Load API Key: Set up your OpenAI API key for access.
• Create Assistant: Define an AssistantAgent using GPT-3.5-turbo.
• Create User Agent: Define a UserProxyAgent with no human input.
• Start Chat: Initiate a conversation with a starting message and limit it to 2 turns.

!pip install git+https://github.com/microsoft/autogen.git@v0.2.25

from autogen import AssistantAgent, UserProxyAgent
import autogen
import os
os.environ["OPENAI_API_KEY"] = "your_api_key"

config_list = [
    {
        "model": "gpt-3.5-turbo",
        "api_key": os.environ["OPENAI_API_KEY"],
    },
]

assistant = AssistantAgent(name="assistant", llm_config={
                           "config_list": config_list})
user_proxy = UserProxyAgent(name="user_proxy", human_input_mode="NEVER")

user_proxy.initiate_chat(
    assistant,
    message="Say 'Hello, world!' and tell me the meaning of life.",
    max_turns=2,
)

Output:

3. CrewAI

CrewAI is an open-source framework for building teams of AI agents that collaborate with defined roles to solve complex, multi-step tasks such as research, content creation and business workflows.

• Role-Based Agents: Agents are assigned roles, goals and backstories for specialized behavior.
• Task Coordination: Tasks are defined and distributed among agents for efficient execution.
• Collaborative Execution: Multiple agents work together, optionally with human input, to complete complex workflows.

Use Case: Multi-agent systems for generating, vetting and publishing marketing content one agent drafts, another edits, a third handles distribution.

Implementation:

Let's see a code example to understand better:

• Import Libraries: Import Crew, Agent and Task and check for the API key.
• Create Agents: Define agents like Python Assistant and Philosopher with roles and backstories.
• Define Tasks: Assign tasks such as printing “Hello, world!” and explaining the meaning of life.
• Build Crew: Create a Crew using the defined agents and tasks.
• Execute Tasks: Run the crew to perform tasks in parallel and get results.

!pip install crewai openai litellm
import os
from crewai import Crew, Agent, Task

os.environ["OPENAI_API_KEY"] = "your_api_key"

assistant = Agent(
    role="Python Assistant",
    goal="Print 'Hello, world!' in Python.",
    backstory="You help users write and run basic Python code.",
    verbose=True
)

philosopher = Agent(
    role="Philosopher",
    goal="Share the meaning of life from literature.",
    backstory="You are inspired by 'The Hitchhiker's Guide to the Galaxy'.",
    verbose=True
)

task1 = Task(
    description="Print 'Hello, world!' in Python.",
    agent=assistant,
    expected_output="Hello, world!"
)

task2 = Task(
    description="Tell me the meaning of life according to popular culture.",
    agent=philosopher,
    expected_output="42"
)

crew = Crew(
    agents=[assistant, philosopher],
    tasks=[task1, task2],
    verbose=True
)

result = crew.kickoff()
print(result)

Output:

4. Semantic Kernel

Semantic Kernel is an open-source SDK by Microsoft that integrates large language models into existing applications, enabling structured orchestration of AI, code and external services.

• AI + Code Integration: Combines traditional programming logic with LLM capabilities.
• Orchestration Engine: Coordinates tasks across AI models, APIs and business logic.
• Plugin-Based Architecture: Supports extensible functions and connectors for real-world applications.
• Enterprise Focus: Designed for scalable, secure and production-ready systems.

Use Case: AI automatically summarizes customer feedback, integrates with business tools and alerts human staff for key issues, all in one workflow.

Implementation:

Let's see a code example to understand better:

• Install Package: Install Semantic Kernel (version 1.35.3).
• Load API Key: Get the OpenAI API key from environment or Colab secrets.
• Utility Function: Define a function to format output (e.g., word wrap).
• Setup Kernel: Create a Kernel instance and configure the chat completion model.
• Connect Service: Attach the LLM client to the Kernel.
• Run Prompt: Send a prompt (e.g., generate a poem) to the model.

import os
from google.colab import userdata
import textwrap
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

os.environ["OPENAI_API_KEY"] = "your_api_key"

def wrap_text(text, width=70):
    return "\n".join(textwrap.wrap(text, width))

async def main():
    kernel = sk.Kernel()

    openai_client = OpenAIChatCompletion(
        ai_model_id="gpt-3.5-turbo",
        api_key=os.environ["OPENAI_API_KEY"]
    )

    kernel.add_service(openai_client)
    kernel.select_ai_service(openai_client.service_id)

    prompt_text = "Tell me about Semantic Kernel."

    result = await kernel.invoke_prompt(prompt_text)

    if hasattr(result, "get_response"):
        output_text = result.get_response()
    elif hasattr(result, "content"):
        output_text = result.content
    else:
        output_text = str(result)

    print(wrap_text(output_text))

await main()

Output:

5. LangChain

LangChain is an open source framework that simplifies building applications using large language models by connecting prompts, data, memory and tools into structured workflows.

• Tool Integration: Connects with APIs, databases and search engines to enhance capabilities.
• Human-in-the-Loop: Supports workflows with human review and intervention.
• Agent Workflows: Enables creation of agents that can think, act and collaborate.
• LLM Integration: Works with models like OpenAI, Anthropic and Hugging Face.
• Memory and Context: Maintains conversation history for better and personalized responses.

Use Case: An AI customer support agent uses LangChain to fetch FAQs from a database, answer user queries with an LLM, log interactions for future context and escalate unresolved issues to a human agent, all in a single automated workflow.

Implementation:

Let's see a code example to understand better,

• Load API Key: Get the OpenAI API key from environment or Colab secrets.
• Install Packages: Install required LangChain libraries.
• Define Model: Initialize the LLM (e.g., GPT-4o-mini) with zero temperature.
• Create Prompt: Define a prompt template (e.g., ask for a fun fact).
• Build Chain: Combine prompt, model and output parser into a chain.
• Run Chain: Execute the chain with input like “cats” to generate a response.

!pip install -q langchain langchain-openai langchain-community openai

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
prompt = PromptTemplate.from_template("What is a fun fact about {topic}?")
chain = prompt | llm | StrOutputParser()

result = chain.invoke({"topic": "cats"})
print(result)

Output:

6. No-Code AI Agent Platforms

No-code and visual AI platforms allow users to build AI agents and workflows using simple drag and drop interfaces, making development faster and accessible without coding.

1. n8n

n8n is a workflow automation tool that combines AI with app integrations using a visual interface.

• Workflow Automation: Build AI workflows by connecting apps like Notion, Stripe and Google Sheets.
• Trigger-Based Flows: Start workflows using events like webhooks, messages or custom triggers.
• Business Use Cases: Automate tasks like CRM updates, lead management and communication.

For its implementation you can refer to n8n project: Automated Email Classifier Project in n8n.

2. Langflow

Langflow is a visual, drag and drop framework for building and testing AI workflows, including multi agent systems and RAG based applications.

• Multi Agent and RAG Support: Enables building complex workflows with multiple agents and knowledge based retrieval.
• Model Flexibility: Works with various LLMs and vector databases, including open source options.
• Fast Prototyping: Allows quick testing, iteration and deployment of workflows.
• Easy Integration: Flows can be shared, embedded or connected via APIs.

Choosing the Right Framework

1. Task Complexity

• LangGraph and CrewAI are best for multi step, stateful workflows.
• LangChain works well for modular, LLM based tasks like Q/A and RAG.
• AutoGen is ideal for dynamic multi agent conversations and collaboration.

2. Integration Needs

• Langflow and n8n are great for no code, visual workflows and quick integrations.
• Semantic Kernel is better for deep integration into applications using code.

3. Customizability and Scalability

• Semantic Kernel, LangGraph and AutoGen are all built for enterprise scale extensibility, offering modular plugins, agent frameworks and support for advanced orchestration.
• CrewAI is particularly suited for collaborative multi agent teams in specialized roles, ideal for automating business processes that benefit from teamwork.

4. Privacy and Data Security

• Semantic Kernel and LangGraph are strong for secure and compliant systems.
• AutoGen and CrewAI require careful design for secure communication.
• Langflow and n8n are convenient but need validation for secure integrations.