Best Open Source Agent Frameworks

Goose does that. Built by Block (the company behind Square and Cash App), it's a local AI agent that uses any LLM you point it at and has full access to your development environment. The key differentiator: extensibility. Goose uses a plugin system where you can add capabilities, called 'toolkits', for specific tasks. Need it to manage your Kubernetes cluster? Deploy to AWS? Run your CI pipeline? Add the toolkit. It's designed to be the agent framework that grows with your workflow. Apache 2.0. Backed by a major tech company, not a weekend project. The catch: Goose needs an LLM, and the quality of its work depends entirely on which model you use. With Claude or GPT-4, it's impressive. With smaller local models, it struggles on complex tasks. Also: giving an AI agent full access to your terminal is powerful but risky. Always review what it's doing, especially with destructive commands.

Free tool. You pay for whatever LLM API you connect, $30-100/mo typical for active use.

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.

Framework is free. LangSmith observability free up to 5K traces/mo, then $39/mo+.

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. Works with 200+ models through OpenRouter, OpenAI, Anthropic, or Hugging Face endpoints. 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. Runs on a $5 VPS or a GPU cluster. Pick this if you want one agent deployed across messaging apps without rebuilding for each. The closed learning loop (skills accumulated from prior runs) is a real differentiator vs framework-first kits like LangChain or AutoGen. Solo and small teams pay only their model bill. Large teams running their own RL stack already have this layer. The catch: it's 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, not a production-grade agent.

Open source. Cost is your VPS plus the model provider you choose.

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.

Free and open source. The real cost is the hardware to run local models.

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.

Library is free forever. LangSmith tracing costs $39/seat/mo when you need production observability. Your real expense is the LLM API bill.

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. For a developer who wants a capable agent without wiring every subsystem by hand, this is a strong starting point, and the framework is free. Solo builders and teams use it the same way. The paid part of the LangChain ecosystem is LangSmith, which handles production tracing, monitoring, and deployment; you can run Deep Agents without it, but you will want observability once real traffic hits. The catch is the LangChain gravity. Adopting Deep Agents pulls in LangGraph and nudges you toward LangSmith for the production story, and that ecosystem has a habit of abstracting things you might have wanted to control directly. 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; look at a lighter harness instead.

Free framework. You pay for tokens, and optionally for LangSmith once you need production tracing.

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.

The framework is free. Your bill is LLM tokens and hosting, nothing more.

OpenClaw is a self-hosted AI assistant that connects to every chat platform you already use. WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, Matrix, and about 15 more. One local gateway, one brain, every inbox. The setup is real work but the payoff is real too. You run a Node.js daemon on your machine (or a small VPS with Tailscale for always-on). Each messaging channel has its own auth dance: WhatsApp needs phone pairing, Telegram needs a bot token, Slack needs an app. Once wired up, you get voice wake words, browser automation, cron jobs, webhooks, and a skills platform that keeps growing. Solo users: run it on your laptop and bring your own API keys. Power users: put it on a $5 VPS and you have a private AI butler across every platform. There is no paid tier, no cloud service, no data leaving your machine. The catch: "free" still costs money. You need LLM API keys (OpenAI, Anthropic, or local models), and the WhatsApp integration uses an unofficial library that Meta could break tomorrow.

The tool is free. You pay your LLM provider for API calls.

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.

Framework is free. You pay for LLM APIs ($0.05-0.50 per crew run). Enterprise from $199/mo for visual tools and monitoring.

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, and email, and can act through shell, browser, and HTTP tools. Written in Rust, dual MIT and Apache-2.0, free, and you bring your own model keys or run local models with Ollama. Running it is moderate work: you host the runtime, wire up the channels you want, and supply API keys or a local model. The appeal is ownership, your assistant, your data, your machine. The flip side is that you are handing an autonomous agent shell and browser access, so the security and blast radius are yours to manage. This is power-user territory, not a polished consumer app. This is for tinkerers who want a fully self-owned assistant wired into the apps they already use and are comfortable operating an agent with real system access. Solo and small teams: free, and you pay only for model usage. If you want something vetted and accountable with support, the proprietary assistants like ChatGPT with agents, Claude, or Copilot are the safer call, and you pay for that polish. The catch, beyond ops, is trust. The project is active and moving fast, but an autonomous agent that can run shell commands on your box is exactly as safe as your configuration and your model's judgment. Lock down what it can touch before you let it loose, and do not point it at anything you cannot afford to have it act on.

