Open source AI agents: tools, differences and how to implement them

AI agents no longer just answer a question in a chat window. They can consult a document base, browse a website, analyze files, trigger a workflow, query an ERP, prepare a report or carry out certain actions in business applications.

The open source ecosystem now makes it possible to build specialized assistants, teams of collaborative agents and intelligent automations tailored to a company’s needs. But the growing number of projects can make the choice difficult.

Should you use OpenClaw, LangGraph, CrewAI, PydanticAI, Mastra, n8n or Langflow? Do these tools really compete with each other? Can they run locally? What budget, infrastructure and skills should you plan for?

The answer depends on the problem you need to solve. Some tools are ready-to-use assistants. Others are development building blocks. Others still serve only to connect the agent to the company’s applications.

What is an AI agent?

An AI agent is software that uses an artificial intelligence model to reach a goal by carrying out several steps.

Unlike a traditional chatbot, it can:

• understand a request;
• decide which actions to perform;
• use tools or APIs;
• consult documents or a database;
• keep context or memory;
• ask for human approval;
• produce a result or trigger an operation.

Example: a chatbot answers the question “What is the status of my order?” An AI agent can identify the customer, check the ERP, verify the delivery status, generate a suitable reply and create a ticket if it detects a delay.

An AI agent is not an artificial intelligence model

This distinction is essential.

A model such as Llama, Qwen, Mistral or Gemma generates text, code or an analysis. An agent adds execution logic around the model.

The architecture can be represented simply:

User
   ↓
Interface: application, website, WhatsApp, Telegram or CRM
   ↓
AI agent: reasoning, rules and orchestration
   ↓
Tools: API, ERP, email, calendar, files, browser or database
   ↓
AI model: local or accessed through an API
   ↓
Controls: security, permissions, logs and human approval

An open source agent can use:

• a local model hosted on the company’s servers;
• a model accessed through a paid API;
• several models, depending on the complexity of the tasks.

So open source does not automatically mean free, local or autonomous. The agent’s code can be open while it relies on an external API billed by usage.

The four main categories of tools

1. Ready-to-use autonomous assistants

These tools offer the most accessible way to test AI agents quickly. They already come with an interface, a CLI or an environment for running tasks.

Goose is presented as a general-purpose open source agent that runs on the user’s machine and can handle code, research, writing, automation or data analysis. OpenHands focuses more on software engineering. Browser Use makes websites accessible to agents. GPT Researcher automates in-depth research across different sources. (GitHub)

OpenClaw: a special case worth knowing

OpenClaw holds an important place in this category. It is not simply a chatbot or a programming framework.

OpenClaw is a personal AI assistant that users can run on their own devices. Its Gateway acts as the control point between the assistant and several communication channels, including WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage and Microsoft Teams. The project is distributed under the MIT license. (GitHub)

You can use it to build:

• a personal assistant accessible from a smartphone;
• an internal assistant for employees;
• a conversational entry point for automations;
• an assistant connected to business tools;
• an interface for controlling agents from several messaging apps.

OpenClaw is not a direct competitor to LangGraph or CrewAI. Instead, it can serve as the conversational interface and Gateway, while a framework handles the complex business logic.

Concrete example: an internal assistant from Telegram

A company can install OpenClaw on a server and let a sales manager send a request from Telegram:

Prepare a summary of the new prospects, identify the priority follow-ups and create a task list for tomorrow.

The assistant can pass the request to business logic, check the CRM and send back an answer. Rules and human approvals must nevertheless control sensitive actions.

2. Frameworks for building custom agents

A framework does not necessarily provide an assistant you can use right away. It lets developers build a solution that fits the company’s processes.

LangGraph: for complex business workflows

LangGraph is a low-level orchestration framework for stateful agents and long-running workflows. It lets the developer define steps, decisions, interruptions and human approvals precisely. (LangChain Docs)

It fits when the agent must follow a rigorous process:

Receive a request
   ↓
Analyze the need
   ↓
Check the ERP
   ↓
Verify the business rules
   ↓
Get human approval if needed
   ↓
Create an action
   ↓
Log the result

Use cases:

• handling customer requests;
• qualifying prospects;
• generating quotes;
• checking case files;
• tracking orders;
• administrative workflows;
• integration with Odoo or ERPNext.

