A Turnkey Toolkit for Agentic Development with Flox Flox released a GitHub repository, agentic-development-with-flox, that consolidates nearly 80 turnkey Flox environments for agentic development, covering harnesses including Claude Code, Codex, OpenCode, Hermes Agent, Pi and OpenClaw. Flox positions its cross-language, cross-toolchain package and virtual environment manager as the reproducible layer of the agent stack, letting agents search millions of historical package versions and run conflicting dependencies such as OpenSSL 1.1.1q and 3.0.19 side by side without containers or VMs. Because the repo's environments ship no committed manifest.lock file, first-time activation resolves dependencies via the Flox Catalog and requires a free FloxHub login through `flox auth login`; a valid lockfile removes that requirement. A Turnkey Toolkit for Agentic Development with Flox Claude Code https://github.com/anthropics/claude-code , Codex https://github.com/openai/codex , OpenCode https://github.com/anomalyco/opencode , Hermes Agent https://github.com/nousresearch/hermes-agent , Pi https://github.com/earendil-works/pi , OpenClaw https://github.com/openclaw/openclaw . These are the agentic harnesses people can’t seem to stop obsessing about. But the harness by itself isn’t actually the most important tool in the agentic toolkit. Arguably, it’s the domain- or use-case-specific enhancements—the skills, tools, persistent memory, sandboxes, software for managing swarms of agents at once—that most matter. These give coding agents an understanding of their environing world, what they can do, what they have to work with, what matters… and what doesn’t. This also presupposes a definite environment in which an agent runs: a world consisting of pinned software packages, standard shell settings, and runtime services. It’s the one part of the stack that can be made reproducible, the one thing you can control… even when the behavior and output of stochastic agents isn’t and can’t. Enter Flox : a cross-language, cross-toolchain package manager that works across operating system and CPU/GPU architectures. Agentic tools use Flox to discover, find specific versions of, and install just the right dependencies, searching among millions of historical package versions. Flox doesn’t require using containers, installing or changing system-wide packages, or clobbering installed dependencies. Worlds within worlds Because Flox is also a cross-platform, cross-language, cross-architecture virtual environment manager , agentic tools won’t burn tokens resolving dependency conflicts. It’s even straightforward to run conflicting versions of dependencies in the same runtime, at the same time. Need OpenSSL versions 1.1.1q and 3.0.19 in the same Flox environment https://flox.dev/glossary/ flox-environment , side by side? No problem Best of all, Flox runs directly on your system—no containers or VMs required. And when you or your Hermes, Pi, or Claude Code minions are ready to share what you’ve created, the Flox environments that you built and perfected locally Just Work when friends, coworkers, or random users human and agentic alike pull and run them on their own machines. Read on to find out why Flox and FloxHub https://hub.flox.dev are perfect for vibe coding, prototyping, and agentic engineering… and how the Flox environments you work with locally travel to CI and prod, too. Looking for a specific agentic tool? Skip straight to the category that interests you: Agentic development with Flox This repo https://github.com/flox/agentic-development-with-flox consolidates nearly 80 environments into a one-stop resource for agentic development. Each folder is its own turnkey Flox environment, complete with a README.md that explains what it is, how it works, and what features / affordances it offers. Clone it to get started: Once you download and install Flox https://flox.dev/docs/install-flox/install/ , you can start Flox environments by running: None of the repo’s environments includes a committed manifest.lock file, so first-time activation https://flox.dev/glossary/ activation must resolve dependencies via the Flox Catalog. That requires a FloxHub login which is free https://flox.dev/blog/flox-catalog-login-requirement-what-you-need-to-know/ : just run flox auth login first. After a successful resolution, Flox saves the lockfile https://flox.dev/glossary/ lockfile locally, and activation with a valid lockfile doesn’t require login. If you want to try one of these environments, cd into its folder before activating it. If an environment defines services—like MCP servers, databases, model servers, workflow scheduling engines like Airflow , and so on—you can either start them at runtime or from within an activated session. This is all you need to start working with any of these tools, once you’ve configured whatever model credentials they require. As for the AI agents/assistants included with this repo, several get the knowledge + context https://flox.dev/blog/focusing-on-the-code-not-the-cruft/ they need from the Flox flox , floxify , and flox-debug skills; others will benefit from reading and referring back to the FLOX.md file that’s baked into the root of this repo. Flox retired its own MCP server in October 2026, chiefly because—as a thin wrapper around our CLI—agents could use the CLI directly. Flox focused its efforts on skills to make the best use of the CLI, bolstered by scripts to lower token costs and increase determinism. Some tools don’t need to know anything about Flox: Flox just provides the world and a declarative, predictable mechanism for reproducing this world that lets them run anytime/anywhere. How they run and what you do with them is up to you—or Skynet isn’t a thing yet, right? them …? Need validated production runtimes? The CUDA Kickstart Program gives teams a guided path to deploying hardened, validated CUDA-accelerated environments in production. Making agents reproducible, too Flox is also sponsoring Agent Stacks https://github.com/agent-stacks , an open source project aimed at making the agents themselves reproducible. Consider everything that goes into a typical agent setup: the agent, its skills, plugins, MCP servers, and the runtimes those components depend on. Install all of that ad hoc, and two developers running the “same” agent can end up running very different software. Agent Stacks packages these components together, pins their versions, and gives you a launcher that makes everything available to the agent without modifying your global configuration. Its agent-pkgs https://github.com/agent-stacks/agent-pkgs repository already contains hundreds of packaged plugins, including the Flox skills, and there's a Claude Code reference implementation https://github.com/agent-stacks/claude-code you can try today. The specification is still a draft, and features like sandboxing and secrets management https://flox.dev/glossary/ secrets-management remain works in progress. But the idea is compelling: if we're going to make development environments https://flox.dev/glossary/ development-environment reproducible for agents, why not make the agents themselves reproducible? Terminal coding agents Anthropic's official Claude Code CLI bundled with the Flox flox , floxify , and flox-debug skills. These give Claude Code the knowledge + context to discover packages, create and modify Flox environments, and troubleshoot the ones that don’t work as expected. Creates a turnkey Claude Code development environment with built-in Flox integration. The activation hook also removes the old Flox MCP registration if it finds one. Note : This environment should pick up new versions of Claude Code as they become available; just run flox upgrade within the repo directory to force an upgrade. Run it: cd claude-code && flox activate OpenAI's local AI coding agent with ChatGPT account integration and approval-based command execution. For full filesystem access, use codex --sandbox danger-full-access ; approval controls are separate. This environment includes the Flox skills and removes the old Flox MCP entry if one is present. Run it: cd codex && flox activate Open-source AI coding agent built for the terminal. Its TUI lets you switch between “build” for interactive development and “plan” for analysis + code exploration agents. In “plan” mode, OpenCode defaults to read-only behavior, asks before running shell commands, and is geared toward planning changes. You can point OpenCode at Anthropic’s Claude, OpenAI’s GPT models, or Google Gemini, along with local providers like Ollama . Uses a client/server architecture so the TUI is just one possible client. You can run the agent on one machine and drive it from another client . OpenCode offers an optional beta desktop app, plus an internal “@general” subagent that can perform complex searches + multi-step tasks. Run it: cd opencode && flox activate A deliberately minimal terminal coding agent. Pi gives the model four tools—read, bash, edit, write—and lets you add what you need with skills, extensions, prompt templates, themes, or Pi packages. It supports multiple providers and models, so you don’t need to buy into a single model vendor to use it. And it has an appealingly small amount of machinery between you, your code, and the model. The Flox environment includes the flox , floxify , and flox-debug skills. Pi has also added native MCP support, for anyone who still wants to connect tool servers. Skills and MCP aren’t enemies. One supplies instructions and practices; the other supplies connections to external systems. Run it: cd pi && flox activate Charm's glamorous, stylish, and surprisingly powerful AI coding agent front-end. Full disclosure : We here at Flox are fans. Ships with a self-bootstrapping wizard that encrypts/stores secrets using system keyring if available . Supports multiple providers—including Ollama The Flox skills are pre-integrated, too. Arguably the most versatile agentic coding assistant out there. Run it: cd crush && flox activate GitHub Copilot’s terminal-based agent, with repository context and access to GitHub workflows. Talk to it about a codebase, ask it to investigate issues or make changes, and review what it proposes before letting it run commands. The Flox environment includes the Flox skills, so Copilot can work with the same package and environment setup as the other agents in this repo. Run it: cd copilot-cli && flox activate Claw-adjacent agents The “claw” cluster is a loose family of self-hosted, open-source personal/coding-agent stacks with overlapping design goals viz.: local-first, sandboxed, multi-channel, pluggable providers but built in different languages with wildly different tradeoffs. If you want to test-drive several of these stacks side by side, Flox offers arguably the path of least resistance: You could even activate each environment and run them at the same time; you don’t need to worry about them stomping on one another’s runtimes or config. AI agent from Nous Research https://github.com/NousResearch with a built-in learning loop. Hermes identifies routine work and turns it into reusable skills, improves them during use, nudges itself to persist knowledge, and searches conversation history for recall across sessions. Runs as a persistent gateway you can talk to from a TUI and/or messaging platforms like Discord, Slack, WhatsApp, Signal, and email. Model choice is wide open: Nous Portal, OpenRouter, NVIDIA NIM, Hugging Face, OpenAI, and other compatible endpoints, all switchable via hermes model . Hermes also supports scheduled automations, spinning up isolated subagents for concurrent work, and multiple backends, so it can run on anything from a cheap VPS to a cloud GPU cluster. Hermes feels like a close relative of the seminal OpenClaw agent, but with a focus on learning from past work, building reusable behaviors, and running as a persistent agent. Run it: cd hermes-agent && flox activate Speaking of which…. Self-hosted AI assistant and agent platform. OpenClaw runs a persistent local gateway that multiple frontends can connect to: a built-in TUI, single-turn CLI agent mode, or external chat channels Telegram, Discord, WhatsApp . Uses OpenRouter as its model provider, facilitating access to a large catalog of models Claude, GPT, Gemini, Llama, etc. via a single API key. Features agent workspaces with session persistence, cron scheduling, plugin/skill systems, a browser automation subsystem, and sandbox containers for agent isolation. Includes a doctor command for health checks and self-repair. This Flox environment runs the gateway as a managed service flox activate -s that stops automatically when you exit. This means no orphaned daemons or persistent systemd units. Run it: cd openclaw && flox activate -s Secure personal AI assistant written in Rust by NEAR AI. Built around WASM-sandboxed tool execution with capability-based permissions, credential-leak detection, and HTTP allowlisting. Persistent memory runs on PostgreSQL + pgvector if you flox activate -s , enabling hybrid full-text and vector search Reciprocal Rank Fusion ; runs on an embedded libSQL database if you run without services e.g., flox activate . Multi-provider NEAR AI, Anthropic, OpenAI, Gemini, Copilot, Ollama, Mistral, OpenRouter, and more and multi-channel REPL, HTTP webhooks, Web Gateway, Telegram, Slack via WASM channels. A routines engine handles cron schedules, event triggers, webhook handlers, and heartbeat loops; a dynamic-tools feature can build new WASM tools from natural-language descriptions. Note : This Flox environment auto-detects Postgres-mode vs libSQL-mode based on whether you run flox activate -s . Run it: cd ironclaw && flox activate -s The repo also includes lighter or more specialized relatives, including nullclaw https://github.com/nullclaw/nullclaw , claw-code https://github.com/ultraworkers/claw-code , and claurst https://github.com/Kuberwastaken/claurst . They’re still available if that particular tradeoff interests you; they’re just not where I’d start a tour of the agentic tools people are gravitating toward in late 2026. Multi-agent orchestration & parallel workflows The next cluster is all about running multiple agents at once: either coordinating specialized sub-agents inside a single task, or fanning out several independent agents across isolated workspaces so you can review their work as it lands. Think of Herdr as a tmux https://github.com/tmux/tmux -like workspace manager that “understands” coding agents. It can track Claude Code, Codex, OpenCode, Pi, Hermes, and others in separate terminal panes, showing which are busy, which are waiting for interactive input, and which have finished. The panes survive terminal disconnects, and you can attach remotely over SSH. Run one agent, five agents, whatever you want; Herdr is about keeping track of what they’re all doing without juggling terminal windows. Its server runs independently of the Flox session, just as a tmux server does. That’s intentional: you detach and the agents keep working. Stop it explicitly with herdr server stop when you’re done. Run it: cd herdr && flox activate A git worktree manager designed for running coding agents side by side. One task gets one branch and one worktree, so two agents—or you and an agent—don’t work on the same files at the same time. wt switch -c creates the worktree; wt list shows what’s happening; wt merge gets the finished work back into the main checkout. Less exciting than a swarm of 100 autonomous agents, perhaps, but also less likely to micturate upon one another’s work. Worktrunk, then, really ties the room together. Run it: cd worktrunk && flox activate xum https://github.com/coder/xum née mux xum lets you plan and run tasks using multiple agents at the same time, each getting its own isolated workspace : git worktree, Docker container, SSH remote, or local directory. Multi-provider Anthropic, OpenAI, Google, xAI, DeepSeek, OpenRouter, Ollama, AWS Bedrock, GitHub Copilot with a plan/exec loop and built-in orchestrator sub-agents exec , explore , plan . Use the one-shot CLI xum run "Refactor the auth module" , the browser UI start the Flox service and hit localhost:3000 , or the desktop app. Perfect for “fan out N tasks, review diffs as they land”-type workflows. Run it: cd mux && flox activate -s Multi-agent orchestration platform that sits on top of Claude Code. Formerly known as Claude Flow. Ruflo coordinates specialized role-based agents—coder, tester, reviewer, architect, security, etc.—and adds memory, routing, and MCP integrations. There’s a lot going on here, and some of the project’s marketing claims are difficult to independently verify. Ruflo installs ruflo@latest via npm on first activation of this Flox environment. That means the downloaded version isn’t pinned by Flox, so inspect what you’re installing before giving it access to a repo or credentials. Run it: cd ruflo && flox activate Skills, browser automation & MCP There’s another big change since OpenClaw first dropped: much of the interesting work has moved from choosing the agent to choosing what the agent knows and can safely do. Skills package up instructions, reference material, and repeatable workflows. MCP connects agents to tools and services. You’ll find both in the wild, often in the same setup. It turns out there’s no law requiring you to pick a side. Flox has made the same shift. Its old MCP server is retired; the maintained Flox skills https://github.com/flox/flox-skills are flox , floxify , and flox-debug . They teach supported agents how to work with Flox rather than forcing every operation through a dedicated Flox MCP server. The floxify skill is particularly useful when you inherit a repo whose setup instructions nobody trusts: have an agent inspect the project and create a Flox environment for it. The agent does the detective work once; the environment is what you keep. Browser automation aimed at agents rather than people. Instead of dumping a huge blob of HTML into the context window and hoping the model finds the right button, agent-browser gives it a compact accessibility snapshot with element references it can click, fill, inspect, or screenshot. It works as a CLI or MCP server. The Flox environment provides Chromium on Linux, so there’s no separate browser download there. Browser automation is especially useful once you want the agent to test the application it just wrote. Run it: cd agent-browser && flox activate Lets an agent call MCP tools from the shell: list servers, inspect their schemas, invoke a tool, and get the result as text or JSON. Mcporter can reuse MCP server definitions already configured for Claude Code, Codex, Cursor, and other agents, or connect directly to a server. It can even turn a tool server into a standalone CLI. This is a useful counterexample to the notion that MCP has somehow gone away. Run it: cd mcporter && flox activate Sandboxing & supply-chain security Giving an agent the tools it needs to install packages, run commands, and mutate files is useful. It also invites the question as to what agent can and can’t do. Sandboxing software gives you a way to confine agents to a restricted environment—a “jail,” so to speak—and control which files they can read or mutate; which if any network destinations they can reach; and what local resources they can access. If an agent gets confused, makes mistakes, or goes rogue, a sandbox helps contain the damage. Kernel-enforced sandbox for AI agents. nono run --allow-cwd --