AI Agent Frameworks

AI agents have become the backbone of complex task automation, decision-making and workflow management across industries. These frameworks helps developers and businesses to build intelligent agents that operate autonomously, coordinate tasks and integrate with a wide range of tools and platforms. In this article we will see different AI Agent Frameworks to make our own agents.

1. LangGraph

LangGraph is designed for building and managing advanced autonomous agents capable of handling independent workflows. Its architecture is inspired by directed acyclic graphs (DAGs) which helps in the execution of complex, branching processes such as starting a chatbot session, continuing the conversation and ending it upon achieving goals.

Features:

• Smaller Workflow Control: Allows developers to design agent flows at small steps, supporting multi-agent, hierarchical and sequential processes.
• Statefulness: Lets agents remember details from past steps so they can pick up where they left off which also makes it easier to trace and fix problems in their workflows.
• Adaptive Retrieval-Augmented Generation (RAG): It supports advanced knowledge-augmented reasoning, letting agents execute adaptive tasks with minimal human input.
• Integration Ready: Easily connects with various LLMs, vector databases, monitoring, debugging and human-in-the-loop controls.

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

Code:

Let see a code example to understand better, the working of code is explained below:

• Installs Langgraph and Langchain packages
• Defines a function using Langchain's GPT-4o-mini LLM to get a motivational quote
• Creates a Langgraph StateGraph with a single node calling the function
• Sets the node as both entry and finish point in the graph
• Compiles and invokes the graph, printing the motivational quote

!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")
    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 multi-agent framework designed for enabling rich, dynamic conversations and automation workflows among AI agents, humans and tools. It emphasizes flexibility, configurability and seamless integration with both large language models (LLMs) and external APIs.

Features:

• Customizable agents: Agents can be defined roles, personas and capabilities.
• Dynamic multi-agent conversations: Agents interact autonomously or with human input for collaboration, debate and problem-solving.
• Tool integration: Connect to APIs, development tools and LLMs for data fetching, code execution and third-party interactions.
• Human oversight: Seamlessly blend automated and manual workflows for complex decisions.
• Conversation history & state: Agents maintain context across interactions for continuity and relevance.

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.

Code:

Let's see a code example to understand it better,

• Installs Autogen package from GitHub
• Loads OpenAI API key
• Creates an AssistantAgent configured with GPT-3.5-turbo model and OpenAI key
• Creates a UserProxyAgent with no human input
• Initiates a chat from user to assistant with a starting message and limits turns to 2

!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 that lets developers create and manage teams of specialized AI agents. These agents collaborate, each handling a distinct role, to automate and streamline complex, multi-step workflows such as research, content creation and business processes

Features:

• Specialized Roles: Agents are defined with roles, goals, backstories and tools enabling tailored decision-making.
• Task Kickoff and Coordination: Define a crew of agents, set tasks and let the crew autonomously commence and optimize processes.
• Human-AI and Multi-Agent Collaboration: Ideal for projects where seamless cooperation between autonomous agents and/or humans is required (e.g., research, fraud detection, content creation).

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

Code:

Let's see a code example to understand better,

• Imports Crew, Agent and Task classes and then checks for OpenAI API key
• Defines two agents: Python Assistant and Philosopher with roles and backstories
• Defines two tasks: Python assistant prints "Hello, world!"; Philosopher shares meaning of life as "42"
• Creates a Crew with the agents and tasks defined
• Starts execution of tasks in parallel and collects 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, lightweight Microsoft SDK that lets developers add advanced AI features such as natural language understanding and generation, to applications written in C#, Python or Java. It connects our existing code and business logic to the latest large language models and is built for enterprise-scale, responsible AI adoption. 

Features:

• Agent Framework: Build autonomous or semi-autonomous agents that collaborate, process information and trigger actions using LLMs, APIs or human input.
• Orchestration Engine: Seamlessly sequence and coordinate tasks across AI, systems and human reviewers for end-to-end automation.
• Context and Memory: Maintain conversation history and app state across interactions, enabling personalized, multi-turn experiences.
• Human-in-the-Loop: Insert human approval or refinement steps into automated workflows for oversight and exception handling.

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

