Sandboxes, control planes, memory systems, and execution environments for AI agents.
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.
NemoClaw runs OpenClaw (the open source coding agent) inside NVIDIA's OpenShell sandbox with managed inference, solving the real security risk of agents executing arbitrary code on your machine. Your agent gets GPU-accelerated model inference through NVIDIA's infrastructure while staying sandboxed. This is NVIDIA saying 'run your coding agents on our hardware, securely.' You get the performance of NVIDIA GPUs for inference without managing the infrastructure yourself. The sandbox prevents the agent from doing anything destructive to your system. Apache 2.0 licensed. The catch: this ties you to NVIDIA's ecosystem. You need NVIDIA hardware or their cloud infrastructure, no running this on Apple Silicon or AMD GPUs. It's OpenClaw-specific, so Claude Code and Cursor users are out. And 'managed inference' is a gateway to NVIDIA's paid compute. The tool is free but the GPU time may not be.
Tool is free. GPU compute costs depend on whether you self-host or use NVIDIA's cloud.
Open source under Apache 2.0. The NemoClaw tool itself is free. Self-hosting requires NVIDIA GPUs. NVIDIA's managed inference (OpenShell) may have usage-based pricing for GPU compute; check NVIDIA's current pricing for NIM/OpenShell. Self-hosted: free if you already own NVIDIA hardware. Managed: likely usage-based GPU pricing through NVIDIA's platform.
DeerFlow is ByteDance's open source answer to Manus and ChatGPT's agent mode: an agent harness built to work a task for minutes or hours, not just answer a prompt. It ships the whole stack (backend, web UI, sandboxed execution, chat gateways for Slack, Telegram, Discord, and more) and gives the agent a real filesystem, persistent memory, loadable skills, and sub-agents to delegate to. MIT licensed, completely free. Self-hosting is real work. Python, Node, and nginx, an interactive setup wizard, Docker as the recommended path, and a hardware floor around 4 vCPU and 8 GB of RAM just to evaluate it. It's model-agnostic through any OpenAI-compatible API. The README is refreshingly blunt that improper deployment introduces security risks: this thing runs code, so it's designed to stay bound to localhost unless you put auth and network isolation in front of it. Use it if you want long-horizon agents on your own infrastructure with your choice of models. Solo and small teams: free, plus tokens. If you just want agent orchestration as a library, LangGraph (which DeerFlow builds on) or CrewAI is the lighter path, and OpenHands is the closest open comparison. The catch: 2.0 is a ground-up rewrite that shares no code with v1, so the project is popular but the current codebase is young, with a long open-issue tail. And an agent with shell access is a loaded tool. Mount credentials into its sandboxes carelessly and you'll regret it.
Completely free and MIT licensed. Your bill is model tokens, hardware, and optional E2B sandbox costs.
**Free:** Everything. MIT licensed with no paid tier, no hosted cloud, no enterprise SKU. The only CTA on the project site is self-hosted setup. **Self-hosted:** The only mode. Docker recommended; 4 vCPU / 8 GB RAM to evaluate, 8 vCPU / 16 GB for production, SQLite by default with Postgres for real deployments and Redis for multi-worker. **The real costs:** Model tokens on whatever OpenAI-compatible API you connect, plus optional E2B sandbox usage if you don't run sandboxes locally.
MemPalace stores your AI conversation history verbatim and searches it semantically. Every Claude session, every project file, indexed locally. The structure is a metaphor: projects become wings, topics become rooms, so you can scope searches instead of querying a flat blob. It publishes 96.6% recall on LongMemEval with no LLM in the loop, and the benchmarks are reproducible from the repo. Install is pip plus pointing it at a directory. ChromaDB is the default backend, embeddings run on CPU with a 300MB model, no API key required. The MCP server exposes 29 tools so Claude Code can read and write the palace directly during a session. Solo developers using Claude Code heavily: install it. The 'wake-up' command that loads relevant context for a new session is the pitch and it works. Small teams: each engineer runs their own palace, there is no shared knowledge layer yet. The catch: it's about two weeks old. The benchmarks are real but the operational track record is not. Breaking changes will happen, and fast-growing projects attract impostor domains. The README has a scam alert for a reason.
Free and open source. Runs entirely offline if you want.
**Free and open source.** MIT license. `pip install mempalace` and you're running. ChromaDB is the default backend, all free. Embeddings run on CPU using a local model of about 300MB, no API key required. The full 96.6% recall path runs entirely offline. **Optional paid:** None from the project. If you swap in OpenAI embeddings or use an LLM for the rerank tier, you pay those providers directly. The core retrieval path has no cloud dependency. No Cloud tier, no paid version, no company behind it yet. That's a feature if you care about data control and a risk if you need support.
QwenPaw is a personal AI assistant you run yourself instead of renting from OpenAI. It ships with a local runtime so it works with no API key out of the box, and it also plugs into Ollama, LM Studio, and a dozen-plus cloud providers if you want bigger models. The hook is reach: it talks to you through Discord, Telegram, Lark, WeChat, DingTalk, even iMessage, and you extend what it can do with skills. It is open source under Apache-2.0, built by the team behind AgentScope, Alibaba's multi-agent framework. Self-hosting is the default here, not an afterthought. There is Docker support and a one-click path to deploy on Alibaba Cloud if you would rather not run it at home, in which case you pay for the cloud, not the software. It takes its own security seriously for a personal tool: a kernel-level sandbox, a Tool Guard, and a File Guard sit between the model and your machine, which matters once an assistant can run code and touch your files. For a solo developer or a tinkerer who wants an assistant that lives in their own chat apps and on their own hardware, this is one of the more complete self-hosted options going, and it costs nothing. Small teams can share an instance. There is no real large-team story here; it is a personal workstation, not a company-wide deployment, and that is fine. The catch is gravity. It is deep in the Alibaba and Qwen ecosystem, the docs are heavily multi-language, and a lot of the built-in channels (WeChat, DingTalk, Lark) point at a Chinese user base. None of that is a flaw, but if you expected a Western-defaults, English-first assistant, calibrate before you install.
Free and open source under Apache-2.0. You only pay if you choose cloud hosting or paid model APIs.
**Free:** Apache-2.0, the whole thing. Local runtime (no API key needed), all the chat-channel integrations, the skills system, the sandbox. **Self-hosted:** The primary way to run it. Docker locally, or one-click to Alibaba Cloud where you pay infrastructure costs, not a license. **Paid:** None for the software. Your only costs are optional: cloud hosting if you do not self-host, or API fees if you point it at paid model providers instead of the local runtime.
Supermemory is a memory and context engine for AI apps. It extracts facts from conversations and documents, keeps a profile of each user, and runs hybrid search that blends RAG with personalized recall, all behind one API. The company reports top scores on the major memory benchmarks. The main repository is MIT, and plugins exist for Claude Code, Cursor and Codex.
Running it locally is one command, npx supermemory local, which starts a single binary with the same API as the hosted platform. It works fully offline with a local model through Ollama, and your data stays on your machine. The local server is single-user and licensed for up to 10,000 documents, though, and the connectors for Google Drive, Gmail, Notion and OneDrive, plus the Supermemory MCP, only exist on the hosted platform.
Hosted pricing is published and credit-based. Free includes $5 of credits a month and pauses when they run out. Pro is $19/mo with pay-as-you-go top-ups, Max is $100/mo, and Scale at $399/mo adds S3 and web crawler connectors, unlimited seats and a self-hosted option. Teams building production memory will land on Pro or Scale.
The catch is maturity. The local server is still version 0.0.x, and one August release was an emergency patch after an upgrade silently wiped search vectors. The consumer app and browser extension were retired in September too. Build on the API, pin versions, and back up your data.
Free locally up to 10,000 documents, or with $5/mo of hosted credits. Hosted plans run $19, $100 and $399 a month.
**Free tier:** The main monorepo is MIT, the TypeScript and Python client SDKs are Apache-2.0, and plugin licenses vary. A free local server runs ingestion, memory extraction, hybrid search and the full API on your own model key or a local model, up to 10,000 documents. The hosted Free plan includes $5 of credits a month, all plugins, the full search and memory API, 1 team seat and unlimited end users, and pauses when credits run out. **Self-hosted:** Install with `curl -fsSL https://supermemory.ai/install | bash` or `npx supermemory local`. The server ships as a prebuilt binary called supermemory lite, is licensed for up to 10,000 documents with the cap enforced at the API, runs a single org with one auto-generated API key, and stores data locally. Extraction runs on whatever model you point it at, including Ollama. Connectors and the Supermemory MCP are hosted-only. Production self-hosting of the full platform is a Scale and Enterprise feature. **Paid:** Pro is $19/mo ($20 of credits, pay-as-you-go top-ups, 3 seats). Max is $100/mo ($130 of credits, Gmail connector). Scale is $399/mo ($600 of credits, S3 and web crawler connectors, unlimited seats, SOC 2, HIPAA BAA, self-hosted option). Enterprise is custom with SSO, air-gapped self-hosting and an uptime SLA. Usage bills per unique SM token: memory at $0.005 (plain text) or $0.010 (rich content) per 1K, SuperRAG at $0.001 or $0.002 per 1K, and search at $0.005 per 1K queries.
Cc-switch wraps them into a single Tauri-based GUI. Cross-platform, open source, and free. Consider it a launcher that lets you switch between agents without context-switching between terminals. Setup is straightforward: download the app, configure your API keys, and pick which agents you want active. It doesn't add intelligence on top of the agents themselves. It's a convenience layer. The value is entirely in the unified interface and the ability to compare agent outputs side-by-side. Solo developers who already use multiple coding agents will get the most out of this. Teams probably don't need it since most teams standardize on one agent. If you only use one coding agent, there's nothing here for you. The catch: it's a wrapper, not a product. If the underlying agents change their CLI interfaces (which they do, frequently), cc-switch breaks until someone updates the integration. You're adding a dependency on a third-party GUI for tools that already work fine in a terminal.
Completely free. Funded by API proxy sponsors, not product sales.
**Free tier:** Everything. MIT-licensed desktop app with no paid features. **Self-hosted:** N/A. Desktop app with local SQLite storage. No server component. **Paid options:** None. The project is sponsor-funded by API proxy services, not by selling the tool itself.
MemPalace gives your AI assistant a long-term memory you actually own. It stores conversations and documents verbatim, nothing summarized away, then lets the assistant pull back the exact relevant pieces with semantic search. MIT licensed, free, no API key required, organized around a memory-palace metaphor: wings for people and projects, rooms for topics, drawers holding the original content. It started life strictly local, and that's still the default: a Python install, a pluggable vector backend (ChromaDB by default; Qdrant, pgvector, Milvus, and SQLite all work), and an MCP server with auto-save hooks for Claude Code. It has since grown past one machine. Recent releases added a team server with TLS and authentication, an HTTP transport for the MCP server, and a coordination layer that lets agents on different machines hand work to each other. Solo developers who want their assistant to remember context across sessions without shipping every conversation to a vendor: this is one of the strongest local options going. Small teams can now share one memory server instead of syncing folders. The closest comparison, supermemory, leans on a hosted API; MemPalace's pitch is that everything stays yours. The catch is pace. It ships releases constantly, and the feature set moves month to month. Pin your version if you depend on it.
Completely free and open source: no cloud, no API key, no paid tier, whether you run it locally or as a team server.
**Free:** Everything. MIT licensed, no hosted tier, no API key required. Run it locally or stand up the team server on your own hardware with the vector backend of your choice. **Cost you'll actually pay:** Your own compute, plus setup time to wire the MCP server and pick a backend. The team server adds TLS certificates and auth config to manage. Optional reranking can call a hosted model, but the core runs without any API. **The trade:** You keep all memory data on machines you control and pay nothing, in exchange for running and updating a fast-moving codebase yourself.
IronClaw is a personal AI assistant that runs entirely on your own machine. Built by NEAR AI, it's what you reach for when you want an always-on agent that reads your email, runs scheduled jobs, and answers from Telegram or Slack, but you don't want any of that data leaving your control. Everything is stored locally and encrypted. It's dual-licensed Apache 2.0 and MIT, completely free and open source.
It ships as a single Rust binary, which is the whole pitch: native speed, memory safety, nothing extra to babysit. Install is a shell script or Homebrew, then ironclaw onboard wires up your LLM provider. It leans on Postgres for persistence rather than SQLite, and runs untrusted tools inside a WASM sandbox or Docker, so the security story is built in, not bolted on. You bring your own model API keys, and you'll want Postgres running somewhere.
This is a young project, a Rust reimplementation inspired by OpenClaw, so treat it as early but serious. Solo devs and privacy-minded tinkerers: this is the fun one, a local agent you actually control. Small teams: usable for internal automation if someone's comfortable with Rust and Postgres. Large teams: watch it, don't bet a production workflow on it yet.
The catch is that "Agent OS" is carrying a lot of weight in the description. You're running an early-stage framework, not a finished product, and the work of wiring up providers, keys, and a database is on you. The privacy guarantee is only as good as the setup you build around it.
Free and open source (Apache 2.0 / MIT). You pay only your LLM provider, plus the effort of running Postgres and managing your own keys.
## Free Dual-licensed Apache 2.0 and MIT. Fully free and open source, every feature included. No paid tier from the project. ## Self-hosted This is the only way to run it, and it's the point. A single Rust binary installed via script or Homebrew, backed by Postgres for persistence. You supply your own LLM provider API keys, so model costs are separate. Untrusted tools run in a WASM sandbox or Docker. ## Paid No paid or hosted tier. Your only ongoing cost is whatever your LLM provider charges for the calls the agent makes.
Cherry Studio puts every LLM behind one desktop window: chat with OpenAI, Claude, Gemini, or a local Ollama model from the same app, with hundreds of preconfigured assistants, knowledge bases, document processing, and MCP support for calling external tools. Download it for Windows, Mac, or Linux and it just runs. No server, no Docker. The Community Edition is AGPL-3.0, and unusually for dual-licensed projects, there's no seat cap or revenue threshold hiding in the license file: commercial use is allowed outright as long as you comply with AGPL. The paid commercial license exists purely to buy an exemption from AGPL obligations, and a separate Enterprise Edition adds private deployment, an admin console, RBAC, and quota management at quote-only pricing. Solo and small teams: free, plus whatever API keys you plug in. Open WebUI and LibreChat are the browser-based comparisons; Jan and Chatbox are the desktop ones. Cherry Studio's edge is breadth: assistants, agents, knowledge bases, and MCP in one polished client. The catch: the enterprise side is oriented to the Chinese market (Alipay and bank transfer, quote-based sales), the license terms have been revised repeatedly over the project's life, and the issue tracker runs long. Read the AGPL before you fork it into a product.
Free desktop app under AGPL. The paid license only buys an exemption from AGPL; Enterprise is quote-only with China-oriented payment rails.
**Free (Community Edition):** The full desktop app for Windows, macOS, and Linux under AGPL-3.0. Commercial use permitted under AGPL terms with no seat caps or revenue thresholds. Your API keys, your token costs. **Commercial license:** Quote-based, and it buys exactly one thing: exemption from AGPL obligations for teams shipping modified builds. **Enterprise Edition:** Cloud-hosted or private-deployed workspace with centralized model management, RBAC, user and quota management. Pricing is not public; sales run through bd@cherry-ai.com with Alipay and bank-transfer payment. Teams outside China should expect friction buying it.
LobeHub is the rebrand of LobeChat, and it grew up. What started as a slick self-hosted ChatGPT interface is now an agent operations platform: you build a team of AI agents, give them schedules and skills, and let them run tasks around the clock. It plugs into OpenAI, Claude, Gemini, and local models, with thousands of MCP plugins for tools and data. Open source under LobeHub's own community license, free to self-host, with a hosted cloud tier if you would rather not run it. Self-hosting is a Docker job, and it is genuinely one-click on Vercel, Zeabur, or Sealos when all you want is the chat experience. The interface is the easy part. You bring your own model API keys, so the real cost is whatever OpenAI or Anthropic charges per token, not the software. Running the full agent-operations layer with scheduling, agent groups, and persistent memory is more involved than the basic chat deployment. Solo builders should self-host: free, trivial setup, and a private front end for every model you use. The cloud tier meters credits rather than seats, which changes the math. Free gives you 500,000 credits a month, 10 MB of storage, and a short model list. Starter is $12.90 a month, or $9.90 if you pay yearly, for 5 million credits and access to Claude Sonnet 5. Premium is $24.90 monthly or $19.90 yearly for 15 million, and Ultimate is $49.90 or $39.90 for 35 million. Small teams that would rather buy credits than run Docker land on Starter or Premium. Enterprise is quoted for private deployment. The catch is the license. It is not plain MIT, and any organization standardizing on this internally needs to read the community license terms before it becomes load-bearing. The 24/7 agent-team story is also new, and how it holds up under real production load is still unproven.
Free to self-host under LobeHub's community license, which is not OSI open source. Hosted cloud is credit-metered: free at 500,000 credits a month, then $12.90, $24.90 and $49.90 a month for Starter, Premium and Ultimate, dropping to $9.90, $19.90 and $39.90 if you pay yearly.
### Free (Open Source) - Self-hosting is free under the LobeHub Community License, which is not an OSI-approved license - Docker image plus one-click deploy to Vercel, Zeabur or Sealos - Multi-model support (OpenAI, Claude, Gemini, local models) with your own API keys - Thousands of MCP plugins for tools and data - Agent teams, scheduling and memory in the self-hosted build - Hosted free plan: 500,000 credits per month, 10 MB file storage, limited model list (DeepSeek V4 Pro, Grok 4.6, Claude Haiku) ### Paid - Starter: $12.90 month to month, or $9.90 per month billed yearly ($118.80 per year, the 20% annual discount). 5,000,000 credits per month, 1 GB storage, expanded models including Claude Sonnet 5. Roughly 900 DeepSeek V4 Pro messages - Premium: $24.90 month to month, or $19.90 per month billed yearly ($238.80 per year). 15,000,000 credits per month, 2 GB storage, priority email support. Roughly 2,600 messages - Ultimate: $49.90 month to month, or $39.90 per month billed yearly ($478.80 per year). 35,000,000 credits per month, 4 GB storage, priority chat and email support. Roughly 6,000 messages - Enterprise: custom pricing for private deployment and custom solutions - Paid tiers also add early access to newly released models ### Self-Hosted Costs The software is free. A Docker deployment fits on a $10 to $20 per month VPS for personal use; the agent-operations layer with scheduled 24/7 runs wants more memory and a real database, so budget $40 to $80 per month. On top of that sit your own model API keys, which is where the money actually goes: token spend dwarfs hosting for anyone using the agents seriously. ### When to Pay Pay for cloud when you do not want to run Docker and you would rather buy pooled credits than juggle provider keys. The tiers are priced on credits, not seats, so a solo user burning a lot of tokens can justify Ultimate while a small team on light usage stays on Starter. Self-host when you want your keys and conversation history on your own box, or when your token spend is large enough that buying credits at retail stops making sense.
Hermes WebUI is a browser frontend for Hermes Agent, a self-hosted autonomous AI agent that holds memory across sessions, runs scheduled jobs, and integrates with messaging platforms. Free and MIT-licensed. Setup is moderate. You bring your own LLM API key (OpenAI, Anthropic, Google, DeepSeek, OpenRouter, others) and run the agent plus WebUI on your own hardware or VPS. Once running, the agent persists conversation context, learns from interactions, and can be triggered on a schedule. The web UI mirrors the CLI experience without locking you out when you close the terminal. For solo developers and small teams who want an AI agent that isn't tied to ChatGPT or Claude.ai, this is a real option. Your conversations, your memory, your hardware. The cost is your LLM API bill, which can climb fast if the agent is making frequent calls. Solo: probably $10 to $50 per month in API spend depending on usage. The catch is that "autonomous AI agent" is doing a lot of work in the description. These systems still hallucinate, still drift, still need supervision. Don't wire it into anything destructive without guardrails.
The software is free. Your real cost is the LLM API bill, which you control by your usage patterns.
**Free (software):** Hermes Agent and Hermes WebUI are both MIT-licensed. All features included. **Self-hosted reality:** Moderate. Standard web app stack, plus you wire in API keys for whichever LLM provider you choose. Nothing exotic, but configuring scheduled jobs and integrations takes some work. **LLM API costs:** Pay-as-you-go to your chosen provider. A casual user might spend $10 to $50 per month. An agent making frequent automated calls or running heavy reasoning loops can run several hundred per month.
BrowserOS is a Chromium fork built for AI agents to drive. The neo variant runs as a second browser where Claude Code, Cursor, or any MCP-compatible agent does web tasks in its own tabs using your logged-in accounts, with every session recorded and replayable as scrubbable video. The full browser variant is a daily driver with an agent built in. AGPL, free, bring your own model keys. Setup is signed installers for macOS and Windows, with Linux on the full browser. There's no BrowserOS subscription; cost is whatever your model provider charges, and local models via Ollama bring that to zero. Building from source is a Chromium build, so plan on hours, not minutes. This is for developers already using coding agents who want them doing authenticated web work, pulling data from dashboards, filling forms, without handing credentials to a cloud service. The proprietary comparisons are ChatGPT Atlas, Perplexity Comet, and Dia. The catch is trust and blast radius. You're giving a young third-party Chromium fork your live sessions, and an agent holding your cookies can act as you. Chromium forks also historically lag upstream on security patches. Keep it away from anything you can't afford to have clicked.
Completely free. You pay only your own model provider, or nothing with a local model.
**Free:** Everything. AGPL-3.0, signed binaries, no paid tier, no subscription, no pro version. **The real cost:** Your AI provider keys. 11+ providers supported; Gemini's free tier or a local model via Ollama brings the bill to zero. **The trade:** Free agentic browsing in exchange for trusting a young Chromium fork with your logged-in sessions.
Bifrost is an open source gateway that puts one OpenAI-compatible API in front of 20+ LLM providers (OpenAI, Anthropic, Bedrock, Vertex, and others). Same idea as LiteLLM, written in Go, with the team claiming significantly higher throughput at concurrency. Apache 2.0 and free to run yourself. Setup is as easy as it gets in this category: 'npx -y @maximhq/bifrost' to try, or Docker and a config file for real use. It has automatic failover, load balancing, semantic caching, MCP integration, plus governance pieces like per-team budgets and rate limits. A web UI handles config, so you don't have to live in YAML. For solo developers and small teams routing AI calls across providers, this is a direct LiteLLM alternative with less Python overhead. Larger teams comparing both will care about throughput claims under real load, verify on your traffic not the benchmark. Open core, with an enterprise tier for clustering, adaptive load balancing, and custom plugins. The catch: it's newer and less battle-tested than LiteLLM, and headline benchmarks rarely match production. If LiteLLM is already running cleanly, the migration story has to clear a real bar. If you're picking now, Bifrost's setup speed is a real win.
Open source AI gateway, free under Apache 2.0. Enterprise tier adds clustering and custom plugins; pricing is not public.
**Free:** The core gateway, Apache 2.0. All 20+ providers, semantic caching, governance, and the web UI. **Self-hosted:** 'npx -y @maximhq/bifrost' to try, Docker or Go SDK for production. Config via the web UI or a file. **Paid:** Enterprise tier adds clustering, adaptive load balancing, and custom plugins. Pricing is not public; cloud demo is available.
Agent Governance Toolkit puts a policy check between your AI agent and every action it takes. Tool calls, resource access, and agent-to-agent messages all get evaluated against rules you write before anything runs. The distinction that matters: this is application-layer enforcement, not prompt instructions asking a model to behave, so a jailbreak in the conversation does not talk its way past it. MIT, maintained by Microsoft, free. It is framework-agnostic on purpose, with adapters for LangChain, CrewAI, AutoGen, AWS Bedrock, Google ADK, and Azure AI among others, plus SDKs for Python, TypeScript, Rust, Go, and .NET. You get a CLI, a governance dashboard, and published specs mapped against the OWASP Agentic Top 10. Installation is a package manager command; the actual work is writing policy that reflects what your agents should be allowed to do, which nobody can do for you. Someone shipping a weekend agent can skip this. Anyone putting an autonomous agent in front of production systems or customer data needs this or an equivalent, and there is no free-versus-paid decision to make because Microsoft ships the whole thing MIT with no commercial gate. The catch is scope, and it is narrower than the marketing suggests. This governs what an agent does, not what a model says, so prompt injection that produces a bad answer rather than a bad action passes straight through and you still need a content safety layer beside it. It is also public preview, with breaking changes expected before GA.
Completely free and MIT with no commercial gate. Budget engineering time for policy authoring, not license cost.
### Free Tier All of it. Policy enforcement, the governance dashboard, the CLI, every framework adapter, and all five language SDKs. MIT licensed with no feature gating. ### Self-Hosted The only mode, and it is light: install the package from PyPI, npm, or NuGet and run policy evaluation in-process alongside your agent. No separate control plane to operate. The real cost is the engineering time to author and maintain policy, which is ongoing rather than one-time. ### Paid No paid tier from this project. Commercial equivalents live inside larger platforms, such as Azure AI Content Safety and the guardrail features bundled into Bedrock and Vertex, which are billed per request and tied to those clouds.
Engram gives it persistent memory. It's a Go binary with SQLite and full-text search that any AI agent can read and write to, so context survives across sessions. It works via MCP server, HTTP API, or CLI, meaning it's agent-agnostic. Claude Code, Codex, OpenClaw, or anything else that speaks HTTP can use it. Your agent writes memories during a session and reads them back next time. Full-text search (FTS5) means it retrieves relevant context, not just raw dumps. MIT licensed, Go. The catch: persistent memory is only useful if the agent writes good memories. Garbage in, garbage out. If the agent stores irrelevant context, it pollutes future sessions. SQLite is great for single-user but won't scale to a team sharing one memory store. And the MCP protocol is still young; not every agent supports it natively.
Free. Zero infrastructure cost: it's a single binary with embedded SQLite.
Fully open source under MIT. No paid tier, no hosted version. You run the Go binary on your machine. SQLite means zero infrastructure, no database server needed. Completely self-contained.
Kungfu tackles the thing that quietly breaks long agent sessions: context loss on a handoff. It's a continuity layer that preserves task state and context so agents like Codex, Claude, OpenCode, and Amp can pause, hand off, and resume without forgetting what they were doing. The project wraps this in unusually formal governance, cryptographic "Release Passports" and a written qualification spec. It's a real, deep monorepo spanning TypeScript, Rust, and C++, with a serious commit history behind it. This is not a thin repo coasting on a good README, the code is there and the engineering is deliberate. For teams running agents on multi-step work, the promise is fewer dropped threads and cleaner resumption. Solo or team, the license cost is zero. The catch is timing. Kungfu is alpha. The public packaging hasn't shipped ("v4 coming soon"), so today you're building from source, not running an install command. The ideas are strong and the foundation looks solid, but this is one to watch and test, not to put in front of production work yet.
Free and open source, but still pre-release. Build from source for now.
Free and open source under Apache 2.0, with no paid tier announced. The practical cost right now is effort: packages aren't published, so you build it from source until the v4 release lands.
Kiro Crew keeps agent work running after you shut the laptop. A long-lived Gateway process holds sessions, memory, schedules and approvals, so multi-step tasks run unattended, recurring jobs fire on schedule, and heartbeats watch a system until a human is actually needed. Apache 2.0, on hardware you control. Getting it up is a one-line installer, a desktop package, a Docker image, or a source build wanting Python 3.12 and Node 22. You work from a dashboard on localhost, the desktop app, the CLI, or through Slack and Discord. History and memory stay on the host. The software is free. The models are not. Every path runs on kiro-cli, so model access goes through a Kiro account: $0 gets 50 credits a month on Claude Sonnet 4.5, Pro is $20 per user for 1,000, and the ladder climbs to $200 for 10,000 with overage at 4 cents a credit. The catch is in the project's own boundary document. Kiro Crew is deliberately KiroACP-only, the agent provider setting accepts exactly one value, and kiro-cli is required. An RFC asking to lift that is still in draft. The license buys the harness, not the choice of model underneath.
The software is free and Apache 2.0, but it only runs on kiro-cli, so budget a Kiro plan: $0 for 50 credits a month, $20 per user for 1,000.
**Free tier:** The Kiro Crew software itself is Apache 2.0 with no paid edition of the project. The Gateway, dashboard, desktop app, CLI, scheduling, memory, subagents, approvals and the Slack and Discord connections are all in the public repository. Model access runs on Kiro Free at $0 per month, which grants 50 credits and access to Claude Sonnet 4.5 plus open-weight models, subject to rate limits. **Self-hosted:** Self-hosting is the default and only deployment mode. Install with a one-line script, a `.deb`, `.rpm` or AppImage desktop package, a Docker image for always-on servers, or a source build (Python 3.12+, Node 22+, npm, and kiro-cli). x86_64 and aarch64 both get first-class builds with SLSA provenance. The Linux desktop app needs glibc 2.34 or newer. Stable, Insider and Nightly channels are available on every install path. On Linux and macOS the agent can run inside an OS sandbox, which on Ubuntu 23.10 and newer needs the AppArmor profile the `.deb` or `.rpm` installs for you. **Paid:** You are buying Kiro credits, not Kiro Crew. Kiro Pro is $20 per user per month for 1,000 credits, Pro+ is $40 for 2,000, Pro Max is $100 for 5,000, and Power is $200 for 10,000. Paid tiers unlock premium models and allow add-on credits at $0.04 each. Kiro Enterprise is contact-sales and adds centralized billing, SSO, usage analytics and security controls. Note that the public repository ships its SSO and tunnel modules as deliberately inert stubs that report unavailable, with a separate enterprise package expected to supply the real implementations.
AgentENV runs thousands of isolated agent environments at once, which is exactly what reinforcement-learning training for agents needs. Written in Rust, it orchestrates Firecracker microVMs across a cluster with sub-50-millisecond snapshot pause and resume, memory forking, and S3-compatible storage. It comes from kvcache-ai, the group behind the well-regarded KTransformers, so the pedigree is real. The standout is the speed of the snapshotting. Forking agent state and pausing or resuming microVMs in under 50ms is what makes large-scale agentic RL practical instead of theoretical. This is free under MIT, but the audience is narrow: teams actually training agents at scale. Solo tinkering is possible, self-hosting on real infrastructure is the expectation. The catch is two-fold. It's infra-heavy, it wants Linux 6.8+ and access to /dev/kvm, so this is a datacenter or beefy-server tool, not a laptop one. And the README is blunt that the API has no authorization built in and must never be exposed publicly. Powerful and specialized, with sharp edges you have to respect.
Free and open source. Serious infrastructure for agentic RL, not a casual install.
Free and open source under MIT, no paid tier. The cost is entirely operational: it needs Linux 6.8+ with KVM access and real cluster infrastructure to be worth running. Heavy to deploy and deliberately unauthenticated, so it must stay on a private network.
Boxlite gives you lightweight sandboxes. Each sandbox is a stateful micro-VM with hardware isolation, snapshots, and an API to control it. Picture giving every AI agent its own disposable computer. The project is open source under Apache 2.0 and self-hosting is free. It's early but growing fast. The 'agent sandboxing' space is heating up as AI agents get more autonomous and need safer execution environments. The catch: this is emerging technology. The documentation and ecosystem are still maturing. Running Firecracker-based micro-VMs requires Linux with KVM support. No macOS, no Windows natively. And the question of whether you need full VM isolation versus Docker containers depends on your threat model. For most use cases, Docker is simpler. Boxlite is for when you can't trust the code being executed.
Free to self-host on Linux with KVM. No paid tier. Server cost is $20-40/mo for meaningful capacity.
Fully open source under Apache 2.0. No paid tier announced. Self-host on any Linux machine with KVM support. **Infrastructure cost:** Each micro-VM is lightweight (boots in <125ms, minimal RAM overhead), but you need a Linux host with KVM. A $20-40/mo dedicated server from Hetzner handles dozens of concurrent sandboxes. Cloud VMs from AWS/GCP work if they support nested virtualization. **Compared to alternatives:** E2B (commercial agent sandboxing) charges per sandbox-hour. Modal charges per compute-second. Boxlite is free to run yourself. The cost is the server and your ops time. **When it's worth it:** If you're running untrusted code from AI agents at any meaningful volume, self-hosted sandboxing saves significantly over pay-per-use commercial alternatives.
GitLab MCP fills the gap Anthropic left open. GitHub has an official MCP server for AI coding assistants. GitLab does not. This community-built server connects Claude Code, Cursor, Copilot, VS Code, and Codex to your GitLab instance, exposing merge requests, issues, pipelines, wiki, releases, and labels as callable tools. Setup is simple for local use: one npx command plus a personal access token. Self-hosted GitLab works fine with a custom API URL. For team deployments, there's a Docker image with OAuth2 support and multi-user remote authorization. Four auth methods cover everything from quick local testing to production multi-tenant setups. Solo developers on GitLab get AI coding assistant integration that was previously GitHub-only. Teams running self-hosted GitLab get the same MCP capabilities without migrating to GitHub. There's a read-only mode toggle for safety if you want to prevent the AI from making changes. The catch: community-maintained, not official GitLab or Anthropic. Feature parity depends on one maintainer keeping up with GitLab's API surface. The multi-user OAuth setup requires a public HTTPS endpoint and pre-registered GitLab app, which is non-trivial.
Completely free. Brings GitLab into the MCP ecosystem that was previously GitHub-only.
## Free Tier Everything. MIT licensed. Full GitLab API coverage, all auth methods, all transport modes. ## Self-Hosted Local: npx command + PAT environment variable. Remote/multi-user: Docker + public HTTPS URL + registered GitLab OAuth app. Moderate setup for team deployments. ## Paid Alternatives No direct paid competitor. GitHub's official MCP server is also free but only works with GitHub. GitLab's own AI features (GitLab Duo) are paid ($19-99/user/mo) and don't expose an MCP interface.
Mirage mounts S3 buckets, Google Drive, Slack, Gmail, and Redis side by side as one filesystem so an AI agent can use familiar Unix commands across all of them. Instead of teaching the agent five different SDKs, you point it at a virtual filesystem and let it grep, cat, cp, and pipe between services the way it would on a local disk. It's an abstraction layer designed for how agents already think.
Install is pip or npm or a curl one-liner. Python 3.12+ or Node 20+, macOS or Linux. You provide credentials for whichever backends you want to mount (AWS, Google, Slack, etc.) and Mirage exposes them as paths. There's no central service; everything runs locally inside the agent's environment.
Solo developers building agent workflows: this is the kind of glue you'd otherwise hand-roll, and having it as an Apache 2.0 package is useful. Small teams shipping agents: worth testing as part of your tooling stack. Large teams: monitor the project; it's young but the design is right.
The catch: v0.0.1, released May 6th, 2026. First public release. The abstraction is interesting but the implementation is brand new. Expect rough edges and breaking changes. Pin the version and read release notes carefully.
Free Apache 2.0 with no current commercial tier. Brand new project; pin your version.
**Free:** Apache 2.0, full source, no enterprise tier mentioned. Pip and npm packages, no account. **Self-hosted:** Runs in the agent's local environment. You manage credentials for whichever backends you mount. No central server to operate. **Paid:** None at this time. Strukto AI may build commercial offerings on top of it later, but the core is open.
Cindy is an open source AI agent that runs on your own machine and actually does the work, driving Claude Code or Codex, controlling a browser or the computer, and reaching into third-party apps. It ships as a desktop and mobile app with native binaries bundled in, so it's closer to a finished product than a framework you assemble. The client is Apache 2.0 and works fully local, including a "Skip Sign-In" path, so you can run it without an account and keep everything on your device. That's the free core, and for a lot of people it's the whole thing. Solo users and small teams can run it free against their own model keys. The monetization is an optional official Cindy service that bills model usage transparently, which is the sensible route for teams that want a managed backend instead of wiring up their own. The catch is maturity. Cindy is early and it shows, a large open-issue count and the rough edges you'd expect from a fast-moving agent app. The direction is good and the local-first stance is the right one, but test it on real tasks before you trust it with anything that matters.
The client is free and runs fully local. The official Cindy service is the optional paid path, billed on model usage.
### Free (open source client) Apache 2.0 desktop and mobile app, runs fully local. "Skip Sign-In" lets you use it with no account, pointing at your own model API keys. All the core agent capability is here at no cost. ### Paid (official Cindy service) Optional managed backend that bills model usage transparently. You pay for the tokens the agent consumes plus the convenience of not running your own infrastructure. ### When to Pay Reach for the hosted service when a team wants a shared, managed setup rather than each person wiring up their own keys and environment. Solo users rarely need it.
This MCP server wraps 41 Brazilian public APIs into one standardized interface your agent can query. The smart part: it doesn't dump all 200+ tools on your agent at once. BM25 search filters to show only relevant tools per query, and a query planner can combine multiple APIs in a single call. 24 of the APIs need no authentication at all. The remaining ones use 2 optional API keys you get with free registration. MIT licensed. Built in Python with async httpx, Pydantic v2, and rate limiting with backoff. The catch: this is Brazil-specific. If you're not working with Brazilian data, there's nothing here for you. And wrapping government APIs means you inherit their reliability issues: downtime, rate limits, and data quality are the API provider's problem, not Floci's. The project is brand new and maintained by what appears to be a single developer.
Free. Government APIs are free. The MCP wrapper is free.
Fully open source under MIT. No paid tier. The underlying Brazilian government APIs are free (24 need no key, rest require free registration).
Commonly gives coding agents a shared workspace instead of a fresh amnesiac session every time. Claude Code, Cursor, Codex, and your own agents each get persistent identity, their own memory, their own skills, and a workstation, and you talk to them in a chat room where the work actually accumulates. The problem it targets is real and annoying: every new agent session starts by re-explaining the project. Commonly keeps that context attached to the agent rather than to a terminal tab you closed. Task management and cross-runtime handoff sit on top. Installation is Docker with the Compose v2 plugin, then clone and run the install script, and you are on localhost:3000. Apache 2.0, self-hosted by default, with no per agent fee and no seat pricing. There is a live demo at commonly.me if you want to see it before committing a machine to it. The catch is that the README says the project is early, and it means it. This is a category where the shape of the right answer is still being argued about, and multi-agent workspaces have a habit of being rewritten. Self-host it, keep your data local, and do not build a team process on it yet.
Completely free and Apache 2.0 with no per agent or per seat charges. The cost is betting on a project that describes itself as early.
**Free:** Everything. Apache 2.0 licensed with no per agent fees, no seat pricing, and no feature gates. Persistent agent identity, memory, skills, task management, and multi-runtime support across Claude Code, Cursor, Codex, and custom agents. **Self-hosted:** Docker with the Compose v2 plugin. Clone the repository, run the install script, and the workspace is on localhost:3000. Self-hosting is the default deployment mode and keeps agent memory on your own infrastructure. **Paid:** No paid tier. A live demo runs at commonly.me, but there is no commercial edition or hosted plan being sold.
PilotDeck is an open source 'agent operating system' from OpenBMB, ModelBest, and Tsinghua's THUNLP, AGPL-3.0. It bundles three pieces most agent frameworks leave to you: a WorkSpace abstraction that keeps projects isolated, a white-box memory layer you can view and edit, and a smart router that sends cheap tasks to cheap models. Free, with a working web UI. Self-hosting is Docker, with TypeScript, Python, and Go components, so it's a real install, not a hobby script. The memory model is the most distinctive piece: instead of a black-box vector store you can't reason about, every entry is human-readable and auditable. The router claims around 70% cost reduction on real workloads by downgrading simple tasks to smaller models. For solo developers building agents who currently glue together LangGraph and a router, this collapses a few components into one and gives you a UI for memory and workspaces. Small teams running production agents get cost savings worth measuring. Larger orgs should treat it as research-grade until they verify the routing decisions on their own task mix. The catch: this is research-driven and the team is academic-plus-startup, so expect rapid changes and rough edges. The AGPL license also means anyone offering it as a service has to share modifications, which matters if you're embedding it inside a SaaS product. For internal use, it's an opinionated and ambitious starting point.
Completely free and open source under AGPL-3.0. The underlying LLM API calls are your own cost.
**Free:** The entire system under AGPL-3.0. WorkSpace, memory, routing, and web UI. **Self-hosted:** Docker deployment with multiple TypeScript, Python, and Go components. Real install, not a single binary. **Paid:** None from the project. The underlying model API calls (OpenAI, Anthropic, local) are your own cost.
Archestra sits between your AI agents and your company's data, and tries to make that connection safe enough for a real enterprise. It is an open-source control plane: an LLM gateway that fronts any model provider, a registry and gateway for MCP servers, an agent orchestrator, and a layer of guardrails (SSO, RBAC, sandboxed code execution, prompt-injection defense). The pitch is that you can let agents touch internal systems with auditing and cost limits instead of hoping nothing goes wrong. Self-hosting is free for teams under 30 people. This is enterprise infrastructure, and it installs like it. Docker, Helm, and Kubernetes are the deployment paths, so standing it up is a platform-team job, not an afternoon. The upside of self-hosting is the whole point of the product: your prompts, your data, and your agent traffic stay inside your own boundary, which is exactly the property security teams want before they let an LLM near anything sensitive. Solo builders and small teams experimenting with agents can run it free, but it is heavier than you need unless governance is the actual problem you are solving. Where it earns its keep is the mid-size company standardizing how dozens of agents reach internal tools: the AGPL self-host covers you up to 30 users, and past that you are into enterprise licensing. The comparison set is commercial AI gateways like Portkey or Kong's AI Gateway; Archestra's bet is open source plus security as the differentiator. Two catches. It is young and venture-backed, which means fast movement but also a roadmap that answers to investors, so watch how the open-core line shifts over time. And the README's talk of migrating from Claude Cowork and similar reads more like marketing than the substance underneath, which is solid. Judge it on the gateway and guardrails, not the launch copy.
Free to self-host under AGPL-3.0 below 30 users; enterprise licensing kicks in above that. Priced and built for companies, not solo tinkering.
**Free (self-hosted):** AGPL-3.0, free for teams under 30 users. The full control plane: LLM gateway, MCP registry and gateway, orchestrator, and guardrails. **Self-hosted:** Deploy via Docker, Helm, or Kubernetes. Your model traffic and data stay inside your infrastructure. Expect a platform-team effort to run it. **Paid (Enterprise):** Above 30 users you need a separate enterprise license. A managed cloud tier exists; pricing is not public. Contact-sales territory.
Codex-console is an integrated control panel for that workflow. Task management, batch processing, data export, auto-upload, log viewing, and packaging in one place. Built in Python with MIT license. The project provides compatibility fixes and experience optimizations for managing multiple concurrent AI coding sessions. The catch: the README and documentation are entirely in Chinese. If you don't read Chinese, you'll be navigating the tool through translation or code reading. The project is a console/dashboard wrapper. It doesn't do the AI work itself, it just helps you manage it. And at with limited English documentation, community support outside Chinese-speaking developers will be thin.
Free. Self-hosted Python console.
Fully open source under MIT. No paid tier, no hosted version. A Python application you run locally.
LLM Space is a desktop workbench for people building AI agents. Write the prompt, wire up the tools, run it, and watch every model call and tool invocation as it happens. Replay a failed run out of history and step through it. Threads are plain files on your machine and API keys stay local. MIT licensed and free, and the DeerFlow team says every release of bytedance/deer-flow is built and debugged inside it. There is no server to stand up. Download the DMG and go. Packaging is the constraint: the desktop app is macOS only, in a 27 MB edition on the system WebView or a 130 MB one with its own renderer. Linux gets a headless server build with no UI. It runs its own agent runtime, so it hosts your agent rather than observing one you already deployed. Use it while you are still shaping an agent and want to see what the model actually did instead of inferring it from logs. Solo builders: free, and the replay view alone earns the download. Small teams: free, though file-based threads make sharing a run manual. If you need hosted traces and production monitoring the whole team can see, langfuse/langfuse or LangSmith is the right shape. promptfoo/promptfoo fits better when evaluation is the main job. The catch: they only merge pull requests from the DeerFlow core team, so this is open source you can read and fork but not contribute to. Anonymous telemetry is on by default with a documented opt-out. And the public repo dates to mid-2026 even though the project claims a 2023 start, so treat the visible history as short.
Free and MIT; the only line item is model tokens, and replay-heavy debugging burns more of them than you expect.
### Free Everything that ships today. MIT license, both desktop editions, the Linux server build, the local runtime with models, tools, skills, MCP, and plugins, plus the generator that turns a thread into a runnable LangGraph agent. No account, no seat count, no gated features. The project is funded by sponsors and donations. ### Paid Nothing from the project. Your bill is model tokens paid straight to whichever provider you point it at. Worth knowing before you take the setup advice at face value: the README recommends ByteDance's BytePlus Coding Plan as the default model provider, and BytePlus is the project's gold sponsor. The repo describes itself as "cloud-ready for managed agents," but no hosted tier and no pricing exist today. ### Self-Hosted Costs Not really self-hosted, since it is a desktop app. The standard edition is about a 27 MB download and the performance edition about 130 MB; both share ~/.llm-space, so you can install either or both. Building from source needs Bun 1.3 or newer, or mise if you want the exact toolchain CI uses. The recurring cost is API spend, and it is easy to underestimate: an agent loop that retries, replays, and re-evaluates burns tokens considerably faster than chat does. Watch a long debugging session on a frontier model and you can clear $10 to $20 without noticing. ### When to Pay Pay when you outgrow one machine. Hosted platforms like LangSmith, Langfuse Cloud, and Weights & Biases Weave sell shared traces, dataset versioning, and production monitoring across a team, generally per seat or per trace. LLM Space does not try to be that, and its file-based threads make sharing a run a manual step. Also pay attention if you are not on a Mac, because the desktop app is macOS only and the Linux artifact is a headless server build.
Steel Browser is browser infrastructure for AI agents: a Chrome instance behind an API that an agent drives, with sessions that keep cookies and local storage alive between requests. It is the self-hosted answer to paying by the browser hour, and it is Apache-2.0. Docker is the fast path, and it also deploys to Railway or Render or runs on bare Node with Chrome. Control is Puppeteer and CDP, so everything you already know about driving Chrome still applies. What it saves you is assembly: stealth plugins and fingerprint management, proxy chain support for IP rotation, Chrome extension loading, and endpoints that turn a page straight into markdown, a screenshot, or a PDF. Solo developers and small teams building agents that browse: self-host it and the marginal cost of a session becomes your own compute. Medium teams: still self-host, but budget real operational time, because headless Chrome at concurrency is memory hungry and crashed sessions are normal rather than exceptional. Large teams running a fleet: compare honestly against Steel Cloud or Browserbase, because managed browser services exist precisely because scaling this is miserable. The catch: releases are still tagged beta and arrive months apart even though commits keep landing. The bigger one is that self-hosting means you personally own the anti-bot arms race. The stealth plugins are in the box, but keeping them effective against sites that actively fight automation is continuous work, and absorbing that work is most of what the hosted providers are actually charging for.
Self-hosting is free and Apache-2.0. Steel Cloud exists for teams who would rather not run headless Chrome at scale.
**Free tier:** The full open source browser API, Apache-2.0. No feature gating between the self-hosted build and what the hosted product runs. **Self-hosted:** One Docker command locally. For anything real, size the host for memory rather than CPU, because each Chrome session is expensive and concurrency is what breaks first. Deploy targets include Docker, Railway, Render, and plain Node with a system Chrome. You own session cleanup, crash recovery, proxy credentials, and keeping stealth measures current. Call it moderate ops that turns significant once concurrency climbs. **Paid cloud:** Steel Cloud is the managed version from the same team, for teams that want sessions without owning the infrastructure. Browserbase is the larger commercial competitor in the same space. **The real comparison:** per browser hour pricing looks expensive until you have run headless Chrome at concurrency yourself. The self-hosted route is genuinely free of licensing and genuinely not free of engineering time. Small volumes favor self-hosting decisively; large, spiky, adversarial workloads are where the hosted bill starts looking reasonable.
This gives you a local control center with full visibility. You get a dashboard that shows what OpenClaw is doing in real time, how much each task costs, and lets you set guardrails. It turns OpenClaw from 'fire and pray' into something you can actually trust and control. You see every API call, every decision branch, every token spent. You set budget limits, approve expensive operations, and kill tasks that go off the rails. MIT licensed, TypeScript. The catch: this is OpenClaw-specific. If you're using Claude Code, Cursor, or Codex, this does nothing for you. And 'control center' implies oversight, but you still need to understand what you're looking at. It surfaces the data, it doesn't interpret it for you. Early stage, so expect UI rough edges.
Free. Requires OpenClaw (also free/open source).
Fully open source under MIT. No paid tier. Runs locally alongside your OpenClaw installation. No separate hosting or account needed.
Qclaw is a GUI wrapper for OpenClaw that removes the command-line barrier. If you want to use AI coding tools but the terminal feels intimidating, Qclaw puts a graphical interface on top of OpenClaw's capabilities. Chinese-language interface, built for users who prefer visual interaction over command-line workflows. It translates OpenClaw's CLI operations into clickable buttons and forms. The catch: Chinese-language only, and it wraps another tool rather than providing standalone functionality. You still need OpenClaw installed underneath. If you're comfortable with a terminal, OpenClaw directly is more flexible. And because it depends on another project's API, breaking changes upstream can break Qclaw.
Free - GUI wrapper for OpenClaw.
Free and open source.
OpenSquirrel is a native desktop app that puts Codex, Cursor, and OpenCode in one window so you stop losing track of what each one is doing. A control plane for your AI coding agents, built in Rust with the GPUI framework. What's free: Everything. MIT licensed, fully open source. No paid tier, no cloud service. The pitch is honest: you're squirrely, you jump between agents, and you need a way to see them all at once without alt-tabbing through six terminal windows. The Rust/GPUI foundation means it's fast and native, not an Electron wrapper eating 2GB of RAM. The catch: this is early, so it's not battle-tested yet. GPUI (Zed's UI framework) is relatively new itself, so you're building on new foundations. If you only use one AI coding tool, this adds zero value. It's specifically for the multi-agent workflow that a growing number of developers are adopting.
Completely free. The expensive part is the AI coding tools you're already paying for.
### What's Free Everything. MIT license, no restrictions. The entire application is open source with no paid tier or hosted service. ### Build Cost You need Rust installed to compile from source. If you already have a Rust toolchain, it's a `cargo build`. If not, budget 15-20 minutes for setup. ### The Real Cost The AI coding tools you're running inside it. Claude Code Pro ($20/mo), Cursor Pro ($20/mo), Codex, those subscriptions add up. OpenSquirrel is free but it's a window into expensive tools. ### Value Proposition If you're already paying for multiple AI coding tools and losing context switching between them, this costs $0 and saves real time. If you use just one tool, skip it.
VM0 runs AI coding agents in isolated cloud sandboxes on a schedule. Describe a workflow in natural language, point it at a repo, and it executes in a Firecracker microVM with full Claude Code compatibility. Think of it as cron for AI agents, with sandboxing built in. The platform gives you persistence (resume, fork, version sessions), observability (logs, metrics, network visibility), and integration with 35,000+ skills via the skills.sh ecosystem. Self-hosting means running the Firecracker VM infrastructure yourself, which is a real infrastructure commitment. Solo developers who want to automate repetitive coding tasks (daily CI fixes, dependency updates, report generation) get the most value here. Teams running multiple agents benefit from the orchestration layer. The catch: this is very early stage. The license isn't a standard OSS license, the docs are sparse, and you're building on a startup's roadmap. The managed cloud is the realistic path for most users, and pricing for that isn't finalized yet.
Self-host for free if you can run Firecracker. Managed cloud pricing not yet public.
**Free tier:** Open source core for self-hosted deployment. Includes CLI, sandbox runtime, skill integrations. **Self-hosted:** Requires Firecracker microVM infrastructure. Non-trivial ops burden. Docker-based dev setup available. **Paid tier:** Managed cloud service at vm0.ai (pricing TBD, currently in early access).
ByteRover adds a persistent memory layer that travels with you. It works as a CLI tool that sits alongside Claude Code, Codex, or any agent that reads context files. It's a portable brain for your coding assistant.
Install it globally, run brv init in your project, and it creates a structured memory store. The agent can read and write to it during sessions, building up project knowledge over time. It stores things like architecture decisions, coding conventions, and task history. The data lives on your machine in JSON files.
This solves a real problem for developers who spend the first 5 minutes of every AI session re-explaining their project. Solo developers and small teams get the most value. The memory is project-scoped, so each repo gets its own context.
The catch: you're trusting a third-party tool to manage context that feeds directly into your AI agent. If the memory format drifts from what agents expect, or if the project goes unmaintained, you've got stale context files that might do more harm than good. And Claude Code already has its own CLAUDE.md convention for project context, so the overlap is real.
Free for local use. Cloud sync and enterprise features likely paid. Source-available, not open source.
**Free tier:** CLI is free to use locally under Elastic License 2.0 (source-available, not OSI-approved open source). **Self-hosted:** Runs locally with no infrastructure. Cloud sync requires ByteRover's hosted service (not self-hostable). **Paid options:** Not explicitly listed yet, but enterprise proxy support and cloud sync dependency strongly suggest paid tiers are coming. The Elastic License pattern (same as Elasticsearch, MongoDB) typically leads to commercial offerings.