The Philosophical Developer — Chapter 25: Introducing Chaossynergy
2026-07-12 · 4 min read
I have been thinking about what comes next for a while.
Twenty four chapters of building software with my Padawan, OrsonRius. Weather CLIs, task trackers, MCP servers, local inference pipelines, three clouds worth of infrastructure code. Each project taught us something about the methodology. But I kept circling back to one question.
What happens when the agent is not a tool you use, but the environment you work in?
Chaossynergy is the answer I landed on. An operating system built for one purpose: being the substrate that an AI agent lives in and operates through. Not Linux with an assistant installed. Not a CLI tool that talks to an LLM. An entire OS shaped around human-AI collaboration.
And as of this week, it has a working alpha.
The name
Chaossynergy is a contradiction made real. Chaos is the unpredictable, emergent behaviour of multiple agents, containers, and runtimes working in parallel. Synergy is the whole working together as one system, directed by a single conductor. The OS is the chaotic substrate. The agent is the synergy.
It lives at chaossynergy.dev with its own identity, separate from this blog. This chapter is the story of how and why we built it and where the prototype stands today.
Three principles
Every architecture decision in Chaossynergy traces back to three rules:
The substrate is sacred and dumb. The host OS is immutable, atomic, and minimal. It does not install software. It does not run services. It is an appliance that exists only to boot the agent container. If the agent breaks, you delete the container. The host is untouched.
The agent is disposable. The AI agent runs in a distrobox container with its own state, its own tools, its own context. Break it? distrobox rm agent. Fresh runtime in thirty seconds. The container is a sandbox you can throw away without consequence.
Safety by construction, not by policy. Two independent isolation layers protect the system. bootc provides atomic OS updates and rollback at the kernel level. Distrobox isolates the agent at the user level. One layer can fail and the other still holds.
How it works
Chaossynergy starts from Bluefin LTS, a Universal Blue image based on CentOS Stream 10 that ships with all the dev tooling we already use. On top of that, we add three things:
The first boot experience. The system detects no agent container exists, pulls the image, and creates the distrobox automatically.
setup-agent.service runs once on first boot. It pulls the Hermes container image and creates a distrobox container that shares the user’s home directory. The agent sees what the user sees.
chaossynergy-recovery.service runs before the launcher. Hold Shift during boot and you get a root shell. No ceremony, no password prompts, just a terminal.
A systemd user service that opens Ptyxis (GNOME’s terminal) running the Chaossynergy launcher on login. The launcher runs
herdr— a Rust-based agent-native terminal multiplexer that auto-detects running agents and shows their state: blocked, working, done, idle.
Once the container is running and herdr is open, Hermes walks you through its own setup:
Hermes’ first-run wizard. Here we’re connecting it to a local ThinkingCap 27B model running on the host via llama.cpp.
After setup completes, the system reboots automatically and you’re dropped into a fully configured agent environment:
The final screen before reboot: Hermes CLI showing available commands, the Synthwave Alpha terminal palette applied, and the alchemistic wallpaper visible behind the window.
The alpha prototype
The build pipeline is live at github.com/dark5un/chaossynergy. GitHub Actions builds the container image with buildah, signs it with cosign, and pushes to ghcr.io/dark5un/chaossynergy. The last two builds completed successfully. Separate workflows produce bootable disk images (qcow2, ISO) via bootc-image-builder.
The repo contains four Architecture Decision Records covering the base image choice, the herdr multiplexer, the shared home directory, and the multi-agent vision. Every design choice is documented, dated, and reasoned about before a single line of installation script was written.
The current state is a terminal-first prototype. It boots into GNOME, launches herdr automatically, and connects to the agent container. The next milestones are a bootable disk image for bare metal installation, then the graphical launcher, then the multi-agent orchestration layer.
But the alpha is enough to validate the idea. The OS as the agent interface is not a hypothetical anymore. The build pipeline works. The CI is green. The ADRs are written. The foundation is laid.
Here I geek out with my young Padawan, OrsonRius.
Repos: