Best Open Source Agent Runtimes & Sandboxes

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.

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.

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.

Supermemory is a memory and context engine for AI. It extracts facts from conversations, keeps a profile of who you are and what you are working on, and runs hybrid retrieval that blends RAG with personalized recall. It currently tops the main memory benchmarks (LongMemEval, LoCoMo, ConvoMem). Plug it into your own agent through the API, or use the consumer app and browser extension to add memory on top of ChatGPT and Claude. MIT. Self-host from source: `pip install supermemory` or `npm install supermemory`, or a one-line MCP install into Claude, Cursor, or VS Code. It syncs Google Drive, Gmail, Notion, and GitHub, and ingests PDFs, images, video, and code as first-class objects. A one-command local deployment runs the whole stack on your own box. Solo developers building agents: this is a faster path than rolling your own memory layer, and it is free. Small teams: the consumer app and developer SDK are both free, but production deployments will likely want the hosted API for managed retrieval and the syncing infrastructure. The consumer app at app.supermemory.ai is free for end users. The catch is that this is a young, fast-moving project. The abstraction is right and the benchmark numbers are real, but expect breaking changes, and the hosted API pricing is not published. Treat any production commitment as a conversation, not a click-to-buy.

Open core: MIT SDK and local deploy are free; the production hosted API has unpublished pricing.

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.

MemPalace gives your AI assistant a long-term memory that lives entirely on your own machine. It stores your conversations and documents verbatim, nothing summarized away, then lets the assistant pull back the exact relevant pieces with semantic search. No cloud, no API key, no subscription. It's MIT licensed and free, organized around a memory-palace metaphor: wings for people and projects, rooms for topics, drawers holding the original content. Under the hood it's a Python system with a pluggable vector backend, ChromaDB by default, with Qdrant, pgvector, and a SQLite option if you'd rather. The headline integration is an MCP server (now around 29 tools) with auto-save hooks for Claude Code, plus a CLI and a Python API, and there are now Docker images for both CPU and GPU. Recent work added a graph layer that links related memories, document mining for PDFs, Word, and PowerPoint files, and multilingual recall out of the box. Setup is moderate: install the package, pick a backend, wire up the MCP server. For a solo developer who wants their assistant to actually remember context across sessions without shipping every conversation to a vendor, this is one of the strongest local options going. The closest comparison is supermemory, which leans more on a hosted API; MemPalace's whole pitch is that everything stays local and free. Small teams can self-host it the same way. There's no paid tier to weigh, because there isn't one. The catch is pace. This is a very young, extremely fast-moving project that just graduated from one person's account to its own organization, and it ships releases constantly. The benchmark numbers it cites are strong, but expect rough edges and frequent changes, and pin your version if you're depending on it.

Completely free and open source, and built to stay local: no cloud, no API key, no paid tier.

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.

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 if you just want the chat experience. The catch is that the interface is the easy part. You bring your own model API keys, so your real cost is whatever OpenAI or Anthropic charges per token, not the software. Running the full agent-operations layer (scheduling, agent groups, memory) is more involved than the basic chat deployment. Solo builders who want a private, good-looking front end for multiple models should self-host, since it is free and the setup is trivial. Small teams wanting shared agents and MCP tooling get more out of the cloud tier, which saves the ops work. Larger orgs standardizing on an internal agent platform should read the community license terms before committing, because it is not plain MIT. The catch: "Chief Agent Operator" is a lot of ambition for software most people still use as a ChatGPT skin. The 24/7 agent-team story is real but new, and how well it holds up under actual production load is not yet proven.

Free to self-host under a community license, with a paid cloud tier. Your real cost is the model API keys you bring.

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.

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.

Agent Governance Toolkit puts deterministic policy enforcement between your AI agents and the actions they take. Every tool call, resource access, and inter-agent message gets evaluated against policy before execution. Not prompt-based safety (which fails 27% of the time in red-team tests) but application-layer enforcement with a 0% violation rate. Works with any agent framework: LangChain, CrewAI, AutoGen, AWS Bedrock, Google ADK, Azure AI, and 20+ others. Ships with a CLI (`agt`), governance dashboard, and covers all 10 OWASP Agentic risks. SDKs for Python, TypeScript, Rust, Go, and dotnet. Sub-millisecond policy checks. Free and open source under MIT. Solo devs building agents should use this from day one. Teams running agents in production need this or something like it. There is no excuse for shipping autonomous agents without action-level governance. The catch: this is still in public preview, so expect breaking changes before GA. It governs agent actions, not model outputs. For prompt-level safety, you still need a separate content moderation layer.

Completely free. Microsoft-backed, MIT licensed, no commercial gating.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.