Code:

Let's see a code example to understand better,

• Installs Semantic Kernel version 1.35.3
• Loads OpenAI API key from Colab secrets
• Defines a wrap_text function to word-wrap output at 70 characters
• Asynchronously creates a Kernel instance and OpenAIChatCompletion client with GPT-3.5-turbo model
• Sets the Kernel’s private chat service to the client
• Calls chat_complete_async with a prompt to write a short poem about Semantic Kernel
• Prints the word-wrapped result

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 designed to streamline the development of applications powered by large language models (LLMs). It excels at chaining together modular components such as prompts, data loaders, memory and external tools enabling developers to build, customize and deploy context-aware AI workflows with ease.

Features:

• Tool Integration: Call external APIs, search engines and databases to augment LLM capabilities.
• Human-in-the-Loop: Design workflows for human review, approval or intervention where needed.
• Multi-Agent & Agentic Workflows: Support for creating agents that communicate, reason and act either independently or together.
• Integration with LLMs: Seamlessly connect to OpenAI, Anthropic, Hugging Face and other leading LLMs.
• Memory & Context: Maintain state and conversation history across interactions for personalized, multi-step experiences.

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.

Code:

Let's see a code example to understand better,

• Loads OpenAI API key from Colab secrets
• Installs necessary Langchain packages
• Defines an LLM with GPT-4o-mini model at zero temperature
• Creates a prompt template asking for a fun fact about a topic
• Chains prompt generation, LLM call and string output parsing
• Invokes chain with topic "cats" to generate a fact

!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 and Visual AI Agent Platforms

For business users, domain experts or fast prototyping, visual and no-code AI agent builders provide drag-and-drop simplicity.

1. n8n: Visual Agent Development Platform

• Workflow Automation Plus AI: n8n Enables users to construct AI workflows integrating 400+ apps like Notion, Stripe, Google Sheets, etc with LLMs and toolchains all via a graphical interface.
• Trigger-Based Flows: Agents can be initiated by webhook, chat message or custom event and use built-in nodes for data handling, communication and logic.
• Sales, Marketing, Support: Automate CRM updates, lead scoring, schedule communications or orchestrate sales pipelines without code.

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

2.  Langflow: Modular Drag-and-Drop Framework

• Multi-Agent and RAG Support: Designed for visually constructing complex agentic workflows including collaborative multi-agent scenarios and Retrieval-Augmented Generation tasks.
• LLM and Vector Store Agnostic: Choose any mainstream or open-source model or vector DB and extend features as needed.
• Prototyping and Collaboration: Rapidly test, iterate and deploy flows and share, embed or serve flows via APIs for enterprise integration.

Choosing the Right Framework

1. Complexity of Tasks:

• For multi-step, stateful processes that require keeping track of context or conversation history, LangGraph and CrewAI are strong choices.
• If our workflow is primarily LLM-powered and modular (e.g., question-answering, retrieval-augmented generation), LangChain is purpose-built for chaining prompts, tools and memory.
• AutoGen excels in dynamic multi-agent conversations where agents with different roles interact, debate or collaborate on complex problems.

2. Integration Needs:

• For no-code, visual workflow design and easy connectivity with business tools, Langflow and n8n stand out. These platforms let us quickly build and deploy integrations without writing code.
• If we need deep code-level integration with existing systems and APIs, Semantic Kernel is designed for embedding AI logic directly into applications using C#, Python or Java.

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 & Data Security:

• Semantic Kernel and LangGraph are particularly well-suited for organizations requiring strict compliance (e.g., GDPR, HIPAA) due to their modularity and enterprise-grade features.
• AutoGen and CrewAI workflows should be designed with secure communication channels between agents and clear data retention policies.
• Langflow and n8n offer convenience, but always confirm that third-party integrations meet our security standards before connecting sensitive systems.