CrewAI: for building a team of agents

CrewAI lets you create specialized agents, crews and flows. A crew is a team of agents collaborating on a task. A flow organizes workflow execution, state management and events. (CrewAI)

Example for creating an article:

Topic monitoring agent
   ↓
Analysis agent
   ↓
Writing agent
   ↓
SEO agent
   ↓
Proofreading agent

CrewAI works well for prototypes, content workflows, research and processes that you can break down into clear roles.

PydanticAI: for securing inputs and outputs

PydanticAI is a Python framework geared toward production-ready GenAI applications. It emphasizes data validation, structured outputs and compatibility with many models and providers. (GitHub)

It is particularly well suited when the agent must return a reliable answer as usable data:

{
  "client_id": 152,
  "priority": "high",
  "recommended_action": "contact_client",
  "requires_human_approval": true
}

This approach is useful for:

• connecting the agent to a FastAPI API;
• feeding a CRM;
• automating classifications;
• extracting information from documents;
• checking the data format before saving it.

Mastra: for TypeScript teams

Mastra is designed for building AI applications and agents with a modern TypeScript stack. It suits teams working with Node.js, React, Next.js or web SaaS architectures. (GitHub)

A company can choose it when it wants to keep most of its development within the JavaScript and TypeScript ecosystem.

Google ADK 2.0: for structured agentic architectures

Google Agent Development Kit 2.0 is an open source, code-first toolkit for building, evaluating and deploying sophisticated agents. It is distributed under the Apache 2.0 license. Google announced the general availability of version 2.0 on May 19, 2026. (GitHub)

It is optimized for the Google ecosystem, yet designed to work with different models and deployment environments.

Microsoft Agent Framework: the successor to AutoGen and Semantic Kernel

Microsoft Agent Framework lets you build, orchestrate and deploy agents and multi-agent workflows with Python and .NET. Microsoft presents it as the direct successor to AutoGen and Semantic Kernel. (GitHub)

It is particularly attractive for companies already embedded in the Microsoft, Azure or .NET ecosystem.

3. Visual and low-code platforms

These solutions let you design AI workflows through a visual interface. They cut the time needed to build a prototype and make collaboration easier between developers and business users.

Langflow offers a visual experience, built-in APIs and MCP servers that turn a workflow into a reusable tool. Flowise positions itself as a visual tool for building agents. Dify brings together AI workflows, a RAG pipeline, agentic capabilities, model management and observability. n8n lets you combine visual building, custom code, self-hosting and business integrations. (GitHub)

When should you use a low-code platform?

A visual platform is useful for:

• building a proof of concept;
• testing an idea quickly;
• connecting a form to an AI model;
• building a document assistant;
• automating emails or notifications;
• linking an agent to a CRM, an ERP or a database.

For a critical workflow, a framework such as LangGraph or PydanticAI generally gives you more control over business rules, errors and approvals.

4. Complementary building blocks: models, connectors and infrastructure

An AI agent project does not rely on a framework alone. It needs several complementary components.

Ollama: running models on a local machine

Ollama makes it easier to use open models on macOS, Windows, Linux or Docker. Its official repository notably mentions its integration with OpenClaw and several coding assistants. (GitHub)

Ollama is suited to:

• testing;
• prototypes;
• development workstations;
• internal assistants with a limited load;
• projects where confidentiality matters.

vLLM: serving models at a larger scale

vLLM is an inference and serving engine for language models. It is designed to improve performance and handle a heavier load, notably with an OpenAI-compatible API and various optimization mechanisms. (GitHub)

vLLM is a better fit when several users or applications need to query a model hosted on GPU-equipped servers.

MCP: a standard for connecting agents to tools

The Model Context Protocol, or MCP, is an open standard for connecting AI applications to external systems: data, files, tools, APIs or workflows. The official website compares it to a universal port for AI applications. (Model Context Protocol)

MCP can connect an agent to:

• a document base;
• a database;
• an ERP;
• a file system;
• a search tool;
• an internal business server.

Composio: an integration layer, not an agent

Composio does not replace LangGraph, CrewAI or OpenClaw. It provides SDKs and integrations that let agents use external tools, with authentication and user session management. Its official repository presents SDKs for Python and TypeScript, while its documentation mentions over 1,000 toolkits. (GitHub)

