AI Agent Frameworks

langchain136.1k★

LangChain provides the plumbing. It connects LLMs to data sources, tools, memory, and each other so you don't write the integration code yourself. The framework is free under MIT. LangSmith (their hosted observability platform for debugging chains) has a free tier with paid plans for teams. The core library, all integrations, and LangGraph (their agent framework) are fully open source. The catch: LangChain is famous for being over-abstracted. Simple tasks that take 5 lines with a raw API call become 50 lines of LangChain boilerplate with three layers of indirection. The API changes frequently. And the abstraction layer means when something breaks, you're debugging LangChain's internals, not your application logic. It's most valuable when you need the orchestration, not when you're making a simple chat call.

AutoGen57.8k★

AutoGen is Microsoft's framework for orchestrating multi-agent AI conversations, where multiple agents with different roles, tools, and instructions collaborate to complete tasks. You define agents with different roles, tools, and instructions, and AutoGen manages how they talk to each other to complete tasks. The framework handles the hard parts of multi-agent systems: conversation flow, tool calling, human-in-the-loop approvals, code execution sandboxing, and state management. It works with OpenAI, Azure OpenAI, and other LLM providers. CC-BY-4.0 license (docs/examples; the code itself is MIT). Fully free, no paid tier. The catch: AutoGen is in heavy flux. The v0.2 to v0.4 transition broke a lot of existing code, and the API is still evolving. The include a lot of early hype. Actual production deployments are less common than the star count suggests. CrewAI and LangGraph are competitors with arguably better developer experience for simpler agent workflows. AutoGen's strength is complex multi-agent patterns, but if you just need a single agent with tools, it's overkill.

CrewAI50.9k★

CrewAI orchestrates multiple AI agents working together on complex tasks, each with defined roles, tools, and goals. It's a project manager for AI: you define who does what, and CrewAI orchestrates the workflow. MIT license, Python. The mental model is intuitive: you create Agent objects with roles and goals, define Task objects with instructions, and a Crew runs them in sequence or parallel. Agents can use tools (web search, file access, APIs) and pass results to each other. Built on top of LangChain under the hood. The open source framework is free. CrewAI also offers CrewAI Enterprise, a managed platform with a visual builder, monitoring, deployment, and team collaboration. Pricing starts at $199/mo for the Teams plan. Solo developers: the open source framework is solid for building multi-agent workflows. Small teams: free tier works, evaluate Enterprise when you need visual workflow building. Medium to large: Enterprise for monitoring and deployment at scale. The catch: CrewAI's agent orchestration adds latency and cost. Each agent makes its own LLM calls, and a 3-agent crew might make 10-15 API calls for one task. The bills add up fast. Also, debugging multi-agent conversations is hard. When an agent produces bad output, tracing why through the chain is painful. And the LangChain dependency means you inherit LangChain's fast-moving API surface.

LangGraph31.5k★

LangGraph defines AI agent workflows as graphs, where nodes are processing steps and edges are conditional transitions. Each node is a step (call the LLM, run a tool, check a condition), and edges define what happens next. The graph model matters because real agent workflows aren't linear. An agent might need to: research, then decide if it has enough info, loop back to research if not, then draft a response, then review it, then either revise or submit. LangGraph makes these branching, looping workflows explicit and debuggable. It builds on LangChain but works independently. Supports any LLM provider. State management is built in: each graph execution has persistent state that nodes can read and write. Human-in-the-loop patterns (pause execution, wait for approval, resume) are first-class features. The star velocity tells you where the market is heading. Agent frameworks are the hottest category in open source AI right now. The catch: the abstraction adds complexity. For simple "call an LLM with tools" flows, LangGraph is overkill. The OpenAI or Anthropic SDKs handle that directly. The LangChain ecosystem moves fast and breaks things; APIs change between versions. And debugging graph execution requires understanding the framework's internals, not just your business logic.

CopilotKit31.0k★

CopilotKit gives you the building blocks to embed AI copilots directly into React and Angular apps. Not a chatbot widget you bolt on, but a framework for building assistants that can read your app's state, take actions in the UI, and hold multi-turn conversations with context. The whole thing is open source and free. Self-hosting means you bring your own LLM keys (OpenAI, Anthropic, whatever) and handle the infrastructure. The framework itself is lightweight, but the real ops burden is managing your LLM costs and keeping API keys rotated. There's a managed cloud option if you want to skip the plumbing, though pricing details are thin. Solo devs and small teams get the most value here: you skip months of building copilot infrastructure from scratch. Larger teams with existing AI tooling may find it redundant. The React integration is solid and well-documented, so getting something production-ready is fast. The catch: you're still on the hook for LLM costs, and the framework assumes you're comfortable wiring AI into your frontend. This is not plug-and-play for non-developers.

