General-purpose AI agents and harnesses you can build on: openclaw, goose, Hermes Agent, 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.
LangChain is the glue layer for LLM apps: one standard interface for models, vector stores and tools, plus create_agent, a small harness that builds an agent from a model, tools and a prompt. Swap OpenAI for Anthropic or local Ollama without a rewrite. LangChain, LangGraph and Deep Agents are all MIT and free.
There's nothing to host. uv add langchain and you're writing code. The ops work is upgrades: patches can land a few times a week, though since 1.0 breaking changes wait for major versions. Still on 0.3? Its maintenance window closes in December 2026.
The paywall is LangSmith, their hosted tracing, evals and deployment platform. Developer is free for one seat and 5k traces a month. Plus is $39 per seat per month with 10k traces, then usage billing. Self-hosted LangSmith is Enterprise only. Solo: free. Small teams: Plus, or send traces to Langfuse instead. Large teams: Enterprise for SSO or self-hosting.
The catch: a single chat call is simpler with the provider SDK, and when a chain misbehaves you debug LangChain's internals. Security too. langchain-core has shipped a steady run of advisories, including a critical serialization bug that could leak secrets (CVE-2025-68664). Pin versions and patch fast.
The framework is free under MIT. LangSmith is free for one seat and 5k traces a month; teams pay $39 per seat per month plus 0.005 LSU ($1 each) per trace past the 10k allowance.
**Free:** The framework is MIT with no feature gates: `langchain`, `langchain-core`, LangGraph, Deep Agents and the partner integration packages (OpenAI, Anthropic, Ollama, Groq, Mistral and more). LangSmith Developer plan: $0 for 1 seat, up to 5k base traces a month, community support, plus small monthly allowances for Fleet (7 LSU) and Sandboxes (8 LSU). **Self-hosted:** The framework is a library that runs inside your own process, so there's no server to run; you pay your model provider directly. Self-hosted or hybrid LangSmith is only available on Enterprise. Open source tracing alternatives such as Langfuse and Arize Phoenix plug into LangChain if you want observability without a LangSmith bill. **Paid:** LangSmith Plus is $39 per seat per month (unlimited seats, billed monthly, self-serve) with 10k base traces a month included, then pay-as-you-go at 0.005 LSU per extra base trace, where 1 LSU = $1. Base traces keep 14 days of history; extended traces keep 180 days for an extra fee. Plus also includes 1 free small serverless agent deployment, with further deployments metered by compute and memory. Enterprise is custom priced, invoiced annually, and adds custom SSO, ABAC/RBAC, a support SLA and cloud, hybrid or self-hosted LangSmith. VC-backed startups can get up to $10,000 in credits.
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.
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 started as a framework for AI agents and now calls itself an agentic operating system. It's a runtime for agents that act across your chat apps, email, calendar, browser and wallet, plus a consumer Eliza app for web, desktop and mobile. It ships memory, document ingestion and connectors for Discord, Slack, Telegram, WhatsApp and X, and works with OpenAI, Anthropic, Gemini, Grok, OpenRouter or local models through Ollama. MIT licensed. Running it yourself is real work. The repo pins Node 24 and Bun, you bring model keys or run local models, and turning a demo into something reliable is a project, not an afternoon. Eliza Cloud is now the hosted route: sign-in, model routing and agent deployment, billed on credits. Its pricing sits behind a login. Solo builders who want control over their agent stack: a strong start. Teams that want a library rather than a whole runtime should look at mastra-ai/mastra or LangChain. Larger teams get the same code with no license ceiling. The catch is churn. The last stable npm release is from January, the repo's main branch is a v2 beta, and third-party plugins are no longer accepted, so older tutorials break. The official docs also carry tokenomics pages for an elizaOS crypto token.
The framework is free and MIT. Eliza Cloud hosting is credit-billed with no public price list; your real bill is LLM tokens.
**Free tier:** The framework and app code are free under MIT: agent runtime, memory, document ingestion, chat connectors, CLI and a local model registry for on-device inference. **Self-hosted:** Bring your own LLM keys or local models, and your own infrastructure. The repo pins Node 24 and Bun. The official deploy guide covers Docker, Railway and Phala (confidential compute); anything else is on you. **Paid (Eliza Cloud):** Optional hosted service for accounts, model routing and agent deployment, billed on prepaid credits. Pricing is behind a login and not published. The open-source cloud code bills running agents by the hour and passes model costs through with a platform markup, but treat those constants as indicative, not a price list. **The real cost:** LLM tokens. Every agent burns them continuously, and that bill dwarfs hosting for most setups.
OpenClaw is a personal AI assistant that runs on your own machine and answers you inside chat apps you already use: WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams and 20+ more. It's MIT licensed and run by the OpenClaw Foundation, a nonprofit. No paid tier, no hosted service, no token. An install script and onboarding wizard set up a background service called the Gateway. Each channel has its own login: WhatsApp links by QR code, Telegram needs a bot token, iMessage needs a Mac. A laptop works; a small VPS keeps it on around the clock. Free software, not free to run: you pay a model provider per token or sign in with a ChatGPT or Claude subscription. Solo: free on a laptop. Small teams: free on one shared Gateway. Larger teams: free, if someone owns security updates. The catch is the blast radius. Tools run directly on the host unless you turn on sandboxing, and the project has published hundreds of security advisories in under a year. Its skill marketplace, ClawHub, was hit by hundreds of malware-laced skills in early 2026. Treat every skill as code you run yourself.
The software is free with no paid tier at all. Your bill is the model, per-token API pricing or a ChatGPT or Claude subscription you already pay for, plus a small always-on server if you want it reachable 24/7.
**Free:** Everything. MIT licensed (copyright OpenClaw Foundation), stewarded by the OpenClaw Foundation, an independent 501(c)(3). The README states it "has no paid tier, hosted service, or token." The Gateway, Control UI, CLI, TUI and the macOS, iOS, Android, Windows and Linux companion apps are all included. **Self-hosted:** The only way to run it. The official install script (bash or PowerShell) provisions Node.js and starts onboarding; npm install needs Node 24.16+ or 26.1+. Docker and Nix paths are documented. The Gateway runs as a daemon on a laptop, VPS, home server or Raspberry Pi-class box. WhatsApp links as a WhatsApp Web device via QR (Baileys); iMessage needs a Mac signed into Messages, reached over SSH from a Linux Gateway. A daily update check is on by default and anonymous feature statistics are opt-in; `update.checkOnStart: false` disables both. Tools run on the host for the main session unless you configure sandboxing. **Paid:** No paid tier. Your real costs are the model (API key billed per token, or OAuth reuse of a ChatGPT/Codex login or the Claude CLI, or a local model on your own hardware) and, for always-on use, a small server.
CrewAI builds a team of AI agents in Python. Each agent gets a role, a goal and tools, and a Crew passes tasks between them, in order or under a manager agent. Flows cover the opposite case: event-driven, step-by-step control when you don't want agents improvising. The framework is MIT and free.
Setup is uv tool install crewai, then crewai create crew scaffolds a project where agents live in JSONC files. It's a standalone framework, not a LangChain wrapper. There's no server to run. Agents call OpenAI by default, and local models work through Ollama.
The paid side is CrewAI AMP, a hosted platform with a visual editor, tracing and deployment. The free Basic plan gives you 50 workflow executions a month. Past that it's Enterprise, custom pricing only, which adds SSO, RBAC and deployment in your own VPC. No self-serve middle tier. Solo and small teams: free framework. Larger teams: Enterprise, or deploy it yourself.
The catch: multi-agent setups multiply LLM calls and are hard to debug. Anonymous telemetry is on by default. And in March 2026 CERT/CC disclosed four flaws, including prompt injection to code execution via the Code Interpreter Tool, which CrewAI then removed.
The framework is free under MIT. Hosted AMP is free up to 50 workflow executions a month, then jumps straight to custom-priced Enterprise with no self-serve tier in between.
**Free:** The framework is MIT with nothing gated: Agents, Tasks, Crews (sequential or hierarchical process), Flows, tools, memory and MCP support. CrewAI AMP Basic is also free: the Studio visual editor and AI copilot, GitHub integration, 2 automations and 50 workflow executions a month (hard cap, no overage), tracing, OpenTelemetry export and community support, hosted on CrewAI cloud only. **Self-hosted:** The framework runs anywhere Python 3.10 to 3.13 runs; you pay only your model provider. There is no server component unless you build one. Running the AMP control plane in your own VPC or on your own infrastructure is Enterprise only. **Paid:** AMP Enterprise is custom priced with no published rate. It adds enterprise connectors, executions sized to your workflows with flexible overage, SSO (Microsoft Entra, Okta), role-based access control, dedicated VPC or on-prem deployment, dedicated and on-site support, and a 45-day onboarding. There is no self-serve paid tier between Free and Enterprise. LLM API costs are always separate.
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.
LangGraph builds AI agents as graphs: nodes do work, edges decide what happens next, and state persists between steps, so an agent can pause for human approval, recover from failures and pick up where it left off. It's from LangChain but works without it. The library is MIT and ungated. Run it anywhere Python or JavaScript runs, with a Postgres or SQLite checkpointer for persistence. LangGraph 1.0 shipped in October 2025 as a long-term-support release with a semver promise, so minor upgrades shouldn't break you; the churn now lives in beta features and the wider LangChain ecosystem. Two high-severity auth advisories in the SDK landed in August and September 2026, so stay current. The money is in LangSmith. Tracing is free for one seat with 5,000 base traces a month; Plus is $39 per seat a month with 10,000 base traces, then $5 per 1,000 more. LangChain's production Agent Server (task queues, cron, streaming endpoints) runs on LangSmith Deployment, metered by compute on Plus, and self-hosting that server requires Enterprise. Solo and small teams: free library plus your own server. Larger teams that want the managed runtime: budget for LangSmith. The catch: the free path means building your own serving layer. The moment you want LangChain's runtime on your own hardware, you're in an Enterprise sales conversation.
The library is free. LangSmith tracing is $39 per seat, and LangChain's managed agent runtime is metered or Enterprise-only to self-host.
**Free:** The LangGraph library (Python and JS), MIT, no gates. LangSmith Developer: 1 seat, 5,000 base traces a month. **Self-hosted:** Run graphs in your own app or worker with a Postgres or SQLite checkpointer at no cost. LangChain's own Agent Server, self-hosted, requires an Enterprise plan and license key. **Paid (LangSmith):** Plus $39 per seat per month, 10,000 base traces included, then pay as you go at 0.005 LSU per base trace (1 LSU = $1, so $5 per 1,000). Plus includes one free small serverless deployment; more deployments meter compute and memory in LSUs. Enterprise is custom, invoiced annually, with self-hosted and hybrid options, SSO and an SLA.
CopilotKit puts an AI agent inside your own app instead of bolting a chat bubble to the corner. The agent reads your app's state, calls your functions and renders real UI in the conversation, across React, Angular, Vue and React Native, plus Slack and Teams bots. Its makers also created AG-UI, the open protocol linking agents to frontends. The SDK is MIT licensed and free.
The free setup is npm packages in your app plus a TypeScript runtime endpoint, with no extra service. Your real bill is LLM tokens, which grow with how much app state you hand the agent every turn. Telemetry is on by default; set COPILOTKIT_TELEMETRY_DISABLED=true to turn it off.
The paid layer is CopilotKit Intelligence: threads that resume across devices, user memory, analytics and managed channels. Hosted is free for 1,000 interactions a month, then $49/month per organization with 10,000 included. Solo and small teams: free SDK. Medium teams wanting history without building storage: pay as you go. Large teams: Annual for SSO and offline installs.
The catch: the free line is narrower than the MIT badge suggests. Only the TypeScript runtime works without Intelligence; the Python, Go, Ruby and .NET runtimes require it.
The SDK is free and MIT with a TypeScript runtime. Persistent threads, memory, analytics and non-TypeScript runtimes need Intelligence: free for 1,000 hosted interactions a month, then $49/month per organization with 10,000 included.
**Free:** The whole SDK is MIT: React, Angular, Vue, React Native and web-component packages, the TypeScript runtime, generative UI, shared state, human-in-the-loop, a SQLite agent runner and the self-hosted Channels adapters for Slack, Teams, Discord and WhatsApp. Bring your own LLM keys. Separately, hosted Intelligence has a free plan with 1,000 interactions per organization per month, and the Developer Edition runs Intelligence locally for non-production use on a renewable 30-day license. Development, staging, test and demo usage is not charged. **Self-hosted:** The SDK needs no extra service if your runtime is TypeScript. Python, Go, Ruby and C#/.NET runtimes require Intelligence (cloud or self-hosted). Self-hosted Intelligence is a Helm chart (app-api, app-frontend, optional realtime-gateway) that needs Kubernetes 1.28+, your own Postgres 14+, Redis 7+, an OIDC provider and a license key, at the same price as hosted. Telemetry is on by default; COPILOTKIT_TELEMETRY_DISABLED=true turns it off. **Paid:** Intelligence pay as you go is $49/month per organization (billed monthly, no annual commitment) with 10,000 interactions included across all apps, then graduated per-interaction rates. Unlimited developers and users. One completed agent request is one interaction; tool and model calls inside it are not counted. Self-hosted pay as you go must report usage over the internet. Annual is custom-priced, adds SSO, offline deployment and up to 24/7 support, and is sold through AWS Marketplace.
Mastra is a TypeScript framework for building AI agents into a web app: agents with tools and memory, workflows that can pause for a human to approve and then resume, RAG, evals and tracing. It routes to 40+ model providers through one interface and drops into a Next.js or Node app, or runs as its own server. The core is Apache 2.0, from a Y Combinator company.
Self-hosting the framework just means deploying your app. The paid layer is Mastra Platform for tracing and hosted deployment: free for 100K events and 24 CPU hours a month, then Teams at $250/mo for 1M events, 250 CPU hours, six months of retention and SSO. Enterprise is custom.
TypeScript teams who don't want to live in Python: this is the most complete option. Solo and small teams: the free framework plus the free platform tier. Compare it with langchain-ai/langchainjs for a bigger ecosystem, or Vercel's AI SDK for something lower-level.
The catch is the ee folders. RBAC, SSO, fine-grained permissions and the visual agent builder sit under a separate Enterprise license: readable, but not for production without a paid key. Mastra has rewritten that license three times this year. Know which imports you're pulling in.
The core framework is free under Apache 2.0. SSO and RBAC need an Enterprise key, and hosted Teams is $250/mo.
**Free (self-hosted):** The core framework (agents, workflows, memory, RAG, MCP, evals) is Apache 2.0. Deploy it anywhere you run Node. **Enterprise features (source-available):** Anything under an `ee/` directory, including RBAC, SSO, fine-grained authorization and the agent/workflow builder, is under the Mastra Enterprise Edition License. You can read and test it, but production use needs a signed agreement and a license key. Self-hosted Enterprise is one flat annual fee, price on request. **Mastra Platform (hosted):** Starter $0/mo with 100K observability events (then $10 per 100K), 24 CPU hours (then $0.35/hr) and 15-day retention, unlimited users. Teams $250/mo with 1M events (then $8 per 100K), 250 CPU hours (then $0.25/hr), 6-month retention, SSO and SOC 2 docs. Enterprise is custom, with RBAC, audit logs and SLAs. **The real cost:** LLM tokens from whichever providers your agents call.
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.
Odysseus is a self-hosted AI workspace: chat with local or hosted models, autonomous agents with tools and MCP, deep research, blind side-by-side model comparison, a writing editor, an email inbox with triage and reply drafts, notes, tasks and calendar sync. Its Cookbook looks at your hardware, recommends models that fit, then downloads and serves them for you through vLLM, SGLang, llama.cpp, MLX or Ollama. It's AGPL-3.0. Docker Compose gets it running at localhost:7000, with NVIDIA and AMD GPU overlays; pin the immutable image tag rather than latest. On Apple Silicon, Docker can't reach the GPU, so use the native install. Its own threat model says to treat it like an admin console: a logged-in admin can run shell commands, read and write files and send email. Keep auth on and never expose it directly to the internet. No paid tier; your costs are hardware and any hosted-API tokens. Solo tinkerers with a decent GPU get a lot for free. Small trusted teams on a private network can share it. Anything bigger needs a security review first. AGPL means that if you modify it and let others use it over a network, you owe them your source. The catch: it's young, the issue tracker is enormous, and it touches your email and your files. Without a capable GPU or plenty of RAM you're limited to small local models.
Free under AGPL. You pay for the hardware and any hosted-model tokens.
**Free:** Everything. AGPL-3.0-or-later (changed from MIT in June 2026). Bundled components keep their own licenses (llmfit and opencode code is MIT). **Self-hosted:** Docker Compose with the official multi-arch image, NVIDIA and AMD GPU overlays, or a native install (Python 3.11+, tmux). Apple Silicon needs the native install for GPU-accelerated serving. Designed for trusted users on a private network only. **Paid:** None. Costs are your hardware and any hosted-model API tokens.
Corsair is a TypeScript library that connects your product, or the AI agent inside it, to your users' Gmail, Slack, Notion, GitHub and hundreds of other apps with one syntax. It handles OAuth, token refresh, webhooks and per-user credentials, and your agent never sees the API keys. Apache 2.0, and the full SDK self-hosts free. Self-hosting means it runs inside your app on SQLite or Postgres, not a separate server. You build the connect, OAuth callback and approval pages yourself. The permission model is the best part: each integration gets a mode (open, cautious or strict), destructive calls can wait on a single-use approval link, and one flag isolates every user's data. Hub, the hosted option, builds those pages. Hobby is $0 for 50 connections, 100k webhook events and 3 team members; Pro is $200/mo for unlimited. Solo: free. Small teams: free until 50 connections or 3 people. Larger teams: Pro, or self-host. Composio and Nango sell the same layer. The catch: it's a 0.1.x package in a repo about a year old, and an approval gate only works if each endpoint's risk level is labeled right. Check the endpoints you rely on before giving it production accounts.
Self-hosting the full SDK is free, but you build the connect and approval pages. Hub is $0 up to 50 connections and 3 team members, then $200/mo Pro with nothing in between.
**Free:** The full SDK under Apache 2.0: every integration plugin, the open/cautious/strict permission modes, approval flow, multi-tenancy and per-tenant caching. Corsair's site says "Run the full SDK on your own infrastructure at no cost. No per-seat pricing." Hub Hobby is also $0/mo: unlimited tool calls, 50 connections, 100k webhook events, unlimited managed permission and auth pages, up to 3 team members, Corsair branding on the consent screen, Discord community support. No credit card required. **Self-hosted:** "Manual" mode. Corsair runs inside your app (npm packages per integration) and stores data in five tables in SQLite or PostgreSQL, with credentials encrypted under a key (KEK) you generate. Lose the KEK and you lose every stored credential. You build and host the connect page, the OAuth callback route (one per environment, registered with each provider) and the approval review page. Without the permissions table, any endpoint that needs approval falls back to deny. **Paid:** Hub Pro is $200/mo (listed monthly; no annual option shown): unlimited connections, webhooks and team members, custom consent-screen branding, Slack support, and custom integrations built by the Corsair team. Enterprise is custom. On Hub, your users' tokens still land in your database; Hub keeps your app's OAuth client ID and secret, not your tenants' tokens.
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.
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.
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.
OpenDots is CopilotKit's open answer to OpenAI's Dots, launched the same day: a web app where you spin up always-on AI coworkers, each with a role, permissions, its own sandboxed computer, a Slack presence and voice calls. The app code is MIT. The part that makes chat work is not. Conversations run through CopilotKit Intelligence, a proprietary backend. You either use CopilotKit's hosted service, run a local evaluation in Docker Desktop on macOS that wants 12 GiB of RAM and expires every 30 days, or buy a self-hosted license. Bring your own OpenAI-compatible model key; voice calls only work through OpenAI's Realtime API. Dot computers need OpenBot's container services (CopilotKit/OpenBot). The free Developer tier covers one developer with 3-day thread retention. Pro is $39 a month, Team is $100 per seat a month for up to 5 seats, and Team is the cheapest plan that includes self-hosting. Solo tinkerers can try it free. Teams eyeing production should price Team or Enterprise before forking anything. n8n (n8n-io/n8n) and Dify (langgenius/dify) self-host end to end if the lock-in bothers you. The catch: it's an alpha template with no releases, single-owner by design (no shared editing yet), and telemetry is on by default. Open source here means the front of the house.
MIT app, proprietary backend. Free to try on CopilotKit's Developer tier; production self-hosting starts at the $100/seat Team plan.
**Free:** The OpenDots app (UI, server, SQLite page storage) is MIT. CopilotKit Intelligence, which conversations require, has a free Developer plan: one developer, 3-day thread retention, 200 max threads, 1 GB storage, 500 channel credits total. **Self-hosted:** The app self-hosts with Node 24 or Docker. Intelligence does not, unless you pay: the only free local option is a macOS Docker Desktop evaluation (4+ CPUs, 12 GiB RAM, 40 GiB disk) that expires every 30 days and needs internet to renew. Production self-hosting requires the Team plan or Enterprise. **Paid (CopilotKit Intelligence):** Pro $39/month (5,000 threads, 10 Slack/Teams channels). Team $100/seat/month, up to 5 seats, includes self-hosting with database. Enterprise is custom with VPC/on-prem and an SLA. On top of that: your model API spend, OpenAI Realtime for voice, and optionally a Parallel key for web research beyond the free anonymous tier.
Nexent builds AI agents from a plain-language description. Say what the agent should do and it generates one, wired to MCP tools, a searchable knowledge base of your documents, memory and other agents. Huawei is behind it (the code's copyright is Huawei Technologies), it's MIT licensed, and it competes with Dify, Coze and Flowise. Self-hosting is free.
This is not a weekend toy. The Docker minimum is 4 cores, 8 GiB of RAM and 40 GiB of disk, and the stack brings Elasticsearch, PostgreSQL, Redis, MinIO and a slimmed-down Supabase for auth. bash deploy.sh docker walks you through it; Helm covers Kubernetes. You bring your own OpenAI-compatible models, so the LLM bill is yours.
There is no paid tier or hosted version; the website the README links to doesn't resolve. Solo: free, with a spare 16 GB box. Small teams: free, with multi-tenancy and role-based access built in. Larger teams: free, but you are the support desk.
The catch is security. An October 14 CVE lets any signed-in user read other tenants' knowledge-base files through version 2.7.0, and the access check on main still allows it. Two unauthenticated file-deletion bugs hit the 1.x line in May. Keep it single-tenant and off the public internet.
Free under MIT with no paid tier; budget for a 16 GB server and your own LLM API usage, not a license.
**Free:** All of it. MIT-licensed code with no paid edition, no feature gates and no hosted plan found. Agent generation, MCP tools, knowledge base, two-tier memory, A2A multi-agent, agent marketplace, multi-tenancy and RBAC all ship in the repo. **Self-hosted:** Docker Compose (`bash deploy.sh docker`, minimum 4 cores / 8 GiB RAM / 40 GiB disk, 8 cores / 16 GiB recommended) or Kubernetes 1.24+ with Helm 3 (16 GiB minimum, 64 GiB recommended). The infrastructure release runs Elasticsearch, PostgreSQL, Redis and MinIO; offline image packages exist for air-gapped installs. **Paid:** No paid tier. The real ongoing cost is your model provider (any OpenAI-compatible LLM, embedding, vision and speech APIs) plus the server. The nexent.tech site linked from the README does not resolve, and an older license page in the docs still describes a commercial license for multi-tenant SaaS that the current MIT LICENSE file no longer contains.
FrontierAgent is the agent runtime Apodex built to benchmark its own models, released free under Apache-2.0. It runs in your terminal for long research and file work. ReAct mode runs one agent that researches, edits files and runs commands in a sandbox; Agent Team mode has a coordinator hand work to parallel sub-agents from a live task board, then merge their reports.
Setup is a uv tool install away, but you need Git, Python 3.12 and uv first, and the prebuilt container image is private, so Docker users build their own. Point it at any OpenAI-compatible endpoint, or serve the open Apodex-1.1-mini weights through SGLang on an NVIDIA box. The sandbox is worth copying: read-only /inputs, scratch /workspace, deliverables in /outputs, fail-closed errors, and file changes wait for your approval.
The runtime is free; tokens are not. Solo: free and worth an evening. Small teams: pin a commit; there are no tagged releases. Larger teams: LangGraph, CrewAI or goose have longer track records.
The catch: it's a vendor harness built to sell the vendor's model. The "free for the next two weeks" API banner has been up since August, the benchmarks are Apodex's own, and main hasn't moved since mid-October.
Free runtime under Apache-2.0. You pay for tokens wherever you point it; on Apodex's own API that's $0.30 in and $3.00 out per 1M tokens for the flagship model.
**Free:** The whole runtime under Apache-2.0: the terminal UI, the ReAct and Agent Team workflows, the tool layer, the sandbox and the benchmark harness. Nothing is gated. The Apodex-1.1-mini model weights on Hugging Face are also Apache-2.0. **Self-hosted:** The only way to run it. Install with `uv tool install` (needs Git, Python 3.12 and uv) or from a clone; Docker is optional and the published container image is private, so Docker users build it locally. Bring any OpenAI-compatible endpoint, or serve Apodex-1.1-mini locally through SGLang on a Linux NVIDIA GPU. Windows runs through WSL2. **Paid:** Nothing from the project. The bill is model tokens. Apodex's own API is usage-based with no subscription: Apodex 1.1 at $0.30 per 1M input tokens and $3.00 per 1M output, Apodex 1.1 Mini at $0.10 in and $1.00 out, and requests over 200K input tokens bill at 2x. Its Deep Research tier runs $5.00 in and $20.00 out per 1M tokens.
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 visual builder for AI apps: chatbots, RAG over your documents and agent workflows on a visual canvas, each exposed as an API. It works with hundreds of hosted and local models. Picture n8n rebuilt around LLMs. The Community Edition is free to self-host.
Self-hosting starts with docker compose up -d on a box with 2 cores and 4 GiB of RAM, but the default stack is about 15 containers: API, workers, web, Postgres, Redis, code sandboxes, a plugin daemon, SSRF proxies, Nginx and Weaviate. Read release notes before upgrading: 1.17.1 required a staged manual Weaviate upgrade or vector search could silently break.
Dify Cloud has a free Sandbox tier. Professional is $59 per workspace a month for 3 members; Team is $159 a month for 50. Self-hosted Community is one workspace, and SSO is Enterprise only, custom priced. Solo: self-host free. Small teams: self-host, or Professional to skip the ops. Larger orgs: Enterprise once you need SSO.
The catch is the license: Apache 2.0 plus conditions. No multi-tenant hosting and no removing the Dify logo from the frontend without a commercial license. Security has been rough too, with a run of cross-tenant bugs through 2026. Patch fast.
Self-hosting is free for a single workspace if you keep the logo and don't resell it as multi-tenant SaaS. Cloud runs $59 or $159 per workspace a month ($590 or $1,590 a year), and SSO or multiple workspaces means an Enterprise contract.
**Free:** Self-hosted Community Edition: all core features in the public repo (workflow canvas, RAG pipeline, agents, prompt IDE, model management, APIs), limited to a single workspace and bound by the Dify Open Source License. Dify Cloud Sandbox is also free: 200 message credits, 1 member, 5 apps, 50 knowledge documents, 50MB storage, 30 days of logs, 5,000 API calls a month. **Self-hosted:** Docker Compose on at least 2 CPU cores and 4 GiB RAM. The default profile starts about 15 services (api, api_websocket, worker, worker_beat, web, Postgres, Redis, two sandboxes, plugin_daemon, agent_backend, two Squid SSRF proxies, Nginx, Weaviate); MySQL and about 15 other vector stores are optional profiles. You bring your own model API keys. Upgrades can need manual steps: 1.17.1 required a staged Weaviate upgrade from 1.27.0 to 1.39.2. The license forbids running it as a multi-tenant service (one tenant = one workspace) or removing the logo and copyright from the web frontend without a commercial license. The pricing page frames Community as for "non-commercial projects", but the LICENSE itself allows commercial use outside those two conditions. **Paid:** Dify Cloud Professional: $59 per workspace per month or $590 per workspace per year (annual saves 17%), 5,000 message credits a month, 3 members, 50 apps, 500 knowledge documents, 5GB storage. Team: $159 per workspace per month or $1,590 per year, 10,000 message credits a month, 50 members, 200 apps, 1,000 documents, 20GB storage. Prices exclude tax. Enterprise (self-hosted or cloud): custom pricing, adds a commercial license, multiple workspaces, SSO, negotiated SLAs and official support.
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.
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.
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.
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.
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.
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.
Unreal Agent is a Go library and command-line runner for building coding agents, the plumbing behind tools like codex exec or claude -p. Its twist is async tool calls: a slow command runs in the background while the model keeps working, instead of burning turns waiting. Sessions are saved, append-only and forkable. MIT, from Unreal Labs.
It plugs into OpenAI, OpenRouter, Fireworks and Ollama, or reuses a Codex ChatGPT login. The tool set is deliberately small: a shell, image viewing and skills. The company's own benchmarks claim Codex-level scores at up to 40% lower cost. Those numbers are self-reported.
Teams building their own agent harness in Go, or chasing cost per task: worth reading and forking. People who just want a coding agent should use Codex or Claude Code directly.
The catch: the official Docker image is published as unrea1labs, with the digit 1 where the l should be, and someone else holds the correctly spelled name on Docker Hub. Install from the Go module or GitHub releases instead, and note the repo hasn't moved since its first week.
Completely free and MIT. Your bill is the model provider.
**Free:** Everything. MIT licensed Go library and runner, with release binaries for macOS and Linux. **Self-hosted:** Go 1.27+ to build, or use the release tarballs. You pay your own model provider. **Paid:** No product pricing. Unreal Labs invites companies to get in touch about cost-efficiency work.
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.
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.
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.
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.
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.