General-purpose AI agents and harnesses you can build on: openclaw, goose, LibreChat, and more.
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.
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.
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 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.
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.
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.
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.
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.
Microsoft Agent Framework is what AutoGen and Semantic Kernel turned into. Same teams, one SDK, and it reached 1.0 in April 2026 with a long-term support commitment behind it. You get agents, graph-based workflows for sequential, concurrent, and handoff patterns, and an opinionated harness agent that handles planning, todo tracking, and context compaction on long jobs. MIT licensed, all of it. There is no server to run. Install the Python or .NET package and your only bill is the model provider. It talks to Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, and Ollama, so choosing it does not lock you to Azure. OpenTelemetry is wired in for tracing and the local DevUI gives you step-through debugging of a running workflow. Python and .NET are the mature targets; Go exists but is public preview and missing declarative agents and RAG. If you are a .NET shop, treat this as the default and stop shopping. Python teams already productive on langchain-ai/langgraph do not have a strong reason to migrate. Solo builders will get moving faster on crewAIInc/crewAI. The catch: this is a migration, not an upgrade. microsoft/autogen is now in maintenance and its future work happens here, so getting current means rewriting against a migration guide. Pick your lane before you end up running three agent stacks in production.
Free and MIT with no paid tier. You pay the model provider, not Microsoft, unless you opt into Foundry hosted agents.
### Free Everything. MIT licensed, fully open source, no paid edition and no gated features. Agents, graph-based workflows with checkpointing and human-in-the-loop, the harness agent, declarative YAML agents, agent skills, middleware, OpenTelemetry observability, and the DevUI. Python hit 1.0.0 on 2026-04-02 and is at 1.14.0 as of 2026-08-14. ### Paid No paid tier for the framework. Costs come from what you point it at: model provider tokens (Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, or free if you run Ollama locally), and Azure infrastructure if you use Foundry hosted agents rather than running the process yourself. ### Self-Hosted Costs $0 for the framework. It runs anywhere Python or .NET runs, including a laptop. The DevUI runs locally. Production cost is whatever compute already hosts your service plus token spend, which for any real agent workload will dwarf the infrastructure line. ### When to Pay Never for the framework. The decision is which model provider you are willing to pay and whether you want Foundry hosted agents, which trades two lines of code for an Azure bill. Compared to langchain-ai/langgraph, this is the stronger option for .NET and for teams that want telemetry and durability defaults rather than assembling them. crewAIInc/crewAI stays quicker for a small prototype.
Corsair is the layer that stops your agent from holding API keys. You connect it once to Gmail, Slack, Notion, Stripe, Linear, GitHub, and the rest, and the agent gets typed tool calls instead of credentials. When it tries something destructive, Corsair intercepts and generates an approval link showing exactly what is about to happen. Apache 2.0, and the full SDK self-hosts for nothing. The permission model is per-integration rather than global, which is the right shape. GitHub can sit in strict mode while Slack runs open, and individual endpoints override the mode. It also does multi-tenancy properly: flip a flag and every tenant gets isolated credentials, storage, and permission handling, which is the part teams normally build badly themselves. Self-hosting is free with no per-seat charge and no cap. The hosted Hub has a $0 Hobby tier at 50 connections and 100k webhook events, then jumps to $200/mo Pro for unlimited. That is a wide gap, so model your connection count before committing. The catch is maturity. The repo is young, the integration catalog is community-extended, and an approval gate is only as good as its coverage. Audit which of your integrations actually classify a destructive action correctly before trusting it with production credentials.
Self-hosting the full SDK is free under Apache 2.0. Corsair Hub is $0 for 50 connections and 3 seats, then $200/mo Pro with nothing in between.
### Free (Self-Hosted) The full SDK under Apache 2.0. Every integration plugin, the permission modes, the approval flow, multi-tenancy, and caching. No per-seat pricing and no feature held back for the cloud. ### Cloud Pricing (Corsair Hub) - Hobby: $0/mo. 50 connections, 100k webhook events, up to 3 team members, unlimited tool calls, Corsair branding on the consent screen, Discord support. - Pro: $200/mo. Unlimited connections, webhooks, and team members, custom consent-screen branding, Slack support, integrations built by the Corsair team. - Enterprise: custom. Custom limits and support. No credit card for the free tier. Corsair states that Hub relays credentials rather than storing them. ### Self-Hosted Costs A Node service plus a database for cached integration data. A $20 to $50/mo VM covers a small deployment. The ongoing cost is upkeep: token refresh, webhook signature verification, and third-party API deprecations are exactly what the project exists to absorb, and self-hosting means you absorb the version upgrades instead. ### When to Pay The $0 to $200/mo jump is the decision. Under 50 connections and 3 people, Hobby is free and fine. Past that, compare $200/mo against a VM plus the hours you spend chasing OAuth changes. Self-host when credentials must never transit a vendor, which is a legitimate reason on its own.
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.
## Free Tier Core harness MIT licensed. Full local functionality. 3 free concurrent remote browsers via cloud.browser-use.com. ## Self-Hosted Run Chrome with remote debugging locally. Zero cost beyond compute. ## Paid cloud.browser-use.com offers managed remote browsers beyond the free tier. Pricing not publicly listed.
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.
**Free tier:** The Apache-2.0 framework is free and open source, currently in public beta. **Self-hosted:** A TypeScript/Node framework you run yourself. Deploying agents on Vercel incurs normal Vercel platform and model costs. **Paid:** No paid tier for the framework. Managed agent platforms with stable APIs are LangGraph Platform or OpenAI's Assistants API.
Running a team of AI agents means losing track of what each one did and why. HiClaw is an operating system for that. It uses Matrix chat rooms (the same protocol behind Element) as the coordination layer, so every agent action is visible as a message in a room you can read. What's free: Everything. Apache 2.0 license, self-hosted, no paid tier. The transparency angle is the real differentiator. Most multi-agent frameworks are black boxes where agents talk to each other and you get the result. HiClaw makes every decision, handoff, and tool call visible in Matrix rooms. For regulated industries or anyone who needs to audit what their AI agents did, that's a big deal. The catch: it's from Alibaba, which means great engineering but documentation tends to be initially Chinese-focused with English as a second priority. It's growing fast but still early. The Matrix dependency adds infrastructure complexity. You need a Matrix homeserver running, which is its own ops burden.
Free software, but the Matrix homeserver dependency means real infrastructure and ops costs.
### What's Free Everything. Apache 2.0 license with no paid tier, no cloud offering, no enterprise edition. ### Self-Hosting Cost You need a Matrix homeserver (Synapse or Conduit) plus the HiClaw services. Minimum viable setup on a VPS: $10-20/mo for a small instance. The Matrix homeserver is the heavier component. ### Infrastructure Requirements - Matrix homeserver (Synapse recommended): 1-2GB RAM minimum - HiClaw services: varies by number of agents - Docker Compose setup available but non-trivial ### The Hidden Cost Ops time. Running a Matrix homeserver, keeping HiClaw updated, managing agent configurations. Budget 4-8 hours/month for a small deployment. At $75/hr, that's $300-600/mo in time. ### Comparison Most competing multi-agent frameworks (CrewAI, AutoGen) don't require a separate messaging infrastructure. You're paying the Matrix tax for the transparency benefit.
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.
**Free:** Apache-2.0, free, pip install. No paid tier. **Self-hosted:** The markdown mode needs nothing extra. The vector mode requires an embedding model and a vector store you run and maintain. **Paid:** No paid version. Any cost is the embedding/inference you supply.
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.
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.
Fully open source under MIT. The framework itself is free. MiniMax may have paid API tiers for their models, but the skills framework has no paid tier or hosted version on its own.
FrontierAgent is Apodex's agent runtime, open-sourced alongside their model, and it aims at long-horizon file-based work rather than chat. The terminal UI ships two workflows. ReAct runs one stateful agent that researches, reads files, writes deliverables, and runs commands in a task-scoped sandbox. Agent Team puts a coordinator on a task board, farms independent work out to parallel sub-agents, collects structured reports, and synthesizes the result. Apache-2.0 and free. The sandbox design is the part worth stealing. Shell and file tools share one task-scoped filesystem split three ways: /inputs is read-only, /workspace is working state, and /outputs holds the deliverables that persist. Authorization and sandbox failures are fail-closed, which is the correct default and not the common one. The task board renders live in the sidebar, and you can type while an agent is running to queue a new instruction instead of waiting for it to finish. Install is one command on macOS and Linux, no preinstall step and no hard Docker dependency. The runtime costs nothing; model calls do. It speaks OpenAI-compatible endpoints, so point it at whatever you already pay for, or serve models locally through SGLang. Solo devs: free, and Agent Team is worth an evening if parallel sub-agents interest you. Teams: evaluate it, but read the catch first. The catch is that this is a vendor's harness published to sell you on the vendor's model. The README leads with a limited-time free trial of the Apodex API and the benchmark chart is Apodex's own. Neither of those makes the code bad, and Apache-2.0 with OpenAI-compatible endpoints means you are not locked in. But the project is days old, the evaluation numbers are self-reported, and a framework this young will move under you. If you want a multi-agent runtime you can build on today, look at goose or the broader LangGraph and CrewAI ecosystem instead.
Free and Apache-2.0. You pay for model tokens at whatever endpoint you point it at, and the vendor's free API window is a trial, not a plan.
**Free tier:** The entire runtime, the terminal UI, both workflows, the tool layer, and the evaluation suite. Apache-2.0 with nothing gated. **Self-hosted:** The only mode. One install command on macOS or Linux, no preinstall step and no hard Docker requirement. Point it at any OpenAI-compatible endpoint, or serve models yourself through SGLang to keep the whole stack on your own hardware. **Paid:** Nothing from the project. Your bill is model tokens from whichever endpoint you configure. Apodex is currently offering free access to its own API for a two-week window, which is a trial, not a pricing tier.
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.
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.
## Free tier The generator and all generated CLIs are MIT licensed and fully free. ## Self-hosted Not applicable, runs locally as a Go binary. No server, no DB, no Docker. ## Paid No paid product from this project. But the generator runs inside Claude Code, which requires a paid Anthropic subscription (Pro plan is $20/mo, or pay-as-you-go on the API). Generated CLIs are free to run.
commerce-agents is Anthropic's reference blueprint for building two things on Claude: a shopping agent you embed for customers, and a merchant agent your staff use to run the back office. It is not a product you install, it is example code (real runnable agents across retail, travel, telecom, and entertainment) that shows how to wire the pieces together. Apache-2.0. The value is the pattern, not the demo. Each agent is defined once (prompt, skills, tool contracts, approval gates) and runs on the Messages API, the Agent SDK, and Managed Agents. There is a Claude Code plugin that scaffolds a new agent against your own systems. Nothing here places a real order or charges a card; every write is staged until a person approves it. If you are building commerce agents on Claude, start here instead of from a blank file. It shows the safety scaffolding (the fencing, the staged writes, the approval surface) that you would otherwise learn the hard way. The catch: the code is free but Claude is not. You bring an API key, and cost scales with usage. This is a starting point wired to Anthropic's own stack, not a vendor-neutral framework.
The blueprint is free and open source. Running the agents needs a Claude API key, and cost scales with usage.
**Free:** The blueprint is Apache-2.0 and open source. All the agent code, skills, tool contracts, and the scaffolding plugin are free to use and fork. **Self-hosted:** You run the agents on your own infrastructure against your own catalog, cart, and order systems. The repo ships runnable demo verticals. **Paid:** The code is free; running it needs a Claude API key. Cost is Anthropic API usage, which scales with traffic. Managed Agents hosting is a separate Anthropic cost if you go that route.
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.
### What's Free The Python package: install, run locally, connect to your own browser instances. Full API access for agent-browser interaction. ### What's Behind the Paywall Hosted API with managed browser infrastructure. Pricing details are sparse. Their site suggests usage-based tiers but specific numbers aren't published. Expect per-action or per-session pricing. ### Self-Hosting Cost $0 for the package. You need compute to run browser instances. A VPS with 2GB+ RAM handles a few concurrent sessions. Headless Chrome is the resource hog, not Notte itself. ### Verdict Self-host for free if you can manage browser infrastructure. The hosted API makes sense if you need scale without ops work, but wait for published pricing before committing.
OpenHarness is agent infrastructure you pip install: the tool-calling loop, 43 built-in tools for files, shell, search, web, and MCP, plus skills, memory, permission modes, and multi-agent coordination. It also ships ohmo, a personal agent built on top of it that lives in Slack, Discord, Telegram, or Feishu and will fork a branch, write code, run tests, and open a PR on its own. MIT, Python 3.10 or newer, free. The ohmo part is the interesting trick. It runs on a Claude Code or Codex subscription you already pay for rather than a separate API key, so a chat-driven coding agent costs nothing extra. Setup is pip install openharness-ai, then oh setup to pick a provider and ohmo gateway start to put it in your chat app. It reads CLAUDE.md, loads Anthropic-style skills and plugins, and compacts its own context. Here is the problem. The last commit landed June 4, 2026, the last PyPI release was 0.1.9 on May 7, and there are dozens of open issues with nobody working them. This is a university research group's project that got popular fast, and popularity is not maintenance. For anything you depend on, langchain-ai/langgraph and crewAIInc/crewAI have real release cadences; for the coding agent job specifically, openclaw/openclaw is still shipping. The catch is that a stalled repo and a permission system make a bad pair. ohmo runs shell commands and opens PRs on your behalf, which is exactly the code you want getting security fixes. Fine for a prototype on a throwaway repo. Not something to point at code you care about until commits resume.
Free and MIT with no commercial tier. Your only cost is the model subscription ohmo rides on, and the risk is a repo that stopped shipping in June 2026.
### Free Everything. The full harness, all 43 built-in tools, skills, plugins, hooks, persistent memory, permission modes, multi-agent coordination, the TUI, and the ohmo personal agent. MIT licensed, no gated features, no account required. ### Paid None. There is no hosted version, no cloud tier, and no commercial offering from the maintainers. ### Self-Hosted Costs `pip install openharness-ai` on Python 3.10 or newer. Running ohmo adds a gateway process you keep alive plus a bot token for whichever chat platform you connect. Your real cost is model access, and this is where ohmo is clever: it is built to ride an existing Claude Code or Codex subscription, so if you already pay for one, the incremental cost is $0. Point it at raw API keys instead (Anthropic, OpenAI, Copilot, Moonshot/Kimi, GLM, MiniMax, NVIDIA NIM, or any compatible endpoint) and you pay per token like any other agent framework. ### When to Pay There is nothing here to buy. Spend money on the model subscription the agent runs on, and spend your caution on the maintenance gap: no commits since June 4, 2026 and no PyPI release since 0.1.9 on May 7, 2026.
OpenSpace is a librarian for the skill files your coding agent piles up. Version 2, released in July 2026, dropped the original self-evolving-agent pitch for something concrete: find the right skill, track whether it worked, share the ones that did, retire the ones that did not. All MIT licensed, including the community library at open-space.cloud. Running it means Python 3.12 or newer, a pip install, and wiring an MCP server into Claude Code, Codex, OpenClaw, or nanobot. Skills and execution stay local, and the cloud is optional. The dashboard is a second install needing Node 20. You bring your own model key, so the running cost is tokens. Solo developers with a dozen skill files do not need this, and a curated pack like slavingia/skills is a smaller commitment. It pays off once a team shares hundreds of skills and nobody can say which still work. The catch: this comes out of an academic lab, and its Terminal-Bench 2.1 result, 65.2% cold to 78.7% warm, was run on its own harness. Self-evolving skills mean an agent rewriting its own instructions, and the restrictive policy that limits it to repairs is not the default. The shared library is still thin.
Free and MIT licensed, cloud included. Your cost is the LLM tokens the evolution loop burns.
### Free All of it. MIT licensed. The community library at open-space.cloud can be browsed without an account, and uploading or importing skills needs only a free agent key you provision from the CLI with `openspace-cloud-auth bootstrap-agent-key`. Every local capability (task execution, skill search, evolution) works with no cloud account at all. ### Paid No paid tier, no hosted plan, no seat pricing, no enterprise SKU as of August 2026. ### Self-Hosted Costs Python 3.12 or newer plus a pip install from the repo. The dashboard is a second install requiring Node.js 20 and its own dev server process. The real spend is LLM tokens: OpenSpace runs an agent harness plus an evolution loop that re-analyzes task traces, so an active setup burns noticeably more per task than a bare agent. You supply your own key, so that bill lands with Anthropic, OpenAI, or whoever you point it at. ### When to Pay Nothing to pay the project. Budget for model usage and cap the evolution loop if your provider bills by token.
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.
## Free Tier Everything. MIT licensed. All execution strategies, all LLM providers, all observability features. ## Self-Hosted Docker Compose with 6+ services: Go gateway, Rust agent core, Python LLM service, Temporal, PostgreSQL, Redis. Production deployment requires understanding microservices, gRPC, and Temporal. Optional browser automation adds 3.4GB to the image. ## Paid Alternatives CrewAI (open core, paid cloud), LangGraph (free + LangSmith paid observability), Dify (open core), Relevance AI (SaaS, usage-based). Shannon offers more infrastructure tooling but demands more operational knowledge.
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.
Fully open source under Apache 2.0. No paid tier, no hosted service. **Costs come from the models you use:** - Google Gemini API: Free tier (15 RPM), then pay-as-you-go. Gemini 1.5 Pro: $3.50/1M input tokens, $10.50/1M output tokens. - Vertex AI: Similar pricing with enterprise features. - Third-party models: Whatever their pricing is. The toolkit itself adds zero cost. It's a library you include in your Java project.
ConnectOnion is a Python agent framework built on one idea: you write the prompt and the tools, and it handles everything else. Plain functions become tools with no schema writing. The whole thing is Apache 2.0 and free, including the CLI, the prebuilt Gmail, calendar, and browser tools, and a ready-made chat frontend. There is no server to run. It's a pip install, and a working agent is three lines of code. The interesting part is the host function: one call exposes your agent over HTTP and a peer-to-peer relay so other agents can discover and call it. Dangerous operations like shell commands go through a built-in approval system instead of you writing permission logic. Solo builders and small teams get the most here. It's one of the fastest paths from idea to working agent in Python. Larger teams already invested in LangGraph (langchain-ai/langgraph) or CrewAI (crewAIInc/crewAI) won't find a reason to migrate. The catch is maturity. The framework is young, the docs move fast, and the multi-agent relay network is the part most likely to change under you. Build side projects on it today, not your production support bot.
Completely free and open source. Your only bill is the LLM API underneath it.
**Free tier:** Everything. The framework, CLI, prebuilt tools, chat frontend, and multi-agent relay are all Apache 2.0. **Self-hosted:** It's a pip install, not a deployment. The host function serves an agent over HTTP from any box you control. **Paid:** Nothing to buy today. Your real spend is LLM API calls, which scale with how chatty your agents are.
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.
**Free / self-hosted:** The full platform is MIT-licensed and self-hostable. You supply your own model API keys and infrastructure. No feature is held back from the open-source code. **Cloud Pro:** About 29 euros per user/month (roughly $31), 14-day trial. Adds managed connectors, advanced models, SOC2 with zero data retention, and API credits. **Enterprise:** Custom pricing, 100-seat minimum. Adds SSO (Okta/Entra/JumpCloud), SCIM provisioning, US/EU data residency, the Salesforce tool, higher limits, and dedicated support.
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.
**Free (MIT):** The full seven-layer memory system is free and open. No paid tier, no usage caps. **Self-hosted reality:** You run Qdrant for vector storage and wire the layers into your agent. Moderate setup. Everything stays local. **Ongoing cost:** Whatever your LLM provider charges, plus your own hardware. No subscription to the memory layer itself, which is the entire point versus mem0, Zep, or Letta.
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.
Fully open source under MIT. No paid tier, no cloud offering. Self-host the 3D environment and connect your agents.
AI models call tools, and every one of those calls has to be shown to the user somehow. 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. That 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.
### Free Everything. MIT licensed, no paid tier, no hosted service. ### What You Get - React components for rendering AI tool calls in chat UIs - Streaming result display - Error state handling - TypeScript types - Integration with assistant-ui chat framework ### Cost $0. `npm install @assistant-ui/tool-ui` and go.
Pi-from-scratch rebuilds a working coding agent, one that reads files, edits code, and runs shell commands, in about 600 lines of TypeScript. It's a deliberate deconstruction of the pi agent framework, delivered as an interactive web tutorial where the code appears progressively as you read, with a trace debugger for stepping through the agent loop. MIT licensed, free, bring an OpenAI-compatible API key. Setup is Node 22 and npm install, or just read the hosted version. The tutorial prose is primarily in Chinese, so non-Chinese readers will lean on translation. Read it if you use coding agents daily and can't explain what happens between your prompt and the file edit. It also works as a skeleton for a custom agent. The upstream pi framework is the production version; Anthropic's and OpenAI's agent SDKs are what you'd actually build on. The catch: this is pedagogy, not infrastructure. Its entire value is that it stays small enough to read in a sitting, which is exactly why nobody should ship it.
Completely free and open source. A tutorial, not a product.
**Free:** Everything. MIT, sponsored, hosted read-along version available. **BYO costs:** Running the agent locally needs an OpenAI-compatible API key; tokens bill at your provider. **The trade:** None. It's a free lesson.
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.
The CLI tool is free under Apache 2.0. The actual cost comes from LLM API usage: OpenAI GPT-4 at ~$0.01-0.10 per generation, or free via local models through Ollama. No paid tier for AIAC itself.
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.
Free and open source, no paid tier. It's a small script plus a prompt, so there's nothing to buy and nothing to host. The only "cost" is that it's intentionally minimal: you get a fast memory primitive, not a full framework.
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.
### Free Tier Claimed MIT license (no LICENSE file in repo). No paid features in the open source version. ### Self-Hosted Requires Docker, Python 3.10+, uv package manager, and LLM API keys. You need to write benchmark tasks in Harbor format. ### Paid None currently. The company (thirdlayer.inc) is building a commercial product around this concept.