AI Agent Frameworks

hermes-agent247.9k★

Hermes is Nous Research's open-source autonomous agent. It builds skills from experience, remembers them across sessions, and connects to Telegram, Discord, Slack, WhatsApp, Signal, and email out of the box. It drives more than 300 models through OpenRouter, OpenAI, Anthropic, Hugging Face endpoints, or Nous Research's own portal. MIT licensed. Install is one curl command on Linux, macOS, WSL2, or Termux. After `hermes setup`, point it at any provider; switching models is a single CLI flag with no code changes. It runs on a $5 VPS or a GPU cluster, and releases land several times a month. Nous now sells subscriptions alongside the free agent, which is the change worth knowing about. There is still a free tier, and the software itself has no paid edition or feature gate. The paid plans are model access: Plus at $20 a month, Super at $100, and Ultra at $200, each bundling 300+ models and the hosted tools Hermes calls into one bill instead of four provider accounts. Each tier carries a monthly credit allowance in the neighbourhood of what you pay for it. Solo builders can ignore all of it and bring an OpenRouter key. Anyone tired of managing separate provider keys has a reason to look. The catch is that it is research-y. Nous is an AI research lab, not a SaaS company. Docs are dense, support is community-driven, and self-improving claims always come with caveats. Treat it as an experiment you are running, not a production-grade agent you are deploying.

dify156.1k★

Dify is a full platform for building AI applications, from simple chatbots to complex multi-step agent workflows. The open source version gives you the workflow editor, RAG pipeline, prompt management, and model integrations with every major provider. You can build and deploy production AI apps without writing much code. Self-hosting runs on Docker Compose with Postgres, Redis, and a few worker services. Not trivial, but the docs are solid and the community is massive. Expect to spend a few hours on initial setup and ongoing attention to model API keys, vector store config, and worker scaling. Solo developers and small teams get enormous value from the free self-hosted version. Dify Cloud starts at $59/mo per workspace if you want managed hosting, which makes sense once you have multiple team members and need usage controls. Enterprise pricing is custom. The catch: Dify does a lot, and that breadth means the learning curve is real. You will spend time understanding their abstraction layers before you ship anything. If you just need a simple RAG chatbot, this might be more platform than you need.

langchain146.5k★

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.

odysseus87.3k★

Odysseus is a self-hosted AI workspace that runs on your own hardware. The pitch is privacy: instead of sending every chat, document, and email to a cloud assistant, you run the whole thing locally and keep your data on your machine. It bundles chat, autonomous agents, tool use, email triage, and research into one app, and it can serve open models directly so you are not dependent on anyone's API. The clever part is the Cookbook. It looks at your hardware and recommends models you can actually run, then serves them for you across vLLM, llama.cpp, or Ollama with far less manual wiring than usual. It supports MCP servers too, so you can connect it to other tools. The flip side is obvious: local models need local compute. Without a capable GPU or a lot of RAM you are limited to smaller models, and you bring your own keys to call hosted ones. It is MIT and free. For a privacy-minded solo developer with decent hardware, this is a genuinely exciting way to get a private alternative to a ChatGPT or Claude subscription. Small teams can experiment, but treat it as early. It is a very young, fast-moving project that launched to a huge audience overnight, so expect rough edges and frequent changes. The catch is security, and the project says so itself. The documentation warns you to treat Odysseus like an admin console and never expose it directly to the internet. It is powerful, it touches your email and your files, and it is brand new. Run it locked down, not on a public IP.

AutoGen61.0k★

AutoGen is Microsoft's framework for building multi-agent AI systems, where several agents with different roles and tools work together, or alongside a person, to finish a task. You define the agents and AutoGen handles how they talk, call tools, run code in a sandbox, and pause for your approval. The code is MIT, the docs and examples are CC-BY-4.0, and all of it is free. Here is the part that matters before you build on it: AutoGen is in maintenance mode. Microsoft named microsoft/agent-framework as the successor and steers new users there. AutoGen still runs and the v0.7 line is stable, but its Python packages have not shipped a release since September 2025 while the successor ships roughly every week. Contributions are limited to bug fixes, security patches, and docs. Already running it in production? You are fine for now, but put a migration to microsoft/agent-framework on the roadmap instead of treating this as permanent. Picking a framework today: start with the successor, or look at crewAIInc/crewAI and langchain-ai/langgraph, which most people find easier for simpler workflows. Solo and small teams: still a good way to learn the patterns, you are just learning a frozen API. The catch is that, plainly: Microsoft stopped developing this. The pile of existing tutorials makes it look like the safe default, and maintenance mode means no fixes for new model behaviors and no new capabilities. Building something long-lived on a frozen framework is a decision, not a default.

CrewAI58.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.

LangGraph41.8k★

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.

CopilotKit37.5k★

CopilotKit gives you the building blocks to embed AI copilots directly into React and Angular apps. Not a chat widget bolted onto the corner of the page, but a framework where the assistant reads your app's state, calls your functions, and takes actions in the UI. The framework is open source and free, self-hosted, with your own LLM keys. Self-hosting is close to trivial because there is no separate service to stand up. It is packages in your Next.js or React app plus a runtime endpoint. Your real cost is LLM tokens, and they scale with how much of your app state the copilot can see, because that context ships on every turn. Budget more than the first week suggests. CopilotKit Cloud handles thread storage, retention, and the Slack and Teams connectors. Developer is free for one developer with 3-day thread retention and a 200-thread cap. Pro is $39/mo for 5,000 threads and 10 GB. Team is $100 per seat per month for up to five seats and adds a self-hosting option. Solo developers and small teams should self-host and pay nothing. Medium teams buy Cloud to stop managing thread state. Large teams end up on Enterprise for VPC or on-prem. The catch is where the free framework and the paid cloud draw their line: persistence. Building the copilot costs nothing. Keeping conversation history past three days is where the meter starts. Decide early whether you need thread history, because retrofitting your own storage later is more work than it sounds.

zeroclaw32.8k★

ZeroClaw is a self-hosted runtime for an autonomous AI assistant that lives on your hardware instead of someone's cloud. It connects to 20-plus model providers and 30-plus channels like Discord, Telegram, Matrix, and email, and acts through shell, browser, HTTP, and custom MCP tools. Written in Rust, dual licensed MIT or Apache 2.0, and free. You bring your own model keys, sign in with a Codex or Claude subscription, or run local models with Ollama. Running it is moderate work: you host the runtime, wire up the channels you want, and supply the models. It installs as a system service on Linux, macOS, or Windows, and now includes a web dashboard. It does not ship wide open. The default autonomy level is supervised, meaning medium-risk operations need approval and high-risk ones are blocked, with workspace boundaries, command policy, and OS-level sandboxes. A YOLO mode exists for trusted dev environments. Solo and small teams: free, and you pay only for model usage. Anyone who wants something vetted with support should stay with ChatGPT, Claude, or Copilot. The catch is still trust. An agent with shell access is only as safe as the policy you leave on and the model's judgment, so resist the urge to loosen the defaults. The newest release also adds ZeroRouter, a hosted model gateway in beta that needs a key and has no published pricing.

deepagents29.5k★

Deep Agents is LangChain's batteries-included agent harness. Where the base LangChain agent gives you a minimal loop, Deep Agents bundles the pieces you always end up building yourself: a filesystem, sub-agent delegation, context management, shell execution, persistent memory, human-approval steps, and reusable skills. It runs on any LLM that supports tool calling, MIT licensed and free. It installs as a Python package (`uv add deepagents`) and one call to its `create_deep_agent` helper gives you a working agent with your model, tools, and prompt. Under the hood it is built on LangGraph, so you inherit streaming, persistence, and checkpointing. Running it yourself costs nothing beyond your model's token bill, and a JavaScript/TypeScript port exists too. For a developer who wants a capable agent without wiring every subsystem by hand, this is a strong starting point at any team size. The money in the ecosystem is LangSmith for tracing and deployment: a free developer seat with 5K traces a month, then $39 per seat per month on Plus. A hosted Managed Deep Agents runtime is in private preview with no published price. The catch is the LangChain gravity. The package installs the LangSmith client plus Anthropic and Google integrations as required dependencies, and the production path points at LangSmith. If you like the batteries, it is a fast path. If you want a thin, transparent agent loop, this is more framework than you asked for.

Haystack26.6k★

Haystack is an open-source Python framework for building LLM applications: retrieval-augmented generation, semantic search, and increasingly, autonomous agents. In plain terms, it is the plumbing that connects your documents and data to a language model and back out as an answer, with explicit control over each step. Apache 2.0 licensed, free via pip install haystack-ai, built by deepset. The design is modular pipelines: you chain swappable components (retrievers, rankers, generators, memory, tool-calling) into a workflow you can actually reason about. Version 2.x widened the scope from pure RAG to agent workflows, tool use, and multimodal apps, so the same framework that builds a document Q&A system now builds an agent that calls tools and keeps memory. Running it yourself is moderate work: the framework is free, but you supply the vector store, the LLM, and the infrastructure around them. Solo and small teams: pip install and go, then budget for the LLM API calls and a vector database, not for Haystack itself. Larger orgs that want managed deployment, observability, and governance can look at Haystack Enterprise, deepset's paid tier, available cloud or self-hosted. The framework gives you the control; Enterprise sells the operations layer on top. The catch is that Haystack's flexibility is also its learning curve. The pipeline model is powerful, but you have to design it, and you are on the hook for the costs it orchestrates: every LLM call and every vector query is your bill, not deepset's. Compare it against LlamaIndex and LangChain before committing, since all three cover overlapping ground with different opinions.

eliza19.4k★

elizaOS is a framework for building AI agents that actually do things: answer in your Discord, run a Telegram bot, automate a workflow, or play an NPC in a game. It ships with the parts you'd otherwise wire up yourself, including memory, document ingestion so the agent can read your docs, and connectors for the major chat platforms. MIT licensed, free, and it works with whatever model you want behind it: OpenAI, Anthropic, Gemini, Llama, or Grok. Running it is real work. You need Node 24 and Bun, you bring your own model API key, and you host it yourself. Scaffolding a starter agent takes minutes, but turning that into something reliable in production is a project, not an afternoon. Solo builders and small teams: this is a strong start if you want control over your agent stack instead of renting someone's hosted bot platform. Larger teams get the same code with no license ceiling. Compare it against LangChain if you want a library rather than a full runtime. The catch: it moves fast and the surface is wide, so expect breaking changes and rough edges as you go deeper. The framework is free, but your real cost is the LLM tokens every agent burns through, and those add up quietly.

langchainjs18.2k★

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.

OpenHarness15.8k★

OpenHarness is agent infrastructure you pip install: the tool-calling loop, 43 built-in tools for files, shell, search, web, and MCP, plus skills, memory, permission modes, and multi-agent coordination. It also ships ohmo, a personal agent built on top of it that lives in Slack, Discord, Telegram, or Feishu and will fork a branch, write code, run tests, and open a PR on its own. MIT, Python 3.10 or newer, free. The ohmo part is the interesting trick. It runs on a Claude Code or Codex subscription you already pay for rather than a separate API key, so a chat-driven coding agent costs nothing extra. Setup is pip install openharness-ai, then oh setup to pick a provider and ohmo gateway start to put it in your chat app. It reads CLAUDE.md, loads Anthropic-style skills and plugins, and compacts its own context. Here is the problem. The last commit landed June 4, 2026, the last PyPI release was 0.1.9 on May 7, and there are dozens of open issues with nobody working them. This is a university research group's project that got popular fast, and popularity is not maintenance. For anything you depend on, langchain-ai/langgraph and crewAIInc/crewAI have real release cadences; for the coding agent job specifically, openclaw/openclaw is still shipping. The catch is that a stalled repo and a permission system make a bad pair. ohmo runs shell commands and opens PRs on your behalf, which is exactly the code you want getting security fixes. Fine for a prototype on a throwaway repo. Not something to point at code you care about until commits resume.

skills13.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-framework13.6k★

Microsoft Agent Framework is what AutoGen and Semantic Kernel turned into. Same teams, one SDK, and it reached 1.0 in April 2026 with a long-term support commitment behind it. You get agents, graph-based workflows for sequential, concurrent, and handoff patterns, and an opinionated harness agent that handles planning, todo tracking, and context compaction on long jobs. MIT licensed, all of it. There is no server to run. Install the Python or .NET package and your only bill is the model provider. It talks to Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, and Ollama, so choosing it does not lock you to Azure. OpenTelemetry is wired in for tracing and the local DevUI gives you step-through debugging of a running workflow. Python and .NET are the mature targets; Go exists but is public preview and missing declarative agents and RAG. If you are a .NET shop, treat this as the default and stop shopping. Python teams already productive on langchain-ai/langgraph do not have a strong reason to migrate. Solo builders will get moving faster on crewAIInc/crewAI. The catch: this is a migration, not an upgrade. microsoft/autogen is now in maintenance and its future work happens here, so getting current means rewriting against a migration guide. Pick your lane before you end up running three agent stacks in production.

OpenSpace7.7k★

