Open source frameworks for building AI agents: multi-agent orchestration, tool calling, and autonomous workflows.
Ranked by Discovery Score — our 0-100 composite of adoption, maintenance, community, and license health. How scoring works.
By Erik Loyd, SaaS CEO and former COO/CFO of an AWS Premier Partner.
Goose is a local AI agent with full access to your development environment: it writes code, runs commands, and drives your tools using whatever LLM you point it at. Block (the company behind Square and Cash App) built it, then donated it to the Linux Foundation's Agentic AI Foundation, which makes it one of the few coding agents with vendor-neutral governance instead of a single company's roadmap. Apache 2.0, free. Extensibility is the differentiator. Goose extends through MCP servers, so the same connectors that work with other agents plug in here: Kubernetes, AWS, CI pipelines, whatever your workflow touches. It runs as a CLI or desktop app, and releases land steadily, mostly provider integrations and protocol work, plus a patched command-execution advisory in its review feature earlier this summer. Use it if you want an open, vendor-neutral agent you can point at any model, including local ones through Ollama. Quality tracks the model: with a frontier model it's impressive, with small local models it struggles on complex tasks. The catch: giving an agent full terminal access is powerful and risky, so review what it runs, especially destructive commands. And model API costs are the real price. Expect $30-100/mo for daily use unless you go local.
Free tool. You pay for whatever LLM API you connect, $30-100/mo typical for active use.
**Free:** Everything. Apache 2.0, no paid tier, no hosted service, no commercial edition. Block built it and donated it to the Linux Foundation's Agentic AI Foundation, so no single vendor controls the roadmap. **Self-hosted:** It's a local CLI/desktop app, so there is nothing to host. Connect any LLM: Claude or OpenAI means per-token costs, Ollama with a local model means zero marginal cost but lower quality on complex tasks. **Paid:** Nothing to buy. For a developer using it daily, expect $30-100/mo in API costs depending on usage intensity and model choice.
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+.
**Framework (free):** LangChain, LangGraph, all provider integrations, fully open source under MIT. No feature restrictions. **LangSmith (observability):** - Developer (free): 5K traces/mo, 1 user - Plus ($39/mo): 50K traces/mo, 3 users - Enterprise: Custom pricing, SSO, advanced analytics **Do you need LangSmith?** For debugging complex chains, it's genuinely useful. You can see every step, every prompt, every response. But you can also use generic observability tools or just log the intermediate steps yourself. **The real cost:** LLM API calls flow through LangChain to your provider. LangChain adds zero markup. Your costs are your provider's costs. But LangChain's abstractions can encourage longer chains with more LLM calls than necessary, indirectly increasing your API spend.
NemoClaw runs OpenClaw (the open source coding agent) inside NVIDIA's OpenShell sandbox with managed inference, solving the real security risk of agents executing arbitrary code on your machine. Your agent gets GPU-accelerated model inference through NVIDIA's infrastructure while staying sandboxed. This is NVIDIA saying 'run your coding agents on our hardware, securely.' You get the performance of NVIDIA GPUs for inference without managing the infrastructure yourself. The sandbox prevents the agent from doing anything destructive to your system. Apache 2.0 licensed. The catch: this ties you to NVIDIA's ecosystem. You need NVIDIA hardware or their cloud infrastructure, no running this on Apple Silicon or AMD GPUs. It's OpenClaw-specific, so Claude Code and Cursor users are out. And 'managed inference' is a gateway to NVIDIA's paid compute. The tool is free but the GPU time may not be.
Tool is free. GPU compute costs depend on whether you self-host or use NVIDIA's cloud.
Open source under Apache 2.0. The NemoClaw tool itself is free. Self-hosting requires NVIDIA GPUs. NVIDIA's managed inference (OpenShell) may have usage-based pricing for GPU compute; check NVIDIA's current pricing for NIM/OpenShell. Self-hosted: free if you already own NVIDIA hardware. Managed: likely usage-based GPU pricing through NVIDIA's platform.
DeerFlow is ByteDance's open source answer to Manus and ChatGPT's agent mode: an agent harness built to work a task for minutes or hours, not just answer a prompt. It ships the whole stack (backend, web UI, sandboxed execution, chat gateways for Slack, Telegram, Discord, and more) and gives the agent a real filesystem, persistent memory, loadable skills, and sub-agents to delegate to. MIT licensed, completely free. Self-hosting is real work. Python, Node, and nginx, an interactive setup wizard, Docker as the recommended path, and a hardware floor around 4 vCPU and 8 GB of RAM just to evaluate it. It's model-agnostic through any OpenAI-compatible API. The README is refreshingly blunt that improper deployment introduces security risks: this thing runs code, so it's designed to stay bound to localhost unless you put auth and network isolation in front of it. Use it if you want long-horizon agents on your own infrastructure with your choice of models. Solo and small teams: free, plus tokens. If you just want agent orchestration as a library, LangGraph (which DeerFlow builds on) or CrewAI is the lighter path, and OpenHands is the closest open comparison. The catch: 2.0 is a ground-up rewrite that shares no code with v1, so the project is popular but the current codebase is young, with a long open-issue tail. And an agent with shell access is a loaded tool. Mount credentials into its sandboxes carelessly and you'll regret it.
Completely free and MIT licensed. Your bill is model tokens, hardware, and optional E2B sandbox costs.
**Free:** Everything. MIT licensed with no paid tier, no hosted cloud, no enterprise SKU. The only CTA on the project site is self-hosted setup. **Self-hosted:** The only mode. Docker recommended; 4 vCPU / 8 GB RAM to evaluate, 8 vCPU / 16 GB for production, SQLite by default with Postgres for real deployments and Redis for multi-worker. **The real costs:** Model tokens on whatever OpenAI-compatible API you connect, plus optional E2B sandbox usage if you don't run sandboxes locally.
gstack is Garry Tan's (YC CEO) Claude Code workflow as a public repo. It ships 23 specialized agents that act like a virtual engineering team, plus slash commands like /office-hours, /review, and /ship that drive end-to-end product work from one terminal. The agents play roles: CEO, designer, engineer manager, QA lead, and more. The idea is that a solo dev orchestrates the team through commands instead of doing every job in series. TypeScript core with some Go for the parts that need speed. Everything lives in .claude/, nothing touches your PATH, and a persistent Chromium browser daemon handles visual testing and QA loops. MIT licensed. Solo devs and tiny teams are the target. If you're already shipping by yourself with Claude Code, this is a real upgrade. Bigger teams will trip over the opinionated roles, since you already have a real designer and QA lead and don't need an agent pretending to be one. The catch: this is one founder's workflow turned into a kit. If your style doesn't match Garry's, you'll fight the agents instead of using them. It's also Claude Code only. No Cursor, no Codex, no swap-in for other harnesses.
Free. You pay only for your existing Claude Code subscription and the tokens the agents burn.
Fully open source under MIT. No paid tier, no hosted version. You clone the repo into your project's .claude directory and use it with Claude Code. Cost is whatever you already pay for your Claude Code subscription plus the API tokens the agents burn through during a session.
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.
The agent is MIT and free with no feature gates. Nous Research now sells optional model access at $20, $100 and $200 per month (Plus, Super, Ultra), each bundling 300+ models into one bill.
### Free (Open Source) - MIT licensed agent, one-command install on Linux, macOS, WSL2 or Termux - Skill accumulation across sessions, persistent memory - Built-in connectors for Telegram, Discord, Slack, WhatsApp, Signal and email - Provider-agnostic: OpenRouter, OpenAI, Anthropic, Hugging Face endpoints or a local model - No feature gates. Every capability is in the open source build - Nous Portal has a free tier if you want to try their model access without paying ### Paid Nothing for the software. Nous Research sells model access through Nous Portal, and Hermes can use it: - Plus: $20 per month. Super: $100 per month. Ultra: $200 per month - All paid tiers cover 300+ models, hosted tool use, higher rate limits and usage-cost discounts - Each tier includes a monthly credit allowance roughly equal to its price, with unused credit rolling over up to a cap. Nous does not publish the exact allowances outside the portal, so check them at signup rather than trusting a number quoted elsewhere ### Self-Hosted Costs A $5 per month VPS runs it. A dedicated box with more memory helps if you connect several messaging platforms at once. The dominant cost is inference, not hosting: an agent that acts on messages around the clock will spend far more on tokens than on the server. Local models drop that to electricity and hardware. ### When to Pay You never have to. Bring an OpenRouter key and skip the subscription entirely. Nous Portal is worth it when you would rather pay one bill than reconcile four provider accounts, or when the rate limits and usage discounts on Super or Ultra beat what you are paying retail. Do the arithmetic against your current token spend before subscribing, because the credit allowance roughly tracks the price of the plan.
MemPalace stores your AI conversation history verbatim and searches it semantically. Every Claude session, every project file, indexed locally. The structure is a metaphor: projects become wings, topics become rooms, so you can scope searches instead of querying a flat blob. It publishes 96.6% recall on LongMemEval with no LLM in the loop, and the benchmarks are reproducible from the repo. Install is pip plus pointing it at a directory. ChromaDB is the default backend, embeddings run on CPU with a 300MB model, no API key required. The MCP server exposes 29 tools so Claude Code can read and write the palace directly during a session. Solo developers using Claude Code heavily: install it. The 'wake-up' command that loads relevant context for a new session is the pitch and it works. Small teams: each engineer runs their own palace, there is no shared knowledge layer yet. The catch: it's about two weeks old. The benchmarks are real but the operational track record is not. Breaking changes will happen, and fast-growing projects attract impostor domains. The README has a scam alert for a reason.
Free and open source. Runs entirely offline if you want.
**Free and open source.** MIT license. `pip install mempalace` and you're running. ChromaDB is the default backend, all free. Embeddings run on CPU using a local model of about 300MB, no API key required. The full 96.6% recall path runs entirely offline. **Optional paid:** None from the project. If you swap in OpenAI embeddings or use an LLM for the rerank tier, you pay those providers directly. The core retrieval path has no cloud dependency. No Cloud tier, no paid version, no company behind it yet. That's a feature if you care about data control and a risk if you need support.
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.
### What's Free The entire LangChain JS library. MIT license, no restrictions. All chains, agents, retrievers, memory, and model integrations are free. ### What Costs Money (Ecosystem) - **LangSmith** (tracing/debugging): Free tier with 5,000 traces/mo. Pro at $39/mo per seat for unlimited traces. - **LangGraph Cloud** (hosted agent deployment): Pricing varies, starts around $50/mo. - **The LLM APIs you connect to**: OpenAI ($0.002-0.06/1K tokens), Anthropic (similar), etc. This is your real cost. ### The Hidden Cost LangChain's abstractions mean more tokens per request (system prompts, chain formatting). A direct API call might use 500 tokens where LangChain uses 800 for the same result. At scale, that's 60% more on your LLM bill. ### When to Pay for LangSmith When you're debugging agent behavior in production and need to see exactly what prompts were sent and what came back. The free tier is enough for development. Pay at $39/seat when you're running production agents and need full observability.
QwenPaw is a personal AI assistant you run yourself instead of renting from OpenAI. It ships with a local runtime so it works with no API key out of the box, and it also plugs into Ollama, LM Studio, and a dozen-plus cloud providers if you want bigger models. The hook is reach: it talks to you through Discord, Telegram, Lark, WeChat, DingTalk, even iMessage, and you extend what it can do with skills. It is open source under Apache-2.0, built by the team behind AgentScope, Alibaba's multi-agent framework. Self-hosting is the default here, not an afterthought. There is Docker support and a one-click path to deploy on Alibaba Cloud if you would rather not run it at home, in which case you pay for the cloud, not the software. It takes its own security seriously for a personal tool: a kernel-level sandbox, a Tool Guard, and a File Guard sit between the model and your machine, which matters once an assistant can run code and touch your files. For a solo developer or a tinkerer who wants an assistant that lives in their own chat apps and on their own hardware, this is one of the more complete self-hosted options going, and it costs nothing. Small teams can share an instance. There is no real large-team story here; it is a personal workstation, not a company-wide deployment, and that is fine. The catch is gravity. It is deep in the Alibaba and Qwen ecosystem, the docs are heavily multi-language, and a lot of the built-in channels (WeChat, DingTalk, Lark) point at a Chinese user base. None of that is a flaw, but if you expected a Western-defaults, English-first assistant, calibrate before you install.
Free and open source under Apache-2.0. You only pay if you choose cloud hosting or paid model APIs.
**Free:** Apache-2.0, the whole thing. Local runtime (no API key needed), all the chat-channel integrations, the skills system, the sandbox. **Self-hosted:** The primary way to run it. Docker locally, or one-click to Alibaba Cloud where you pay infrastructure costs, not a license. **Paid:** None for the software. Your only costs are optional: cloud hosting if you do not self-host, or API fees if you point it at paid model providers instead of the local runtime.
Supermemory is a memory and context engine for AI apps. It extracts facts from conversations and documents, keeps a profile of each user, and runs hybrid search that blends RAG with personalized recall, all behind one API. The company reports top scores on the major memory benchmarks. The main repository is MIT, and plugins exist for Claude Code, Cursor and Codex. Running it locally is one command, `npx supermemory local`, which starts a single binary with the same API as the hosted platform. It works fully offline with a local model through Ollama, and your data stays on your machine. The local server is single-user and licensed for up to 10,000 documents, though, and the connectors for Google Drive, Gmail, Notion and OneDrive, plus the Supermemory MCP, only exist on the hosted platform. Hosted pricing is published and credit-based. Free includes $5 of credits a month and pauses when they run out. Pro is $19/mo with pay-as-you-go top-ups, Max is $100/mo, and Scale at $399/mo adds S3 and web crawler connectors, unlimited seats and a self-hosted option. Teams building production memory will land on Pro or Scale. The catch is maturity. The local server is still version 0.0.x, and one August release was an emergency patch after an upgrade silently wiped search vectors. The consumer app and browser extension were retired in September too. Build on the API, pin versions, and back up your data.
Free locally up to 10,000 documents, or with $5/mo of hosted credits. Hosted plans run $19, $100 and $399 a month.
**Free tier:** The main monorepo is MIT, the TypeScript and Python client SDKs are Apache-2.0, and plugin licenses vary. A free local server runs ingestion, memory extraction, hybrid search and the full API on your own model key or a local model, up to 10,000 documents. The hosted Free plan includes $5 of credits a month, all plugins, the full search and memory API, 1 team seat and unlimited end users, and pauses when credits run out. **Self-hosted:** Install with `curl -fsSL https://supermemory.ai/install | bash` or `npx supermemory local`. The server ships as a prebuilt binary called supermemory lite, is licensed for up to 10,000 documents with the cap enforced at the API, runs a single org with one auto-generated API key, and stores data locally. Extraction runs on whatever model you point it at, including Ollama. Connectors and the Supermemory MCP are hosted-only. Production self-hosting of the full platform is a Scale and Enterprise feature. **Paid:** Pro is $19/mo ($20 of credits, pay-as-you-go top-ups, 3 seats). Max is $100/mo ($130 of credits, Gmail connector). Scale is $399/mo ($600 of credits, S3 and web crawler connectors, unlimited seats, SOC 2, HIPAA BAA, self-hosted option). Enterprise is custom with SSO, air-gapped self-hosting and an uptime SLA. Usage bills per unique SM token: memory at $0.005 (plain text) or $0.010 (rich content) per 1K, SuperRAG at $0.001 or $0.002 per 1K, and search at $0.005 per 1K queries.
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.
Free MIT framework. You pay for tokens, and for LangSmith Plus at $39 per seat per month if you want its tracing and deployment.
**Free tier:** The framework is MIT licensed with nothing held back: filesystem, sub-agents, context management, shell execution, persistent memory, human-in-the-loop approvals and skills, built on LangGraph and usable with any tool-calling model. A JavaScript/TypeScript port is also free. **Self-hosted:** Runs wherever Python 3.11+ runs. Install with `uv add deepagents`; your cost is model tokens. `langsmith`, `langchain-anthropic` and `langchain-google-genai` install as required dependencies. **Paid:** Nothing for the framework. LangSmith, LangChain's commercial platform, has a free Developer plan (1 seat, 5K base traces a month) and Plus at $39 per seat per month (10K base traces, deployment access, one free small serverless deployment), with pay-as-you-go usage beyond that. Enterprise is custom. Managed Deep Agents, a hosted runtime inside LangSmith, is in private preview.
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.
**Free tier:** The entire framework is free under the MIT license. Multi-agent runtime, RAG document ingestion, connectors for Discord, Telegram, and Farcaster, plus a web dashboard. No paid edition, no gated features. **Self-hosted:** This is the only way to run it. You bring your own LLM key (OpenAI, Anthropic, Gemini, Llama, or Grok) and your own infrastructure. Needs Node 24+ and Bun. Deploy locally or push to Vercel, Cloudflare, AWS, or GCP at those providers' normal rates. **Paid:** None from elizaOS itself. Your costs are LLM API tokens and whatever hosting you pick.
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.
### Free Tier Completely free and open source under MIT. No paid tier exists. ### Self-Hosted Run a Node.js gateway locally or on a VPS. Bring your own LLM API keys. Each messaging channel requires separate configuration. ### Paid None for the tool. LLM API costs depend on your provider and usage.
Everything Claude Code (ECC) is a plugin you install through the Claude Code marketplace that bundles 63 agents, 249 skills, 79 commands, hooks, MCP server configs, and security enforcement scripts into one harness. The pitch is: stop hand-rolling your CLAUDE.md and skills, install this and get a curated set that actually works. It's MIT licensed and works across Claude Code, Cursor, OpenCode, and Codex, not just Claude. The agents cover the usual suspects (code review, security analysis, planning, language-specific reviewers) and the skills span TDD, video editing, and dozens of niche workflows. Hooks auto-execute on editor events. The security scanning piece tries to catch prompt injection and rule violations before they hit your codebase. Solo devs and small teams using AI coding agents get the biggest lift here. Pulling in 63 agents you didn't ask for is overkill, but cherry-picking the ones that match your workflow is the real value. Large teams will probably want to fork it and trim aggressively. The catch: 249 skills is a lot of surface area to audit. You're trusting someone else's prompt engineering to run inside your editor. Read the security-relevant pieces before you turn the hooks on, and treat this as a starting template, not gospel.
Free and open source. You pay for the LLM API or subscription behind whichever harness you run it on.
Fully open source under MIT. No paid tier for the plugin itself. The ecc.tools site may host extras, but the GitHub repo has the full bundle. Your cost is the LLM API or subscription you already pay for whatever harness you run this in.
Graphify reads your entire codebase, docs, PDFs, and even screenshots, then builds a knowledge graph you can actually navigate. It parses 19 languages via tree-sitter for code and uses an LLM for everything else. The result is an interactive HTML visualization showing how your architecture, concepts, and files connect. The first extraction pass costs real API tokens (Claude or GPT), proportional to your corpus size. After that, incremental updates via SHA256 caching mean re-runs only process changed files. The 71x token compression claim is real for subsequent queries, not the initial scan. Runs as a /graphify slash command inside Claude Code, Codex, or OpenCode. For developers onboarding to large or unfamiliar codebases: this is genuinely useful. Architecture reviews, cross-referencing code with design docs, understanding how a monorepo fits together. Exports to Neo4j, Obsidian vaults, or standalone wikis. The catch: it is a plugin, not a standalone tool. You need Claude Code or a compatible AI assistant as the runtime. Quality of inferred relationships depends on the underlying LLM, and the initial scan of a large repo is not cheap.
Tool is free. LLM API costs for extraction depend on corpus size.
### Free Tier Fully free under MIT. No paid tier or hosted service. ### Self-Hosted pip install, then run as a slash command. No server or database needed. All local. ### Paid None for the tool. You pay for LLM API tokens during extraction passes.
Career-Ops turns your AI coding CLI into a full job search command center. Paste a job URL and get back a structured report broken into blocks A through H, with a single 1 to 5 score reached by holistic judgement across five dimensions. It generates tailored, ATS-optimized PDF resumes per application. One developer used it to evaluate 740+ offers and land a Head of Applied AI role. The system gets smarter over time. It builds an interview story bank in STAR format, ships a scanner preloaded with 100+ companies and 45+ search queries, and can batch-evaluate offers in parallel using sub-agents. The dashboard is a Go TUI built on Bubble Tea, so you browse the entire pipeline from the terminal, and an experimental web UI is available as an opt-in alpha. Running it needs Node.js and Playwright for the PDF generation and portal scanning. Solo job seekers running any AI coding CLI: this is a force multiplier. It used to be Claude Code only, and now it also works with Gemini, OpenCode, Qwen, Grok, Codex, and Kimi, several of which have free tiers. It does not replace your judgment, it structures it. The human in the loop design means the AI evaluates and you decide. The catch: the tool is free, but it leans on an AI CLI underneath, so your real cost depends on which provider you pick and how hard you run it. The preloaded company list skews heavily toward AI and tech companies. And the first evaluations are rough until you feed it enough context about yourself.
Free and open source (MIT). Runs on any AI coding CLI, including free options like Gemini CLI.
### Free Tier MIT license, no paid features. All functionality is in the open source repo. ### Self-Hosted Clone, npm install, and install Playwright for PDF generation and portal scanning. All data is stored locally in markdown and YAML files. ### Paid None for the tool itself. It runs on top of an AI coding CLI: some are paid (Claude Code), others have free options (Gemini CLI, Qwen), so the real cost is whatever provider you choose.
MemPalace gives your AI assistant a long-term memory you actually own. It stores conversations and documents verbatim, nothing summarized away, then lets the assistant pull back the exact relevant pieces with semantic search. MIT licensed, free, no API key required, organized around a memory-palace metaphor: wings for people and projects, rooms for topics, drawers holding the original content. It started life strictly local, and that's still the default: a Python install, a pluggable vector backend (ChromaDB by default; Qdrant, pgvector, Milvus, and SQLite all work), and an MCP server with auto-save hooks for Claude Code. It has since grown past one machine. Recent releases added a team server with TLS and authentication, an HTTP transport for the MCP server, and a coordination layer that lets agents on different machines hand work to each other. Solo developers who want their assistant to remember context across sessions without shipping every conversation to a vendor: this is one of the strongest local options going. Small teams can now share one memory server instead of syncing folders. The closest comparison, supermemory, leans on a hosted API; MemPalace's pitch is that everything stays yours. The catch is pace. It ships releases constantly, and the feature set moves month to month. Pin your version if you depend on it.
Completely free and open source: no cloud, no API key, no paid tier, whether you run it locally or as a team server.
**Free:** Everything. MIT licensed, no hosted tier, no API key required. Run it locally or stand up the team server on your own hardware with the vector backend of your choice. **Cost you'll actually pay:** Your own compute, plus setup time to wire the MCP server and pick a backend. The team server adds TLS certificates and auth config to manage. Optional reranking can call a hosted model, but the core runs without any API. **The trade:** You keep all memory data on machines you control and pay nothing, in exchange for running and updating a fast-moving codebase yourself.
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.
### Free Tier Open source framework under MIT. All core features (agents, tasks, crews, tools, sequential/parallel execution) are free. No restrictions. ### Paid (CrewAI Enterprise) Teams: $199/mo, visual builder, monitoring, 5 team members. Business: $499/mo, advanced features, 20 team members, priority support. Enterprise: custom pricing. ### Self-Hosted Costs The framework is free. Your costs are LLM API calls. A multi-agent crew processing one request might cost $0.05-0.50 in API calls depending on models and complexity. At scale, this adds up. ### When to Pay Pay for Enterprise when you need visual workflow building, production monitoring, or team collaboration on agent design. The open source framework handles everything else.
oh-my-claudecode turns Claude Code into a multi-agent team coordinator. You describe a job in plain language and it dispatches specialized agents that plan, build, review, and test in parallel, passing work between themselves without you driving each step. MIT-licensed, installs through the Claude Code marketplace or as an npm CLI. No server to run. It lives inside your Claude Code session and extends the built-in agent tooling. The canonical mode is now explicit team orchestration via /team syntax, which replaced the older swarm keyword. It also routes compatible work across other CLIs you have installed (Codex, Gemini, Grok, Cursor) to save Anthropic tokens, and extracts reusable skills as it goes. Solo developers get a structured way to run long, multi-step tasks without micromanaging each agent. Small teams get a shared pattern for agent pipelines instead of everyone rolling their own. There is no paid tier and no cloud version. You bring your own Claude Max, Pro, or API key. The catch: it moves extremely fast, and that speed shows. Releases land constantly and keywords get deprecated mid-stream (swarm and autoresearch already went), so a setup that worked last month may need adjusting. Multi-agent pipelines also burn tokens faster than a single prompt, and if you don't trust the autopilot, you will review more code than you write.
Completely free and open source. Optional Gemini/Codex integrations save tokens.
**Free tier:** Fully MIT-licensed. No paid tier, no premium features. **Self-hosted:** Nothing to host in the traditional sense. It runs inside your Claude Code session as a plugin. Optional integrations with Gemini CLI and Codex CLI route compatible tasks to those providers for token savings. **Paid:** None. The creator accepts GitHub sponsorship but all features are free.
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.
Completely free and open source. You bring your own model keys and run it yourself.
**Free:** Dual MIT or Apache 2.0, fully free. The project's site says there is no subscription and no hosted seat. You supply your own LLM API keys, a supported subscription login, or local models through Ollama. **Self-hosted:** The only mode. You host the runtime, wire up channels, and provide the models. Costs are your hardware and your model usage. **Paid:** None for ZeroClaw itself. ZeroRouter, an OpenAI-compatible model gateway from the same team, launched in beta with a public hosted deployment that requires a key. Its pricing is not published in readable form, and it can be self-hosted under AGPL.
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.
**Free / self-hosted:** All of it. MIT-licensed, runs entirely on your own hardware. You bring your own models (served locally) or your own API keys for hosted ones. **Paid:** None from the project. Your real cost is compute: a capable GPU or plenty of RAM to run useful local models, plus any token costs if you point it at a hosted API.
This is a library of more than 2,000 reusable SKILL.md playbooks for coding agents. Skills are structured prompts that teach an agent a specific job (write tests, harden a web app, run a data pipeline), and the project installs them into Claude Code, Cursor, Codex, Gemini CLI, Kiro, OpenCode and others. MIT for the code, CC BY 4.0 for the content unless an upstream notice says otherwise, free. You install with `npx agentic-awesome-skills` plus a tool flag like `--claude`, and the installer now makes you choose: named skills, a risk, category or tag filter, or explicit consent for the whole catalog. The project itself says to start with a focused plugin instead. Newer releases add AAS Core, an optional local CLI and MCP server that lets an agent search the catalog and validate the skills it picks. For anyone building an agent workflow, this is a fast way to skip writing every skill from scratch. Solo developers and teams get the same value, since skills are just files you version alongside your project. The catch is curation. Thousands of community skills mean variable quality and overlap, and an installed skill is a prompt your agent will follow. The catalog labels some skills critical or offensive, and an audit command flags network, credential and destructive signals, but the project calls that a review aid, not a safety certificate. Read the ones you install.
Free and open source. The real cost is the time it takes to vet the skills you install.
**Free tier:** MIT code and CC BY 4.0 content, where more specific upstream notices can override: 2,000+ skills, the installer CLI, focused plugins, bundles, risk labels, an audit command, and the AAS Core preview. Funding comes from optional GitHub Sponsors and Buy Me a Coffee. **Self-hosted:** Nothing you have to run. Skills install as files into your agent's config directory through `npx`. AAS Core's `aas` CLI and MCP server run locally if you opt in; its apply and recovery features are still experimental. **Paid:** None.
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.
Fully open source under MIT. No paid tier. Self-host with Docker Compose. Your costs are: - Compute: a small VPS ($5-20/mo) runs it fine - MongoDB: free tier on Atlas or self-hosted - API keys: whatever you spend with OpenAI/Anthropic/etc. - With Ollama: $0 API cost if you have local GPU Total self-hosted cost: $5-20/mo compute + your AI API spend.
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).
### Free Fully open source under the MIT license. No feature gates, no usage limits. ### LangSmith (Companion SaaS) LangChain offers LangSmith for tracing and monitoring agent runs: - **Developer:** Free, 5K traces/month - **Plus:** $39/seat/mo, 50K traces/month, team features - **Enterprise:** Custom pricing LangSmith is optional but genuinely useful for debugging agent behavior. You can use OpenTelemetry alternatives instead. ### The Math LangGraph itself: $0. Your costs are LLM API calls, which depend entirely on your agent's behavior. A simple agent making 3 LLM calls per task at $0.01 per call costs $0.03/task. An agent that loops 20 times researching might cost $0.20/task. LangGraph doesn't change these costs; it just orchestrates them.
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.
The framework is fully open source and free to self-host. Cloud is $39/mo Pro or $100/seat Team, and what you are buying is thread persistence and retention, not framework features.
### What's Free The full open source framework. React and Angular packages, the runtime, generative UI, frontend and backend actions, state sharing, agent integrations. Self-hosted, unlimited use, bring your own LLM keys. ### CopilotKit Cloud - **Developer**: free forever, 1 developer. 3-day thread retention, 200 max threads, 1 GB storage, 1 Slack/Teams org with 5 channels. - **Pro**: $39/mo. 5-day retention, 5,000 threads, 10 GB storage, 10 channels, 2,000 monthly credits. - **Team**: $100/seat/mo up to 5 seats. 14-day retention, 25,000 threads, 100 GB storage, 2 orgs, 20 channels, 5,000 monthly credits, dedicated Slack support, and a self-hosting option. - **Enterprise**: custom. Unlimited threads, custom retention, VPC/on-prem, SLA, and up to 5 hrs/week of engineering time. ### Self-Hosting Cost Effectively zero beyond your existing app hosting. There is no database to run unless you want thread persistence, which is the thing Cloud is selling. ### The Real Cost LLM tokens. A copilot with broad read access to app state sends that context every turn, so token spend tracks context size more than user count. Measure it on a real page before you extrapolate. ### The Math Self-hosting plus your own Postgres for thread storage is a day of work and roughly $10-20/mo of database. Pro at $39/mo buys you out of that day and the maintenance. Team at $100/seat is a different question entirely, and at that price the self-hosting option it unlocks is the reason to buy it.
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.
### What's Free The entire framework. Apache 2.0, installed with pip install haystack-ai. Pipelines, agents, retrievers, rankers, generators, memory, tool-calling, and evaluation are all open source with no feature gate. ### Self-Hosted The framework is free; the stack around it is not: - **LLM**: an API (OpenAI, Anthropic, and others) or a local model you host. - **Vector store**: bring your own (Postgres/pgvector, Qdrant, Weaviate, Elasticsearch). - **Infra**: you deploy and scale the app yourself. ### Paid Option Haystack Enterprise (by deepset) layers support, templates, managed deployment, observability, and governance on top, available as cloud or self-hosted. Pricing is enterprise sales; the core framework stays free. ### vs Alternatives - **LangChain**: larger ecosystem, more integrations, busier API. - **LlamaIndex**: data and RAG first, excellent for indexing-heavy apps. - **Haystack**: clean pipeline model with explicit control, strong for production RAG and agents.
Cc-switch wraps them into a single Tauri-based GUI. Cross-platform, open source, and free. Consider it a launcher that lets you switch between agents without context-switching between terminals. Setup is straightforward: download the app, configure your API keys, and pick which agents you want active. It doesn't add intelligence on top of the agents themselves. It's a convenience layer. The value is entirely in the unified interface and the ability to compare agent outputs side-by-side. Solo developers who already use multiple coding agents will get the most out of this. Teams probably don't need it since most teams standardize on one agent. If you only use one coding agent, there's nothing here for you. The catch: it's a wrapper, not a product. If the underlying agents change their CLI interfaces (which they do, frequently), cc-switch breaks until someone updates the integration. You're adding a dependency on a third-party GUI for tools that already work fine in a terminal.
Completely free. Funded by API proxy sponsors, not product sales.
**Free tier:** Everything. MIT-licensed desktop app with no paid features. **Self-hosted:** N/A. Desktop app with local SQLite storage. No server component. **Paid options:** None. The project is sponsor-funded by API proxy services, not by selling the tool itself.
Cherry Studio puts every LLM behind one desktop window: chat with OpenAI, Claude, Gemini, or a local Ollama model from the same app, with hundreds of preconfigured assistants, knowledge bases, document processing, and MCP support for calling external tools. Download it for Windows, Mac, or Linux and it just runs. No server, no Docker. The Community Edition is AGPL-3.0, and unusually for dual-licensed projects, there's no seat cap or revenue threshold hiding in the license file: commercial use is allowed outright as long as you comply with AGPL. The paid commercial license exists purely to buy an exemption from AGPL obligations, and a separate Enterprise Edition adds private deployment, an admin console, RBAC, and quota management at quote-only pricing. Solo and small teams: free, plus whatever API keys you plug in. Open WebUI and LibreChat are the browser-based comparisons; Jan and Chatbox are the desktop ones. Cherry Studio's edge is breadth: assistants, agents, knowledge bases, and MCP in one polished client. The catch: the enterprise side is oriented to the Chinese market (Alipay and bank transfer, quote-based sales), the license terms have been revised repeatedly over the project's life, and the issue tracker runs long. Read the AGPL before you fork it into a product.
Free desktop app under AGPL. The paid license only buys an exemption from AGPL; Enterprise is quote-only with China-oriented payment rails.
**Free (Community Edition):** The full desktop app for Windows, macOS, and Linux under AGPL-3.0. Commercial use permitted under AGPL terms with no seat caps or revenue thresholds. Your API keys, your token costs. **Commercial license:** Quote-based, and it buys exactly one thing: exemption from AGPL obligations for teams shipping modified builds. **Enterprise Edition:** Cloud-hosted or private-deployed workspace with centralized model management, RBAC, user and quota management. Pricing is not public; sales run through bd@cherry-ai.com with Alipay and bank-transfer payment. Teams outside China should expect friction buying it.
LobeHub is the rebrand of LobeChat, and it grew up. What started as a slick self-hosted ChatGPT interface is now an agent operations platform: you build a team of AI agents, give them schedules and skills, and let them run tasks around the clock. It plugs into OpenAI, Claude, Gemini, and local models, with thousands of MCP plugins for tools and data. Open source under LobeHub's own community license, free to self-host, with a hosted cloud tier if you would rather not run it. Self-hosting is a Docker job, and it is genuinely one-click on Vercel, Zeabur, or Sealos when all you want is the chat experience. The interface is the easy part. You bring your own model API keys, so the real cost is whatever OpenAI or Anthropic charges per token, not the software. Running the full agent-operations layer with scheduling, agent groups, and persistent memory is more involved than the basic chat deployment. Solo builders should self-host: free, trivial setup, and a private front end for every model you use. The cloud tier meters credits rather than seats, which changes the math. Free gives you 500,000 credits a month, 10 MB of storage, and a short model list. Starter is $12.90 a month, or $9.90 if you pay yearly, for 5 million credits and access to Claude Sonnet 5. Premium is $24.90 monthly or $19.90 yearly for 15 million, and Ultimate is $49.90 or $39.90 for 35 million. Small teams that would rather buy credits than run Docker land on Starter or Premium. Enterprise is quoted for private deployment. The catch is the license. It is not plain MIT, and any organization standardizing on this internally needs to read the community license terms before it becomes load-bearing. The 24/7 agent-team story is also new, and how it holds up under real production load is still unproven.
Free to self-host under LobeHub's community license, which is not OSI open source. Hosted cloud is credit-metered: free at 500,000 credits a month, then $12.90, $24.90 and $49.90 a month for Starter, Premium and Ultimate, dropping to $9.90, $19.90 and $39.90 if you pay yearly.
### Free (Open Source) - Self-hosting is free under the LobeHub Community License, which is not an OSI-approved license - Docker image plus one-click deploy to Vercel, Zeabur or Sealos - Multi-model support (OpenAI, Claude, Gemini, local models) with your own API keys - Thousands of MCP plugins for tools and data - Agent teams, scheduling and memory in the self-hosted build - Hosted free plan: 500,000 credits per month, 10 MB file storage, limited model list (DeepSeek V4 Pro, Grok 4.6, Claude Haiku) ### Paid - Starter: $12.90 month to month, or $9.90 per month billed yearly ($118.80 per year, the 20% annual discount). 5,000,000 credits per month, 1 GB storage, expanded models including Claude Sonnet 5. Roughly 900 DeepSeek V4 Pro messages - Premium: $24.90 month to month, or $19.90 per month billed yearly ($238.80 per year). 15,000,000 credits per month, 2 GB storage, priority email support. Roughly 2,600 messages - Ultimate: $49.90 month to month, or $39.90 per month billed yearly ($478.80 per year). 35,000,000 credits per month, 4 GB storage, priority chat and email support. Roughly 6,000 messages - Enterprise: custom pricing for private deployment and custom solutions - Paid tiers also add early access to newly released models ### Self-Hosted Costs The software is free. A Docker deployment fits on a $10 to $20 per month VPS for personal use; the agent-operations layer with scheduled 24/7 runs wants more memory and a real database, so budget $40 to $80 per month. On top of that sit your own model API keys, which is where the money actually goes: token spend dwarfs hosting for anyone using the agents seriously. ### When to Pay Pay for cloud when you do not want to run Docker and you would rather buy pooled credits than juggle provider keys. The tiers are priced on credits, not seats, so a solo user burning a lot of tokens can justify Ultimate while a small team on light usage stays on Starter. Self-host when you want your keys and conversation history on your own box, or when your token spend is large enough that buying credits at retail stops making sense.
Diagram-design is a Claude Code skill for editorial-quality diagrams. Architecture sketches, flowcharts, sequence diagrams, quadrants, pyramids. 13 types total, all rendered as self-contained HTML and SVG with no JavaScript or build step. The output is opinionated: low density, restrained color, accent used sparingly on the one or two things that matter. It looks like something a design team made, not generic AI output. Install is clone or plugin, then tell Claude to onboard it to your website and it pulls your brand palette and typography from your homepage. After that every diagram uses your colors. The skill activates automatically when you ask for a diagram. Solo writers and technical bloggers: install it. Small teams with a brand style guide: install it team-wide and onboard to your site. Large teams with a design system: the editorial constraints may conflict with your existing design language, evaluate first. The catch: the plugin route puts the skill in a cache that updates overwrite, so style-guide customizations get wiped unless you clone the repo and symlink. And the opinionated style is the whole pitch. If you want Mermaid-style diagrams, this is the wrong tool.
Free. Requires Claude Code to use.
**Free and open source.** Clone the repo or install via Claude Code's plugin marketplace. No paid tier, no cloud service, no premium version. The onboarding flow reads your website with Claude and writes the color tokens to a local file. All inference runs in your Claude Code session using your existing plan. No third-party API keys required beyond what Claude Code already needs. If you are already paying for Claude Code, there is no additional cost. If you are not, this isn't the reason to start.
OpenViking is a context database built specifically for AI agents. Instead of the usual pile of vector embeddings, it organizes an agent's memory, retrieved documents, and skills the way a filesystem organizes files: directories you can navigate, tag, and search recursively. It is open source under AGPL-3.0. Setup is heavier than a typical pip install. You will need Python 3.10+, a Rust toolchain for building the RAGFS component, and a C/C++ compiler for the core extensions, on top of wiring up a vision-language model and an embedding model (Volcengine Doubao, OpenAI, or others) before it does anything useful. Once running, it compresses conversation history automatically and shows you the retrieval path it took to answer a query, so debugging why an agent recalled the wrong thing is actually possible. There is a hosted demo, OpenViking Studio, if you want to try the retrieval and memory features before committing to the build. Solo devs experimenting with agent memory: worth the setup time if you are hitting the limits of flat vector search. Teams building production agents: the tiered loading, it only pulls in the context tier it actually needs, is the real selling point for cutting token costs at scale. It is AGPL-3.0, not MIT or Apache. If you build a hosted product on top of OpenViking and offer it as a network service, the license requires you to open source your modifications too. That is a real constraint for anyone planning to build a commercial product on this, not just an internal tool.
Completely free and open source, but AGPL-3.0 comes with real strings attached if you are building a commercial product on top of it.
**Free (only option):** OpenViking is fully open source under AGPL-3.0. No paid tier, no hosted managed offering beyond a browser demo. **Self-hosted:** Requires Python 3.10+, a Rust toolchain (Cargo) to build the RAGFS component, and a C/C++ compiler for core extensions. You also need to bring your own vision-language model and embedding model, so add whatever those API calls cost. **Paid:** None currently. The AGPL-3.0 license means if you build a commercial hosted product on top of it, you are required to open source your changes.
Cloudflare's Security Audit Skill turns a coding agent into a vulnerability auditor. A skill is a module you add to an AI coding agent to give it a specific job. This one runs a six-phase audit: it maps your app, sends parallel agents to attack from different angles, then has separate agents try to disprove each finding before it gets reported. The philosophy is blunt, only report what you can actually exploit, with a concrete attack scenario, not a checklist of maybes. MIT licensed and free. There is no service to run. You install it into your agent with one command, npx skills add, and ask it to audit a codebase. The only real dependency is a coding agent that supports tool use and parallel sub-agents, plus Node for schema validation. The cost you do pay is model tokens, since the multi-phase, multi-agent design burns through a lot of them on a real codebase. The independent verification pass exists to cut false positives, which is the usual failure mode of AI security scanners. For solo developers and small teams without a security budget, this is a strong first pass and it is free. Larger teams should treat it as one input, not a replacement for a real pentest or a human reviewer. The catch: it is only as good as the agent running it and the tokens you feed it. It finds plausible issues and verifies them, but it does not replace someone who actually understands your threat model.
Free and MIT licensed. Your real cost is the model tokens the multi-agent audit consumes.
**Free:** MIT licensed and free. Install it into your coding agent with one command (npx skills add) and run as many audits as you want. No license fee from Cloudflare. **Self-hosted:** It runs inside your own coding agent, so there is no separate service to operate. The dependencies are a coding agent that supports tool use and parallel sub-agents, plus Node for schema validation. The real cost is model tokens: the six-phase, multi-agent design consumes a lot of them on a real codebase, so your LLM bill is the thing to watch. **Paid:** No paid tier for the skill itself. Your spend is whatever your AI model provider charges for the tokens it burns.
Hermes WebUI is a browser frontend for Hermes Agent, a self-hosted autonomous AI agent that holds memory across sessions, runs scheduled jobs, and integrates with messaging platforms. Free and MIT-licensed. Setup is moderate. You bring your own LLM API key (OpenAI, Anthropic, Google, DeepSeek, OpenRouter, others) and run the agent plus WebUI on your own hardware or VPS. Once running, the agent persists conversation context, learns from interactions, and can be triggered on a schedule. The web UI mirrors the CLI experience without locking you out when you close the terminal. For solo developers and small teams who want an AI agent that isn't tied to ChatGPT or Claude.ai, this is a real option. Your conversations, your memory, your hardware. The cost is your LLM API bill, which can climb fast if the agent is making frequent calls. Solo: probably $10 to $50 per month in API spend depending on usage. The catch is that "autonomous AI agent" is doing a lot of work in the description. These systems still hallucinate, still drift, still need supervision. Don't wire it into anything destructive without guardrails.
The software is free. Your real cost is the LLM API bill, which you control by your usage patterns.
**Free (software):** Hermes Agent and Hermes WebUI are both MIT-licensed. All features included. **Self-hosted reality:** Moderate. Standard web app stack, plus you wire in API keys for whichever LLM provider you choose. Nothing exotic, but configuring scheduled jobs and integrations takes some work. **LLM API costs:** Pay-as-you-go to your chosen provider. A casual user might spend $10 to $50 per month. An agent making frequent automated calls or running heavy reasoning loops can run several hundred per month.
Watermarks-remover strips AI provenance marks from text and files: invisible Unicode watermarks (zero-width characters, bidi marks) from text, and C2PA manifests, EXIF, and XMP metadata from images, PDFs, and Office documents. It ships as an agent skill plus standalone Python scripts, MIT licensed, stdlib-only at the core. The legitimate use is real: invisible Unicode breaks diffs, search, and paste, and metadata on your own files is yours to remove. The honest part is what it admits it can't do. Deterministic removal covers Unicode and file metadata; statistical watermarks baked into AI text get best-effort rewriting that degrades the prose, and the project says so. Its own ethics doc rules out academic fraud and disclosure-dodging, and states plainly that a removed mark doesn't mean the content was never AI-assisted. Use it for hygiene on files you own. For pure image metadata work, exiftool and mat2 are the incumbents, and this wraps rather than replaces them. The catch: it cannot verify its own success against the strongest watermarks, and if your reason for reaching for it is a disclosure rule, the tool's own documentation tells you not to. It's also brand new, so treat the polish as unproven.
Completely free and open source. The optional SynthID scorer's upstream carries a non-commercial research license.
**Free:** Everything. MIT, Python stdlib for the core scripts. Optional exiftool and c2patool are auto-detected when present. **Optional heavy piece:** A SynthID pixel scorer (detection only, never removal) pulls a ~220MB codebook from an upstream project under a non-commercial research license. That upstream license is a real constraint for business use of that one feature. **The trade:** Free and local, but best-effort by design against statistical watermarks.
Ponytail is a plugin that talks your coding agent out of writing code. It installs a decision ladder the agent has to walk before it types anything: can this be skipped entirely, can existing code be reused, is there a standard library function, is there already a dependency that does it, can it be one line. Building something new is the last rung. MIT licensed, nothing to host. What started as a Claude Code skill now covers roughly twenty harnesses, each with its own install command: Codex, Copilot CLI, Cursor, Windsurf, Cline, Zed, Gemini CLI, Aider. Node on your PATH is the only hard requirement, for the lifecycle hooks. Six commands cover mode control, review, audit, tech debt, and a gain report, and three intensity levels dial how aggressive it gets. The project's own benchmark on FastAPI and React edits claims 54% fewer lines, 20% lower cost, and 27% faster runs. Treat a maintainer's benchmark as directional rather than settled. Solo developers: the token savings alone repay ten minutes of setup. Small and medium teams: worth standardizing so agent output looks the same across the team. Large teams should wire the audit and debt commands into review. The catch is that "write less code" is a preference, not a law. Push an agent hard enough toward minimalism and it will reach for a dependency that does not quite fit, or skip an abstraction you wanted. Start on lite, read what it declines to build, and turn it up once you trust its judgment.
Completely free and MIT licensed, and it is one of the few free tools that measurably lowers a bill you are already paying.
### What's Free All of it. MIT licensed. Every mode, all six commands, and every platform integration. No account, no telemetry gate, no paid tier. ### Deployment Cost $0. It is a plugin or rules file installed into an agent you already run. Node.js on PATH is needed for lifecycle hooks on Claude Code and Codex. Optional config lives at ~/.config/ponytail/config.json. ### The Real Savings This is one of the rare free tools with a direct cost argument attached. Fewer generated lines means fewer output tokens, and the project benchmarks roughly 20% lower cost and 27% faster runs on real repository edits. On a team burning a few hundred dollars a month in agent spend, that is real money for a one-time setup. ### The Real Cost Review attention. A minimalist agent makes different mistakes than a verbose one, and they are quieter: reused code that almost fits, missing abstractions, dependencies pressed into service. Budget the review time you save on volume back into reading what it chose not to build.
Caveman strips the fluff from Claude Code responses. Install it with one command, activate with /caveman, and your AI assistant drops the pleasantries, hedging, and filler words while keeping full technical accuracy. Average savings: 65% fewer output tokens. Multiple intensity levels: Lite stays professional but terse, Full drops articles and uses fragments, Ultra goes telegraphic, and Wenyan variants compress into classical Chinese. Code blocks, error messages, git commits, and technical terms pass through untouched. Version 2 added a compression engine that squeezes model input as well: tool outputs, logs, and JSON get compacted before they hit your context window, and a companion tool rewrites your CLAUDE.md and memory files to cut input tokens too. It works across 30+ AI coding agents, not just Claude Code. Cursor, Copilot, Windsurf, Cline, Codex, all supported. Heavy token users will feel the difference in both speed and cost. The catch: it started as a meme but the benchmarks are real, backed by a real 2026 research paper. Ultra mode can be hard to read. And v2 split the licensing: the skill, CLI, and SDKs stay MIT, while the engine, proxy, and platform components moved to BSL-1.1, free to self-host including production, only blocking resale of Caveman as a service. The split is per-component, so the LICENSE file in each package is the authority.
Free everywhere, including production self-hosting. The MIT/BSL split only bites if you resell it as a service.
**Free:** Everything, for everyone actually using it. The skill, CLI, and SDKs are MIT. The v2 engine, proxy, MCP, and platform components are BSL-1.1: free to self-host, including production use. **The only restriction:** Selling Caveman itself as a hosted service requires a commercial license. The BSL components sunset to Apache-2.0 in roughly four years. **Note:** The split is per-component, so check the LICENSE file in each package rather than assuming one license covers the repo.
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.
**Free tier:** Self-hosted, unlimited. Full workflow editor, RAG, prompt management, all model integrations. **Cloud (Sandbox):** Free, 200 message credits, 1 workspace, 1 member, 5 apps. **Cloud (Professional):** $59/mo per workspace. 5,000 message credits, 3 members, 50 apps, 5GB storage. **Cloud (Team):** $159/mo per workspace. 10,000 message credits, 50 members, 200 apps, 20GB storage. **Enterprise:** Custom pricing. Dedicated deployment, SLA, custom integrations.
Multica manages a fleet of AI coding agents like they're people you hired. Instead of babysitting one agent in your terminal, you assign issues to agents, group them into squads under a leader, watch their progress live, and schedule recurring jobs. It's runtime-agnostic, so it drives Claude Code, Codex, Copilot CLI, Cursor Agent, Gemini, and others rather than locking you to one. You can self-host it, and for internal use across your own team that's free. The stack is a Go backend, a Next.js frontend, and Postgres with pgvector, so standing it up yourself is real ops work, not a one-click install. Recent versions added the headline pieces: squads for routing work to a stable group of agents, a catalog of agent templates you can spin up in one click, and autopilots for scheduled recurring tasks. It's iterating fast, with near-daily releases. For a solo developer or a small team that wants to run several coding agents in parallel with real visibility into what each one is doing, this is a genuinely useful control layer, and the self-hosted version is free for your own organization. The thing to read carefully is the license. It's a modified Apache 2.0: you can use it internally all you want, but you can't offer Multica as a hosted service to other people or strip its logo without a commercial license, and there's a managed cloud at multica.ai for teams that don't want to self-host. The catch is that this is source-available, not classic open source, and it's young. If you're a developer running it for your own team, none of the restrictions touch you and it's free. If you're thinking about building a product on top of it or reselling it, that's exactly what the commercial clause is there to stop. Know which side of that line you're on before you commit.
Free to self-host for your own team. The modified-Apache license blocks reselling it or offering it as a hosted service without a commercial deal.
**Free (self-hosted, internal use):** The full platform is source-available under a modified Apache 2.0 license. Run it for your own organization, across multiple workspaces, at no cost. Go backend, Next.js frontend, Postgres plus pgvector. **Restricted:** You may not offer Multica as a hosted service to third parties, embed it in a commercial product, or remove its logo without a commercial license. This is the line between source-available and true open source. **Paid (cloud):** A managed offering at multica.ai for teams that would rather not run the stack themselves, plus commercial licensing for anyone who needs the resale or SaaS rights the open license withholds. **The trade:** Free and self-hostable for internal use, with a commercial clause aimed squarely at resellers and SaaS builders.
OpenAI's Codex agent packaged as a Claude Code skill plugin. It lets you invoke Codex from inside Claude Code to review code or delegate tasks, connecting two AI coding agents so they can collaborate. Useful if you want a second opinion from a different model without switching tools. The integration is straightforward: install the skill, and you can ask Claude Code to hand off specific tasks to Codex. Code review is the primary use case, where having two different models look at the same code catches more issues than either alone. The catch: requires both Claude Code and OpenAI API access, so you're paying for two AI services to talk to each other. The value proposition only makes sense if you're already invested in both ecosystems. For most developers, one AI coding tool is enough.
Free plugin, but you are paying for both Claude and OpenAI API usage to run it.
The plugin itself is free and open source. You need active subscriptions to both Claude Code and OpenAI's API to use it. Your real cost is the combined token usage across both services.
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.
Free framework. Your cost is LLM API usage, which multi-agent patterns multiply significantly.
Fully open source. The framework code is MIT, documentation/examples are CC-BY-4.0. No paid tier from Microsoft for AutoGen itself. **Your costs are LLM API calls:** - OpenAI GPT-4o: ~$2.50/1M input tokens, $10/1M output - Azure OpenAI: similar pricing - Local models via Ollama: free but slower Multi-agent systems multiply your API costs because agents converse with each other. A 4-agent workflow processing one task might use 5-10x the tokens of a single-agent approach. Budget accordingly. Autogen Studio (the visual UI) is also free and included.