Composio can be useful when an agent must act in several applications: Gmail, Slack, GitHub, a CRM or collaboration tools. However, you need to check the hosting, confidentiality and cost constraints for each project.

What is the difference between OpenClaw, LangGraph, CrewAI, n8n and Composio?

People often compare these tools even though they do not play the same role.

A professional project can combine several of these solutions.

Example:

OpenClaw
   ↓
LangGraph
   ↓
MCP or Composio
   ↓
n8n
   ↓
Odoo, ERPNext, Gmail, calendar and document base
   ↓
Ollama or an AI model API

Which tools should you choose for each need?

Need 1: create an internal assistant accessible from WhatsApp or Telegram

Possible stack:

OpenClaw
+ model accessed through an API or Ollama
+ MCP connectors
+ permission rules
+ human approval for sensitive actions

This architecture suits a personal assistant, a sales assistant or internal support.

Need 2: automate ERP or CRM processes

Possible stack:

LangGraph or PydanticAI
+ FastAPI API
+ Odoo or ERPNext
+ PostgreSQL
+ n8n for secondary integrations
+ logs and approval system

Examples:

• qualify leads;
• prepare a sales proposal;
• classify support tickets;
• summarize a customer’s history;
• create a follow-up task;
• check that the required documents are present before approval.

Need 3: quickly build a demo for a client

Possible stack:

Langflow, Flowise or Dify
+ model accessed through an API
+ a few business documents
+ chat interface

The goal is to validate the value of the use case before investing in a complete architecture.

Need 4: set up a team of agents for SEO writing

Possible stack:

CrewAI
+ GPT Researcher
+ reliable reference sources
+ writing agent
+ SEO agent
+ proofreading agent
+ human approval before publication

Need 5: assist a development team

Possible stack:

OpenHands or Goose
+ isolated environment
+ Git repository
+ limited permissions
+ mandatory human review

Need 6: automate browsing on websites

Possible stack:

Browser Use
+ isolated browser
+ browsing rules
+ control over the data collected
+ approval before binding actions

Open source, open core and source-available: know the difference

Before you integrate a tool into a commercial offering or a white-label solution, check its license.

OpenClaw, LangGraph, CrewAI and Langflow use an MIT license. Flowise makes its community code available under Apache 2.0. Dify uses a license derived from Apache 2.0 with additional conditions. n8n presents itself as a fair-code platform distributed under the Sustainable Use License and the n8n Enterprise License. (GitHub)

A legal review becomes essential when the company wants to:

• sell a solution as SaaS;
• offer managed hosting;
• modify the product extensively;
• distribute a white-label version;
• integrate the tool into a recurring commercial offering.

What do you need to plan for to implement an AI agent?

Level 1: simple prototype

Goal: demonstrate an idea with a few scenarios.

Example: an assistant that answers questions based on a product catalog.

Level 2: business agent connected to the information system

Goal: automate a real process.

Example: an agent that prepares a sales proposal but cannot send it without approval.

Level 3: agentic platform in production

Goal: serve several users or several clients.

Security is not optional

An agent that can act inside an application carries more risk than a simple chatbot.

OWASP notably lists prompt injection and excessive agency among the major risks of applications based on language models. Excessive agency arises when a system has overly broad functionality, excessive permissions or too much autonomy. (OWASP Gen AI Security Project)

Security checklist

Before going to production:

• limit the tools the agent can access;
• separate read and write permissions;
• prohibit automatic deletions;
• require human approval for payments, emails, orders and sensitive changes;
• log every tool call;
• isolate code execution in a sandbox;
• protect API keys;
• test direct and indirect prompt injections;
• set a maximum number of steps;
• cap costs and token consumption;
• check data before saving it;
• provide an emergency stop mechanism.

Three mini use cases for an SME

Case 1: sales assistant connected to the CRM

Goal: help the sales team prioritize follow-ups.

Possible architecture:

Web application or OpenClaw
   ↓
PydanticAI or LangGraph
   ↓
CRM
   ↓
n8n for notifications
   ↓
Human approval before sending a message

Expected result: the agent summarizes the history, suggests an action and prepares a draft, without contacting the customer automatically.