OpenSpace is a librarian for the skill files your coding agent piles up. Version 2, released in July 2026, dropped the original self-evolving-agent pitch for something concrete: find the right skill, track whether it worked, share the ones that did, retire the ones that did not. All MIT licensed, including the community library at open-space.cloud. Running it means Python 3.12 or newer, a pip install, and wiring an MCP server into Claude Code, Codex, OpenClaw, or nanobot. Skills and execution stay local, and the cloud is optional. The dashboard is a second install needing Node 20. You bring your own model key, so the running cost is tokens. Solo developers with a dozen skill files do not need this, and a curated pack like slavingia/skills is a smaller commitment. It pays off once a team shares hundreds of skills and nobody can say which still work. The catch: this comes out of an academic lab, and its Terminal-Bench 2.1 result, 65.2% cold to 78.7% warm, was run on its own harness. Self-evolving skills mean an agent rewriting its own instructions, and the restrictive policy that limits it to repairs is not the default. The shared library is still thin.

hiclaw5.7k★

Running a team of AI agents means losing track of what each one did and why. HiClaw 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.

eve5.2k★

Eve is Vercel's framework for building durable AI agents where the agent's definition lives as plain files, not buried in code. Its instructions, tools, skills, message channels, and scheduled jobs sit in a conventional folder layout you can read, diff, and reason about. Apache-2.0, free, and currently in public beta. The filesystem-as-source-of-truth idea is the interesting part: an agent's behavior is inspectable and version-controlled instead of tangled in application logic. It is a TypeScript/Node framework you run yourself, so the ops are moderate and familiar. Being a Vercel project, it is oriented toward their deployment and model ecosystem, and being public beta, the APIs can still move under you. This is for TypeScript developers who want maintainable, inspectable agents and like the idea of the agent's whole definition being files on disk. Solo and small teams: free to build and run. Larger teams: free framework, but factor in beta churn and the Vercel-shaped defaults. If you want a managed agent platform with a stable API and a support contract, LangGraph Platform or OpenAI's Assistants API are the paid alternatives. The catch is beta. The design is clean and the file-based approach is a readable way to keep agents legible, but public beta means expect breaking changes and thin edges. Build with it if you are comfortable tracking a moving target; wait if you need stability today.

autoagent4.6k★

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.

commerce-agents3.0k★

commerce-agents is Anthropic's reference blueprint for building two things on Claude: a shopping agent you embed for customers, and a merchant agent your staff use to run the back office. It is not a product you install, it is example code (real runnable agents across retail, travel, telecom, and entertainment) that shows how to wire the pieces together. Apache-2.0. The value is the pattern, not the demo. Each agent is defined once (prompt, skills, tool contracts, approval gates) and runs on the Messages API, the Agent SDK, and Managed Agents. There is a Claude Code plugin that scaffolds a new agent against your own systems. Nothing here places a real order or charges a card; every write is staged until a person approves it. If you are building commerce agents on Claude, start here instead of from a blank file. It shows the safety scaffolding (the fencing, the staged writes, the approval surface) that you would otherwise learn the hard way. The catch: the code is free but Claude is not. You bring an API key, and cost scales with usage. This is a starting point wired to Anthropic's own stack, not a vendor-neutral framework.

Shannon2.3k★

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.7k★

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.

dust1.5k★

Dust lets a company build its own AI agents that plug into internal data and take action across the tools people already use: GitHub, Google Drive, Notion, Slack. Instead of buying a separate assistant for every department, you build agents once and route them across models like Claude, GPT, and Gemini. The platform is open source under MIT and you can run the whole thing yourself. Self-hosting is a real project, not a weekend. This is a large TypeScript and Rust monorepo with multiple services, data connectors, and vector infrastructure to stand up, and you bring your own model API keys on top. You need a platform team that wants to own it. When that is not you, the hosted version exists for a reason. Cloud Pro runs about 29 euros per user per month (roughly 31 dollars) and covers connectors, the better models, and SOC2 with zero data retention. Enterprise is custom, starts at 100 seats, and adds the things big companies cannot skip: SSO, SCIM provisioning, and data residency. Solo builders and small teams should just use the cloud. Large teams self-host only when owning the infrastructure beats the per-seat bill, which usually means real scale. It substitutes for the agent-building tiers of platforms like Glean or Microsoft Copilot Studio. The catch: the MIT license covers the engine, but the value most teams actually pay for is the managed, connected, compliant version. Running it yourself means you own the connectors, the upgrades, and the 2am pages.