Completely free and open source. You bring your own model keys and run it yourself.

LibreChat is a self-hosted AI chat interface that connects to multiple LLM providers (OpenAI, Anthropic, Google, local models) through a single unified UI. Self-host it and your team gets a unified chat UI that works with whatever models you're paying for (or running locally). No vendor lock-in. MIT license. Multi-model conversations (start with GPT-4, switch to Claude mid-chat), file uploads, code interpreter, plugins, conversation search, and user management are all built in. Docker Compose setup gets you running in minutes. Fully free to self-host. No paid tier, no gated features. You bring your own API keys. Running it locally with Ollama means zero API costs. Self-hosting ops: moderate. Docker Compose handles most of it, but you need MongoDB for the backend. Updates are frequent (active development), which means staying current takes attention. Figure 2-3 hours/month. Solo: self-host, connect your API keys, done. Small teams: add user accounts, share a single deployment. Growing teams: works well but you'll want to think about rate limiting per user. Large orgs: evaluate security hardening. It's not built for enterprise compliance out of the box. The catch: the feature velocity is both a strength and a risk. Breaking changes happen. And while it supports many providers, the quality of each integration varies. OpenAI is rock-solid, others can lag behind.

Free. You pay only for compute hosting and whatever AI APIs you connect.

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.

Framework is free. Your costs are LLM API calls (varies by usage) and optionally LangSmith for tracing ($39/seat/mo).

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.

Framework is free. Your LLM bill is the real cost.

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.

Framework is free and open source under Apache 2.0. You pay for the LLM APIs, vector store, and infra you plug into it. Haystack Enterprise adds managed deployment and governance for larger teams.

Browser Harness gives LLMs raw access to Chrome through a single WebSocket connection. No abstraction layer, no pre-built recipes, just direct CDP (Chrome DevTools Protocol) control. When the agent encounters something it cannot do, it writes new helper functions mid-task. Self-healing browser automation. The entire codebase is under 600 lines of Python. Connect to Chrome with remote debugging enabled, and your agent can navigate, click, fill forms, extract data, and extend its own capabilities on the fly. From the same team that built the browser-use framework, this is the stripped-down version for agents that need complete freedom. Developers building AI agents that interact with websites: this is the thinnest possible layer between your LLM and a real browser. The free tier at cloud.browser-use.com gives you 3 concurrent remote browsers for testing without managing Chrome instances. The catch: "complete freedom" means no guardrails. Your agent can navigate anywhere, click anything, submit forms. You need your own safety layer if you are pointing this at production accounts.

Core is free and MIT. Remote browser hosting has a free tier. Local use costs nothing.

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.

Completely free and open source. You pay for the LLMs, not the framework.

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.

Free software, but the Matrix homeserver dependency means real infrastructure and ops costs.

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.

Free and open source (public beta). You pay normal hosting and model costs to deploy.

ReMe gives AI agents memory that survives past a single session. Agents forget everything when the context window fills up or a new conversation starts, and ReMe fixes that by storing what matters and feeding it back later. It's free and open source under Apache-2.0. It offers two flavors. The light version keeps memory as plain markdown files organized by date, compresses long conversations into summaries, and trims verbose tool output, no infrastructure required. The vector version uses embeddings to store user preferences, task patterns, and tool experience, then retrieves them by meaning. You wire either into your agent's reasoning loop. The catch: memory for agents is a crowded, unsettled space, and ReMe is one approach among several (mem0 and others compete here). The markdown mode is easy to start with; the vector mode adds an embedding model and a store to run and maintain. Good to try if you're building agents that need to remember. Don't expect a finished standard yet.

Free and open source. The vector mode adds an embedding model and store to run.

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.

Self-host for free and get everything. Cloud makes sense at $59/mo when your team outgrows DIY infrastructure.

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.

Fully free MIT-licensed framework. No commercial offering.

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.

Free framework. MiniMax model API costs are separate.

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.

Free. Cloud community is free. You pay for LLM API calls.

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.

Completely free but operationally heavy. Your cost is infrastructure and the engineering time to run 6+ services.

AutoGen is Microsoft's framework for building multi-agent AI systems, where several agents with different roles, tools, and instructions work together or alongside a human to finish a task. You define the agents, and AutoGen manages how they talk, call tools, run code in a sandbox, and pause for your approval. It handles the plumbing of multi-agent coordination so you are not hand-rolling conversation state and tool routing. Here is what you need to know before building on it: AutoGen is now in maintenance mode. Microsoft has named a successor, the Microsoft Agent Framework, and is steering new users there. AutoGen still works, the v0.7 line is stable, and the community manages it going forward, but it will not get new features. The code is MIT (docs and examples are CC-BY-4.0), so it stays free and forkable. If you already run AutoGen in production, you are fine for now, but plan a migration path to the Microsoft Agent Framework rather than starting new work here. If you are picking a multi-agent framework today, start with the successor, or look at CrewAI and LangGraph, which many find easier for simpler workflows. Solo and small teams experimenting: it is still useful for learning the patterns, just know you are learning a frozen API. The catch is that one, stated plainly: this is a framework Microsoft has stopped developing. The star count and the pile of existing tutorials make it look like the safe default, but 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.

Free framework. Your cost is LLM API usage, which multi-agent patterns multiply significantly.

cli-printing-press is a tool that generates other tools. You point it at an API, and it builds a custom command-line interface for that API, optimized for AI agents to use. The generated CLIs have local SQLite caching, fast text search, compound query commands, and structured exit codes, designed so an agent gets predictable, parseable output instead of guessing at JSON shapes. MIT licensed, fully free, written in Go. The generator runs as a standalone Go binary. Install with go install or grab a release. To actually use it, you need a Claude Code subscription because the generation runs inside Anthropic's CLI. Generated binaries are standalone with no runtime or Docker, just a local store at ~/printing-press/. Distinctive positioning here. OpenAPI Generator and Speakeasy generate API clients, but they do not tune for agent workflows. If you are building agent toolchains and want every API connector to behave consistently for an LLM caller, this is worth trying. Otherwise, the existing client generators are fine. The catch: solo project, depends heavily on Claude Code working a specific way. If Anthropic changes their tool-use protocol or pricing structure, this gets stranded.

Free tool, but the generator depends on Claude Code which is $20/mo for Pro or pay-as-you-go API pricing.

Claw3D visualizes AI agent activity as a 3D command center you can watch in real time. Agents sit at desks, review code, run standups, and collaborate in an isometric environment you can watch in real time. Picture a visual mission control for your AI workforce. Each agent gets a customizable 3D avatar with a persistent profile. The office has rooms, navigation, animations, and event-driven activity cues. When an agent starts a code review, you see it happen spatially. Built on OpenClaw, MIT licensed. It's early (just hit open source), but the community is already building on it. The catch: this is a visualization layer, not an orchestration framework. Your agents still need something to make them work; Claw3D just shows you what they're doing. And '3D virtual office' is a concept that sounds cooler than it might be useful day-to-day. If you don't need visual monitoring, this adds complexity for aesthetics.

Free. Self-hosted only.

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.

Free toolkit. You pay only for the AI model API calls.

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.

Self-host free under MIT, or pay roughly $31/user/month for the managed, connected, compliant version.

Notte lets AI agents interact with websites the way a person would (clicking buttons, filling forms, navigating pages) but through a structured API instead of raw browser automation. If you're building an AI agent that needs to do things on the web (book appointments, fill out forms, scrape dynamic content), Notte handles the browser part. The key difference from regular browser automation (Playwright, Selenium): Notte translates web pages into a format LLMs can understand. Instead of your agent parsing raw HTML, it gets a structured representation of what's on the page and what actions are available. The LLM decides what to do, Notte executes it. Early stage. The concept is strong but the project is young. There's a hosted API (pricing on their site suggests usage-based tiers) and you can self-host the Python package. The catch: you're betting on a small team maintaining a tool that sits between your AI agent and the entire web. Browser automation is fragile by nature. Sites change, CAPTCHAs block, rate limits hit. Notte abstracts some of that pain but can't eliminate it. For production agent workflows, compare against Browser Use and Playwright with your own LLM integration.

Free to self-host. Hosted API pricing is unclear, wait for published rates.