Case 2: document assistant for a company

Goal: answer internal questions based on approved documents.

Possible architecture:

Chat interface
   ↓
Langflow or Dify
   ↓
Internal documents
   ↓
Document search engine
   ↓
Local model via Ollama or external API

Expected result: less time spent searching for procedures, guides and product information.

Case 3: topic monitoring and SEO writing agent

Goal: produce a reliable working base for a writer.

Possible architecture:

GPT Researcher
   ↓
CrewAI
   ↓
Topic monitoring agent
   ↓
Structuring agent
   ↓
SEO agent
   ↓
Human editorial approval

Expected result: faster research, a better article structure and continued human control over sources and claims.

Common mistakes to avoid

Choosing a tool before defining the problem

Starting by installing several frameworks often leads to a needlessly complex architecture. The starting point must be a precise business task.

Confusing a local assistant with a local model

OpenClaw or Goose can run on the user’s machine, but that does not automatically mean the AI model is hosted locally. The model may still be accessed through an API.

Giving the agent too many permissions

An agent that looks up information in a CRM does not necessarily need to modify the data. Starting in read-only mode sharply reduces the risks.

Building a team of ten agents right away

A chain of specialized agents is not always better than a simple workflow. Add a new agent only when a distinct role delivers measurable value.

Overlooking licenses

A self-hostable tool is not always free to use in a SaaS or white-label offering.

Forgetting indirect costs

Even when the framework is free, you need to plan for:

• model APIs;
• hosting;
• GPUs, if needed;
• databases;
• monitoring;
• maintenance;
• testing;
• security hardening;
• integration with business tools.

Which selection should you start with?

For a digital agency or a company that wants to explore AI agents without spreading its efforts too thin, a pragmatic starting selection would be:

The right combination then depends on the project.

For an internal assistant accessible through messaging:

OpenClaw + MCP + Ollama or external API

For an agent connected to an ERP:

LangGraph or PydanticAI + business API + n8n + human approval

For a quick demo:

Langflow or Flowise + documents + AI model

For a SaaS built in TypeScript:

Mastra + Node.js backend + MCP tools + database

Key takeaways

Open source AI agents are not a homogeneous family.

OpenClaw is a self-hosted, multichannel personal assistant. LangGraph structures complex business workflows. CrewAI makes it easier to build teams of agents. PydanticAI secures the inputs and outputs of Python applications. Mastra meets the needs of TypeScript teams. Langflow and Flowise speed up visual prototypes. n8n connects applications. Ollama and vLLM run models. MCP standardizes connections with external tools.

The right choice is not to pick the most popular tool. It is to assemble only the building blocks the use case requires, with minimal permissions, explicit controls and human approval for sensitive operations.

FAQ: open source AI agents

What is the best open source AI agent?

No single tool is the best for every case. OpenClaw suits a multichannel assistant. LangGraph handles complex workflows. CrewAI makes agent teams easier to build. PydanticAI suits structured business APIs.

Is OpenClaw really open source?

Yes. The main OpenClaw repository is distributed under the MIT license. It is a personal assistant and a self-hostable multichannel Gateway. (GitHub)

Can you use OpenClaw with a local model?

Yes. You can pair OpenClaw with Ollama. The official Ollama repository mentions a command that launches OpenClaw as a multichannel personal assistant. (GitHub)

What is the difference between OpenClaw and n8n?

OpenClaw provides a conversational assistant interface. n8n automates workflows between applications. You can use both together.

What is the difference between LangGraph and CrewAI?

LangGraph offers fine-grained control over states, decisions and interruptions. CrewAI makes it easier to organize several specialized agents and collaborative flows.

Do you need a GPU to build an AI agent?

Not necessarily. An external API is enough to get started. A GPU becomes useful when the company wants to run certain models locally with performance suited to several users.

Can an AI agent connect to Odoo or ERPNext?

Yes. The integration can go through the ERP’s APIs, dedicated connectors, n8n or a business MCP server. Limit permissions to the authorized actions.

Can you sell a solution based on these tools?

It depends on the license of each component. MIT licenses are permissive. Dify and n8n impose specific conditions that you must check before any SaaS offering, managed hosting or white-label distribution. (GitHub)