--- title: Swarm-Forge: Coordinating a Swarm of AI Agents for Engineering Development url: https://blog.krasovskiy.team/en/swarm-forge-coordinating-a-swarm-of-ai-agents-for-engineering-development/ date: 2026-08-08 lang: en source: blog.krasovskiy.team --- # Swarm-Forge: Coordinating a Swarm of AI Agents for Engineering Development Imagine a development team that works without disputes over branches, without merged conflicts and with ready-made PR at the exit - only it is not people, but a swarm of AI agents. Swarm-Forge assigns them roles as in a real devops department: one writes TDD code, the other cleans up the commit history, and the git worktree becomes their shared desktop. Run locally is a matter of one command: `g two-pack', and the system itself will deploy a pair of coder→cleaner agents that will go through the cycle from tests to refactoring and issue a clean pull request — without manual intervention. ## Swarm-Forge: what is it and how does it work as a tool for AI agents **Swarm-Forge** is a tool that transforms the chaos of AI agents into an organized development team. Its job is to coordinate a swarm of agents in real-world engineering tasks, assigning roles and managing the `git worktree` so agents don't interfere with each other. For example, running `g two-pack` will give you two agents: _coder_ writes code and _cleaner_ keeps the repository clean, each in its own `worktree`. To avoid conflicts, Swarm-Forge uses **tmux-sessions** (each agent works in its own window) and **proxy messages** — like an intermediary that filters and synchronizes the actions of agents. Supports ready-made configurations: two-pack (two agents), four-pack or six-pack to scale the team to the task. Result? Ready `pull request` with tests, clean commit history and refactoring, generated by _TDD cycles_. Written in Clojure, the project has already collected **1.7k stars** and **190 forks** on GitHub — proof that automating a swarm of agents is not a fantasy, but a working tool. ## How Swarm-Forge distributes roles and manages workflows Swarm-Forge transforms chaos into order with ready-made workflow configurations. The simplest is a **two-pack**: a pair of agents _coder_ and _cleaner_ work in separate `git worktree`, synchronizing via proxy messages. _Coder_ writes TDD code, generating tests and a minimal implementation, while _cleaner_ automatically refactors the result, following the style and cleanliness of the commit history. Started `g two-pack` — and after a few minutes you get a pull request with a full set of tests, ready for review. For more complex tasks, there is a **four-pack** (adds a _reviewer_ and a _tester_) and a **six-pack** — with agents for documentation and integration tests. Each swarm operates in an isolated tmux session, avoiding conflicts. For example, in _four-pack_ _tester_ runs scenarios on real data, and _reviewer_ validates architectural decisions. The result is a 100% automated cycle from idea to PR, where every step is repeatable and transparent. 1.7k stars on GitHub don't lie: it works. ## Technical Features: Clojure, GitHub, and Automation Clojure is a JVM-based functional language that is ideal for complex systems with parallel processes. Its immutable data structures and emphasis on composition make it a natural choice for coordinating a swarm of AI agents: each agent operates in an isolated context without affecting the state of the others. In Swarm-Forge, this allows you to dynamically assign roles (for example, _coder_ writes code, _cleaner_ refactors) without the risk of conflicts. The project has already collected 1.7k stars and 190 forks on GitHub - this is not just a number, but a signal that the tool solves real problems of engineering teams. Users are actively testing it in various scenarios: from developing microservices to automating DevOps pipelines. Forks often contain adaptations for specific workflows, such as integration with Kubernetes or custom TDD cycles. To start a local copy, it is enough to execute the command `g two-pack`. It deploys two separate _git worktrees_ — one for the coder agent and one for the cleaner agent. Each runs in its own tmux session, exchanging messages over a proxy channel. Result? Pull request with a clean history of commits, ready-made tests and automatically refactored code — without manual intervention. Automation here is not about "replacing developers", but about freeing them from routine. For example, _four-pack_ adds the roles of _reviewer_ and _tester_, turning a chaotic process into a predictable pipeline. And all this is on Clojure, which keeps the system flexible and easily modifiable. ## What Swarm-Forge Means for AI and SEO Professionals Swarm-Forge is not just another tool for AI developers, but an attempt to turn chaos into system. Imagine: instead of manually managing a dozen agents pulling the project in different directions, you run `g two-pack` — and the system itself distributes roles (for example, _coder→cleaner_), creates separate `worktree` for each agent, and makes sure that they do not overlap. Result? Pull request with a clean history of commits, ready-made tests and automatic refactoring — all according to TDD cycles, without manual intervention. For the team, this means less time for coordination, more time for development. And also — standardization of processes: ready-made configurations (_two-pack_, _four-pack_) allow you to scale work without loss of quality. SEO specialists should look at such solutions not only as a technical trick. The automation offered by Swarm-Forge is a preview of the future of content engineering, and platforms like AgentRQ are already demonstrating how AI agents can be [organically integrated into workflows](https://blog.krasovskiy.team/en/agentrq-a-platform-for-integrating-ai-agents-into-workflows/). If today the agents generate code, then tomorrow they will be able to optimize the technical aspects of the sites (speed, data structure) or even create content according to the given SEO templates — taking into account keywords, link building and adaptation to search engine algorithms. 1.7k stars on GitHub and 190 forks are not just numbers, but a signal: the industry is already moving towards collective AI intelligence. Whoever manages to integrate such tools into work processes earlier than competitors will gain an advantage in speed and quality.