AIAC uses LLMs to generate infrastructure-as-code: Kubernetes manifests, Dockerfiles, CI/CD configs, all from plain English prompts. Instead of looking up the exact syntax for an AWS security group or a Helm chart values file, you describe what you want and AIAC produces the code. Go, Apache 2.0. It's a CLI tool that connects to OpenAI, Amazon Bedrock, or Ollama (for local models). You run `aiac get terraform for an s3 bucket with versioning enabled` and it returns the HCL. Supports Terraform, Pulumi, CloudFormation, Ansible, Docker, Kubernetes, GitHub Actions, and more. Fully free as a tool, but you pay for the LLM API calls behind it. Using OpenAI's GPT-4, that's roughly $0.01-0.10 per generation depending on complexity. Using Ollama with a local model, it's free but quality varies. Solo developers: useful for scaffolding infrastructure you don't write every day. Saves the 20 minutes of docs-reading for unfamiliar providers. Small to medium teams: helpful for standardizing templates, but review everything it generates; LLMs hallucinate resource attributes. The catch: zero star velocity and the homepage URL points to a Wikipedia article about LLMs, which is not confidence-inspiring. The generated code needs human review; treat it like a first draft, not a production artifact. And if you're already using GitHub Copilot or Claude in your editor, you get this same capability without a separate tool.

Tool is free. You pay for the LLM API behind it, or use local models for $0.

Memory OS gives an AI agent long-term memory that survives across sessions, and it runs entirely on your own machine. The problem it solves is real: most agents forget everything the moment a conversation ends, so you re-explain the same context every time. This stacks seven layers of memory, from workspace files and a session database up to vector storage in Qdrant and an auto-curated wiki, then pulls the relevant pieces into the prompt before each call. MIT licensed, and it works with OpenAI, Anthropic, OpenRouter, or local Ollama. Running it yourself means standing up Qdrant and wiring the layers in, so the ops burden is moderate, not plug-and-play. The payoff is that your agent's memory is yours: no monthly memory subscription, no data sitting in someone else's vector store. The closest hosted options, mem0, Zep, and Letta, all want a cloud account and a recurring bill. This trades that for hardware you control. Solo builders running a persistent agent and small teams who care where their data lives are the target. If you are already invested in the Hermes Agent ecosystem this is the native memory layer; if you are not, the architecture is the draw more than a drop-in install. The catch is that it is built around Hermes Agent. The seven-layer design is general enough to learn from, but lifting it cleanly into a different agent framework is not free. And memory systems are only as good as their retrieval: inject the wrong context and the agent confidently runs with it.

Free and MIT-licensed. Your only real cost is running Qdrant and paying for whatever LLM provider you point it at.

OptMem gives an AI agent permanent memory in about 426 tokens of prompt and a small script. It's a Python CLI, wake, note, and recall, backed by an append-only log with a binary-tree cache for fast compressed retrieval. The compact prompt teaches the agent how to use it, and the storage design does the heavy lifting underneath. The clever part is the architecture, not the surface. Fixed-width, append-only records let it find a memory in a single disk seek even as the log grows, so recall stays fast without a database or a vector store. It's from Victor Taelin, whose work on HVM, Kind, and Bend gives the systems thinking real credibility. Free and open source, for solo builders and teams experimenting with agent memory. The catch is that it's minimalist by design. This is a small, sharp memory CLI plus an integration prompt, not a full memory framework with retrieval strategies and knobs. The value here is the idea and the storage architecture, plug it in for what it is. If you need a rich, configurable memory layer, you'll outgrow it, but as a lean, fast primitive it's a genuinely smart piece of work.

Free and open source. Minimalist permanent memory for agents.

Tool-ui gives you pre-built React components for rendering those tool calls and their results inside a conversation UI. This is a UI component library specifically for AI tool-calling interfaces. Instead of building your own "here's what the AI did" rendering from scratch, you get components that display tool invocations, streaming results, and error states. It's TypeScript, React-based, and designed to plug into assistant-ui (the parent project's chat framework). Completely free. MIT license, and growing fast. Solo developers building AI chat products will save significant time here. If you're already using assistant-ui for your chat interface, this is the natural add-on. Small teams building internal AI tools get a polished UX without designing tool-call rendering from scratch. The catch: it's nascent. means a small community, potential breaking changes, and limited battle-testing. Tightly coupled to the assistant-ui ecosystem. If you're using a different chat framework, integration will take work.

Fully free. Nascent but promising for anyone building AI chat interfaces with tool calling.

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.

Free for now, but missing LICENSE file and commercial company behind it raise questions.