Haystack25.1k★

Haystack connects documents, language models, and retrieval systems into production-ready NLP pipelines, handling the plumbing so you can focus on the AI logic. It's plumbing for AI apps: connecting your data sources to language models to output. Apache 2.0. Built by deepset. The pipeline architecture lets you chain components (retrievers, readers, generators, rankers) into workflows. Supports OpenAI, Hugging Face, Cohere, and local models. Native integrations with vector databases like Qdrant, Weaviate, and Chroma. Fully free and open source. deepset offers a managed platform (deepset Cloud) for enterprise deployments with collaboration and evaluation features, but the framework itself has zero restrictions. Self-hosting is straightforward. pip install, define your pipeline in Python. The ops burden depends on what you connect: a simple RAG pipeline is trivial, a multi-step agent with retrieval and re-ranking needs more infrastructure. Solo to small teams: free, great developer experience. Medium teams: evaluate deepset Cloud when you need shared pipelines and evaluation dashboards. Large: deepset Cloud or your own orchestration layer. The catch: Haystack is a framework, not a product. You still need to pick your models, vector store, and deployment strategy. And if you're already deep in the LangChain ecosystem, migrating has real cost. The abstractions are different enough that it's not a drop-in swap.

langchainjs17.6k★

This is the framework that connects your code to LLMs. It handles the plumbing: talking to OpenAI/Anthropic/local models, managing conversation memory, chaining prompts together, and calling tools. What's free: Everything. MIT license, no paid tier in the library itself. LangSmith (their observability platform) has a free tier with limits. LangChain JS has become the default starting point for JS/TS AI applications. Active development, huge community. The abstractions for chains, agents, and retrieval are battle-tested. The catch: LangChain is famously over-abstracted. Simple things that take 5 lines with the OpenAI SDK directly take 20 lines through LangChain. The abstraction layers add latency and debugging complexity. If you're just calling an API and formatting the response, you don't need this. It earns its keep when you're building complex agent workflows with tool calling, retrieval-augmented generation (feeding your own documents to AI), or multi-step reasoning chains.

OpenHarness12.1k★

OpenHarness is an open source agent framework that gives you tool-use, skills, memory, and multi-agent coordination out of the box. It ships 43 built-in tools (file ops, shell, search, web, MCP) and a plugin system for extending them. MIT licensed, Python, designed to work with any LLM provider. The architecture mirrors what you'd expect from a coding agent: an agent loop with streaming tool calls, context compression, persistent memory, and permission governance. Setup is a pip install. It's compatible with existing skill and plugin ecosystems, so you're not starting from zero on integrations. For solo developers building agent prototypes, this covers the boring infrastructure so you can focus on the agent logic. Small teams get multi-agent coordination without rolling their own orchestration layer. The catch: this is a research project from HKU, not a production-hardened framework. The ecosystem is young, documentation is thin, and you're betting on an academic team's long-term commitment. For production agent workloads, more established frameworks like LangGraph or CrewAI have deeper community support.

skills11.6k★

MiniMax Skills is a framework for creating task-specific agent capabilities. Instead of one general-purpose agent that's mediocre at everything, you build focused skills that each do one thing reliably. Built by MiniMax (a major Chinese AI company), it's written in C# and designed for their agent ecosystem. You define skills as modular units that agents can discover, load, and execute. A plugin system for AI agents. MIT licensed. The catch: this is deeply tied to MiniMax's ecosystem. If you're not using their models or agent infrastructure, the value drops significantly. The C# implementation is unusual in a Python/TypeScript-dominated AI landscape; your team needs C# experience. And 'skills framework by a model provider' means the framework is optimized for their models, not necessarily yours.

agent-framework10.2k★

Microsoft's agent framework brings enterprise-grade tooling to the AI agent space. Graph-based workflows, first-class Python and .NET support, and a built-in DevUI for testing and debugging. Teams building multi-agent systems who need something more structured than LangChain should look here first. The standout feature is the developer experience. Time-travel debugging lets you step backward through agent execution, OpenTelemetry is built in for observability, and the middleware pipeline gives you clean request/response interception. Microsoft clearly built this for teams that need to ship agent workflows to production, not just prototype them. Enterprise teams on .NET or Python get the most value. Solo developers and startups might find it heavier than alternatives like CrewAI or AutoGen. But for multi-language parity, structured workflows, and production observability out of the box, this is one of the stronger options. The catch: it's a Microsoft project, which means enterprise polish but also enterprise complexity. The learning curve is steeper than lightweight frameworks, and you're betting on Microsoft's continued investment.

OpenSpace6.1k★

