Discover Open Source AI Agent Projects

Compare LangChain and CrewAI across agent orchestration, multi-agent collaboration, ecosystem maturity, learning curve, and best-fit use cases.

Compare Microsoft AutoGen and CrewAI for multi-agent collaboration, conversational workflows, task orchestration, and developer experience.

Compare LangChain and LlamaIndex across RAG, data connectors, indexing, retrieval, agent capabilities, and application development.

Compare Pydantic AI and Mastra across type safety, language ecosystem, tool calling, workflows, and production deployment.

Compare Dify and Langflow across visual orchestration, app publishing, RAG, workflows, and team collaboration.

Compare n8n and Langflow for workflow automation, AI node orchestration, integration ecosystem, and visual development.

Compare OpenAI official Agents SDK and Google official Agent Development Kit across protocol, model support, tool calling, and deployment model.

Compare Mastra (TypeScript-first) and LangGraph (Python-first) across workflow, tool calling, state management, and observability.

Compare Browser-Use (DOM route) and Skyvern (vision route) two major browser Agent frameworks across technical route, performance, success rate, and use cases.

Compare RAGAS (RAG evaluation specialist) and DeepEval (general LLM evaluation) across evaluation metrics, testing methods, and CI/CD integration.

Compare Mem0 (lightweight memory layer) and Letta (full stateful Agent platform) across memory model, retrieval capability, and deployment complexity.

Compare Aider and Continue on AI coding assistant positioning, terminal/IDE integration, codebase comprehension, multi-file editing, and enterprise features.

Compare Open WebUI and NextChat on self-hosted chat UI capabilities, model support, user management, mobile experience, and deployment complexity.

Compare E2B and CubeSandbox on secure code execution for AI agents, isolation strength, startup latency, runtime duration, and language support.

Compare Langfuse and Arize Phoenix on LLM observability, trace/prompt management, evaluation capabilities, integration options, and open-source licensing.

Compare NeMo Guardrails and Guardrails AI: Colang DSL flow vs Pydantic Validator output across protection layers, structured output, scenarios, and ecosystem.

Haystack (2018, deepset) leans pipeline-first and reads like a research codebase. LlamaIndex (2022) shipped in the LLM wave with friendlier abstractions and a much larger community. We compare index abstractions, retrievers, chunking, evaluation, and ecosystem so you can tell whether you want depth or speed.

CAMEL (MBZUAI) leans into role-playing and emergent dialog. AutoGen (Microsoft) leans into programmable conversation flows and code execution. We compare role abstractions, dialog mechanics, observability, enterprise adoption, and the gotchas each one ships with.

Claude Code (Anthropic, 138k+ stars) is the official CLI assistant and only works with Claude models. Aider (Paul Gauthier, 47k+ stars) is Git-aware pair programming that talks to any LLM. We compare model lock-in, repo comprehension, PR workflow, cost, and enterprise readiness.

Langfuse (YC-backed OSS) ships trace + prompt management + evaluation as a stack. Helicone is an LLM gateway with built-in analytics and a much lighter footprint. We compare deployment, core capabilities, data ownership, pricing, and the use case each one fits.

AutoGPT (2023, 185k+ stars) ignited the Agent hype with its autonomous task loop. CrewAI frames agents as a structured crew with explicit roles and tasks. We compare architecture, control granularity, ecosystem maturity, production readiness, and where each one shines.

Dify (150k+ stars) is an AI-native app builder with built-in RAG, agent, and workflow primitives. n8n (198k+ stars) is a general-purpose workflow automation platform with hundreds of system integrations that has been adding AI capabilities. We compare positioning, integrations, AI depth, learning curve, and typical users.

MetaGPT (69k+ stars, MIT) simulates an SOP-style assembly line: each role produces artifacts following predefined workflows. CrewAI (56k+ stars, MIT) uses explicit crew / agent / task orchestration and lets the LLM drive the flow. We compare abstraction level, flow control, observability, learning curve, and production readiness.

OpenHands (82k+ stars) focuses on software development: code agents, sandboxed execution, and GitHub PR integration. AutoGPT (185k+ stars) targets general autonomous tasks where the LLM decides the next action. We compare positioning, execution environment, typical tasks, controllability, and production readiness.

Langfuse (31k+ stars) is LLM-native observability with trace + prompt management + evaluation as a stack. SigNoz (31k+ stars) is an OpenTelemetry-native general APM that treats LLM workloads as one of many. We compare positioning, protocol support, data model, extensibility, and typical scenarios.

AnythingLLM (63k+ stars, MIT) is a RAG-first desktop plus server Chat UI with a built-in vector store and workspace concept. Open WebUI (146k+ stars) is a general ChatGPT replacement with native Ollama support and full multi-user management. We compare RAG depth, model support, deployment, extensibility, and typical scenarios.