OpenSpace makes agent skills self-evolving, running experiments and keeping what works based on results. Instead of static prompt files, skills are living entities that automatically select themselves, monitor their performance, and evolve based on results. Basically, Darwinian selection for agent capabilities. Three evolution modes: FIX (repair broken skills), DERIVED (create new skills from existing ones), and CAPTURED (learn skills from successful runs). The result is a 46% reduction in token usage and 4.2x higher income compared to baseline agents in their benchmarks. Uses Qwen 3.5-Plus as the backbone LLM. MIT licensed. Integrates with MCP servers (GitHub, Slack, etc.) and stores evolved skills in a local SQLite database you can inspect. The catch: the benchmarks are impressive but from an academic lab (HKU). Real-world skill evolution is messier than controlled experiments. The community cloud (open-space.cloud) is new and the shared skill library is still sparse. And 'self-evolving' means your agent's behavior can change in ways you didn't explicitly approve.

hiclaw4.5k★

This is an operating system for that. It uses Matrix chat rooms (the same protocol behind Element) as the coordination layer, so every agent action is visible as a message in a room you can read. What's free: Everything. Apache 2.0 license, self-hosted, no paid tier. The transparency angle is the real differentiator. Most multi-agent frameworks are black boxes where agents talk to each other and you get the result. HiClaw makes every decision, handoff, and tool call visible in Matrix rooms. For regulated industries or anyone who needs to audit what their AI agents did, that's a big deal. The catch: it's from Alibaba, which means great engineering but documentation tends to be initially Chinese-focused with English as a second priority. It's growing fast but still early. The Matrix dependency adds infrastructure complexity. You need a Matrix homeserver running, which is its own ops burden.

autoagent4.4k★

AutoAgent is a meta-agent framework: you give it a task, and it builds and iterates on an AI agent harness autonomously. It modifies the system prompt, tools, and orchestration, runs a benchmark, checks the score, keeps improvements, discards regressions, and repeats. Automated prompt engineering on steroids. The human steers via a program.md directive in plain markdown. The meta-agent edits the actual agent.py code, runs it in Docker isolation, and hill-climbs on a 0-1 score. You write the goal, it does the iteration loop. Built by thirdlayer.inc, who are building a commercial product around self-configuring agents. For AI engineers building complex agent systems who want to automate the tuning loop: this is worth watching. You need existing benchmark tasks in Harbor format and a working harness to start from. It does not build your first version, only improves it. The catch: the README claims MIT but there is no LICENSE file in the repo. That is a red flag for production use. The commercial angle (thirdlayer.inc signup form in the README) suggests the open source version may not stay fully open.

Shannon1.8k★

Shannon is a multi-agent orchestration framework built in Go with a Rust agent core and Python LLM layer. It manages complex AI workflows: task decomposition, multi-agent coordination, token budgets with automatic model fallback, and time-travel debugging that lets you replay any execution step. Supports 10+ LLM providers including Anthropic, OpenAI, and Ollama. The architecture is serious infrastructure: Temporal for durable workflows, OPA for policy enforcement, Prometheus metrics, OpenTelemetry tracing, and human-in-the-loop approval gates. Multiple execution strategies (DAG, ReAct, Research, Swarm, Browser Use) cover different agent patterns. Docker Compose spins up Go gateway, Rust core, Python LLM service, Temporal, PostgreSQL, and Redis. Teams building production agent systems who need observability, cost control, and multi-tenant isolation will find the feature set compelling. The token budget enforcement with automatic fallback to cheaper models is a useful idea for controlling LLM spend. The catch: very early stage with minimal commit history. The feature list reads like aspirational docs more than battle-tested reality. Three languages (Go, Rust, Python) means three ecosystems to debug. Temporal alone is a significant operational dependency. Watch this project, but don't bet production on it today.

adk-java1.5k★

ADK (Agent Development Kit) for Java is Google's official toolkit for building, evaluating, and deploying AI agents. Define tools, orchestrate multi-step reasoning, handle conversation state, and evaluate agent performance all within your Java codebase. Apache 2.0. This is early but backed by Google. It integrates with Google's AI models (Gemini) and supports the broader agent ecosystem. Fully free and open source. No paid features in the toolkit. You pay for the AI models you call through it: Gemini API pricing, Vertex AI costs, or whatever LLM you connect. The catch: Java in the AI agent space is unusual; most agent frameworks are Python or TypeScript. The ecosystem of examples, tutorials, and community plugins is small compared to LangChain or CrewAI. If your team is already in the Java ecosystem (Spring Boot, enterprise backends), this makes sense. If you're starting fresh, Python frameworks have 10x the community support. And it's early; the API is still evolving.