Cody (Sourcegraph) goes enterprise code-search plus contextual completion. Cline is a VS Code extension focused on end-to-end software engineering tasks (multi-file diffs, command execution, browser automation). We compare positioning, context acquisition, model support, safety boundaries, and typical users.

OpenHands (All-Hands-AI) targets software engineering with sandboxed runtime, GitHub PR integration, and dev tasks. Aider (Paul Gauthier) is Git-aware pair programming with multi-LLM support that runs locally. We compare positioning, execution environment, task type, model choice, and typical use.

Hermes Agent (Nous Research, 224k+ stars, MIT) is a self-improving agent from Nous Research with a learning loop, autonomous skill creation, cross-session memory, and a multi-platform messaging gateway. OpenCode (SST, 192k+ stars, MIT) is a terminal-native AI coding tool focused on multi-provider support and a build / plan dual-agent design for software development. We compare positioning, model strategy, runtime model, and typical scenarios.

LangChain is the general LLM orchestration framework that started with chain abstractions (LCEL / prompt / model / output parser). LangGraph is a graph state-machine abstraction from the same team, focused on stateful multi-agent plus cycles plus explicit control flow. We compare abstraction level, control flow, state management, ecosystem, and typical scenarios.

Ollama (177k+ stars, MIT) is a local LLM inference server (default port :11434) with a `ollama run <model>` command for one-line model startup. vLLM (88k+ stars, Apache-2.0) is built for production-grade high-throughput LLM serving, with multi-GPU and continuous batching. We compare positioning, deployment complexity, performance optimization, ecosystem, and typical scenarios.

Gemini CLI (Google, 106k+ stars, Apache-2.0) is Google's terminal AI agent with built-in Google Search grounding, a 1M token context window, and a free tier of 1,000 requests/day. Claude Code (Anthropic, 141k+ stars) is a terminal AI coding assistant with deep codebase understanding, git workflow management, and a plugin system. We compare model capabilities, context window, tool integration, pricing, and typical scenarios.

RAGFlow (88k+ stars, Apache-2.0) is an enterprise-grade open-source RAG engine with deep document understanding and Agent capabilities, deployable via Docker. MaxKB (22k+ stars, GPL-3.0) is an open-source knowledge base Q&A and Agent-building platform focused on zero-code integration and workflow orchestration. We compare retrieval capabilities, document processing, deployment, and typical scenarios.

Lobe Chat (lobehub/lobe-chat, 81k+ stars, LobeHub Community License) is an open-source AI chat web app with multi-model chat, plugin system, and knowledge base, deployable on Vercel / Docker / cloud. Cherry Studio (50k+ stars, AGPL-3.0) is a cross-platform desktop client with 300+ preset assistants and smart translation, ready out of the box. We compare product form, model support, extensibility, and typical scenarios.

smolagents (Hugging Face, 28k+ stars, Apache-2.0) is a minimal agent framework with ~1,000 lines of core code, where agents write actions as Python code rather than JSON. AutoGen (Microsoft, 60k+ stars) is a framework for building multi-agent AI apps, now in maintenance mode (new users directed to Microsoft Agent Framework). We compare architecture philosophy, agent types, code execution, multi-agent support, and typical scenarios.

llama.cpp (123k+ stars, MIT) is a pure C/C++ LLM inference engine with zero dependencies, extreme performance, and support for all GGUF models, from Raspberry Pi to GPU clusters. Ollama (177k+ stars, MIT) is a user-friendly wrapper on top of llama.cpp, offering `ollama run` one-click experience, Modelfile customization, a model library, and a REST API. We compare abstraction level, performance optimization, model format, ease of use, and typical scenarios.

Playwright MCP (Microsoft, 36k+ stars, Apache-2.0) is a Playwright-based MCP browser automation server supporting Chromium, Firefox, and WebKit. Chrome DevTools MCP (Chrome DevTools team, 49k+ stars, Apache-2.0) is a Puppeteer-based MCP focused on deep Chrome DevTools integration (performance tracing + network debugging). We compare browser coverage, automation engine, debugging capabilities, and typical scenarios.

browser-use (109k+ stars, MIT) ships both a Python library (embedded in agents) and a CLI skill (called by agents), so AI agents can use it via Python import or shell commands. Agent Browser (Vercel Labs, 40k+ stars, Apache-2.0) is a Rust-native CLI plus daemon where AI agents invoke it via shell, designed for speed and LLM-friendly output. We compare product form, performance, browser coverage, and typical scenarios.

Letta (formerly MemGPT, 24k+ stars, Apache-2.0) is a stateful agents platform focused on agent memory, learning, and self-improvement, offering CLI, App Server, desktop, and web access. Graphiti (getzep, 30k+ stars, Apache-2.0) is a temporal context graph engine that builds and queries knowledge graphs where facts evolve over time, positioned as a dynamic memory alternative to RAG. We compare memory model, deployment form, query capabilities, and typical scenarios.