SquansQ – I Built a Multi-Agent AI Dev Platform to Stop Juggling Claude Code Windows
If you’ve spent any serious time building with AI coding tools, you’ve probably hit the same wall I did.
You open Claude Code to tackle a task. Then you realise you need something running in parallel — so you open another window. Then another. Before long you’ve got four or five terminals going, no real picture of which agent is doing what, and you’re spending more mental energy managing the chaos than actually shipping code.
That friction is what drove me to build SquansQ — a browser-based, multi-agent development orchestration platform that gives you a single command center for all your AI coding agents.
In this post I’ll walk you through what it is, why I built it, what’s under the hood, and where it’s going.
The Problem: Claude Code Is Brilliant — But It’s Single-Threaded
Claude Code is genuinely impressive for development. But the moment you try to scale beyond one task, the workflow breaks down fast.
There’s no built-in way to run multiple agents in parallel and keep track of them. You end up doing what I did — juggling multiple terminal windows, losing context, manually switching between projects, and constantly asking yourself “which window was handling the auth refactor again?”
The same issue exists with other AI dev tools like Loveable. They’re powerful in isolation, but the moment you want to coordinate work across multiple threads or projects simultaneously, you’re stuck.
What I wanted was something closer to how a real engineering team works — multiple people (or in this case, agents) working on different things at the same time, with one person keeping a view of the whole board.
The Solution: SquansQ
SquansQ is a browser-based multi-agent orchestration platform built on top of Claude Code. The core idea is simple: give yourself one interface to spin up, manage, monitor, and coordinate multiple AI coding agents — all running in parallel, each isolated in their own environment.
Instead of being bottlenecked by a single terminal and a single thread of thought, you distribute the work across a team of agents and keep control of the bigger picture from one dashboard.
Here’s what that looks like in practice.
Key Features
Multiple Workspaces and Projects
Within SquansQ you can create multiple workspaces, and within each workspace you can have multiple projects. Each project gets its own Claude Code agent running in an isolated git worktree — meaning agents don’t step on each other’s code.
Flipping between workspaces is instant, and each one shows you the live Claude Code session for that project.
The Root Agent — Your Orchestrator
At the top of the system sits the Root Agent: an orchestrator powered by its own MCP tools that handles planning and dispatching work to individual worker agents.
The Root Agent follows a five-step workflow:
Orient — assess the current state of all active projects
Plan — structure work into Release Trains and Atomic Tasks
Dispatch — spawn WorkerBee agents to handle each task
Monitor — track progress in real time via post-commit hooks
Complete — land finished trains and summarise outcomes
This means you can hand the Root Agent a high-level goal and let it figure out how to break it down and assign it — rather than manually managing every sub-task yourself.
WorkerBees: Isolated Claude Code Agents
Each WorkerBee is an individual Claude Code agent running in its own isolated git worktree, with its own branch and config directory. They’re completely independent of each other, which means you can run as many as you need without conflicts.
Release Trains and Atomic Tasks
Work is structured into two levels:
Release Trains are feature-area units of work. They come with a description that becomes the agent’s briefing document.
Atomic Tasks are the discrete, deliverable-level items within a Release Train — tracked on the Kanban board.
This structure gives you a clear hierarchy from high-level goal all the way down to individual agent output.
Native Kanban Board
Every task across every project lands on a built-in Kanban board. Columns for open, in progress, in review, and done — so you always have a birds-eye view of what’s actually happening, no matter how many agents are running.
When you context-switch between projects (and you will), the Kanban keeps you grounded.
Live Terminals and the Console Panel
Each agent gets a live terminal powered by xterm.js, with configurable pane layouts. You can watch what your agents are doing in real time.
There’s also a console panel — a browser-based command interface for running commands directly, without needing to drop into a terminal. Handy when you want to stay in the UI.
The sq CLI
For those who prefer the command line, SquansQ ships with a full sq CLI that gives you complete control from your terminal. You can list agents, kill agents, dispatch tasks, and more — all without touching the browser.
Real-Time Metrics and Event Streaming
The dashboard streams live events from all your agents — what they’re doing, what hooks have fired, and what’s changed. Token tracking is in place, and cost tracking is on the roadmap (right now it’s genuinely hard to pull Claude Code cost data directly, which is something I’m working on).
GitHub PR Support
WorkerBees can create GitHub PRs directly from their worktrees, which means the output of each agent can flow naturally into your existing review process.
Under the Hood: The Tech Stack
For anyone curious about what’s powering it:
LayerTechnologyServerNode.js, Express, TypeScriptClientReact, Vite, ZustandDatabaseSQLite via libsqlReal-timeWebSocketsTerminalsxterm.jsAgent ManagementClaude Code CLI (PTY processes)OrchestrationHTTP JSON-RPC 2.0 MCP server
Agents run as PTY processes managed by the Claude Code CLI, which is what gives you the live terminal output. The real-time dashboard is WebSocket-powered, so everything updates as it happens.
Getting Started
SquansQ supports three installation paths depending on your setup:
Local development via npm
npm install
npm run dev
Docker container
docker pull squansq/squansq
docker run squansq/squansq
Docker Compose
docker-compose up
The sq CLI can be installed globally via npm or run directly. Full setup instructions are in the GitHub repo.
What’s Still in Progress
I want to be straight about where things are. SquansQ is a working, usable platform — but it’s actively evolving.
A few things I’m still working on:
Cost tracking — token usage is visible but getting accurate cost data directly from Claude Code is tricky. This is a known gap.
Gemini integration — I want to add Gemini alongside Claude so you can choose your model per agent or per project.
Idle agent handling — occasionally a dispatched agent goes idle unexpectedly. I’m debugging the root cause.
UI polish — it’s functional, but there’s room to refine the layouts and flows.
The goal was to get something real in front of people early and build from there. If you’re using it and hit issues or have ideas, I want to hear about it.
Why This Changes How I Work
The biggest shift isn’t any single feature — it’s the overall mental model.
Before SquansQ, I had one agent, one thread, one bottleneck. My pace was limited by how fast a single Claude Code session could move.
Now I can hand off a set of tasks, let multiple agents work in parallel, and check back in via the Kanban or the dashboard. I’m spending more time thinking about architecture and direction, and less time babysitting terminals.
It’s still early, but even in this form it’s meaningfully changed how productive I feel on large builds.
Try It / Follow Along
SquansQ is open source under the MIT license.
🔗 GitHub: https://github.com/tarvitave/squansq-releases
I’ll be posting updates here and on YouTube as the platform evolves — new features, demos, and honest walkthroughs of what’s working and what isn’t. If you’re building with AI coding agents and running into the same coordination pain, give it a look.
And if you’ve built something similar, or have ideas for where this should go — drop a comment. I’m genuinely interested in how other people are solving this.
Colin Wynd builds AI-powered developer tools and writes about the process.
The World Wide Web, The Internet and The Cloud
The World Wide Web, The Internet and The Cloud
In 1983 ARPANET adopted the TCP/IP protocol for what was then called the ‘network of networks.’ Seven years later, computer scientist Tim Berners-Lee invented the World Wide Web, or what we would later refer to as the Internet.
As a backbone for connectivity, the Internet initially allowed stand-alone PC’s to share data. This sharing required users to define themselves and on-line security protocols to be developed. With this base of identity, control and access, what came next was a equivalent to an digital terraform, where entire societies of virtual personalities began to interact without geographical or societal constraints. The Internet provided the third component of the Intelligence Age: Collaboration.
Commercial use of the Internet quickly took hold in the early 1990’s, initially with static promotion sites that evolved into today’s on-line marketing, underground and non-traditional communication that later became on-line media and basic transactioning that became grew into what we call today’s eCommerce. Corporations later adopted Intranets, secured web sites with limited access for internal communications while individual users found new ways to interact via social networking.
In August 2006, internal and external usage collided into the current version of the Internet. During an Internet industry conference, Google CEO Eric Schmidt dusted off a 1960’s telephony term to describe a vision of unexpurgated access to information, processing and collaboration by both consumers and business on any mobile device of their choosing. Thus “the Cloud” was born as both a web-based architecture and a global Internet marketing term.
Now…The Intelligence Age
Now…The Intelligence Age
While the Information Age matured over the past three decades, futurists, scientists and engineers have envisioned a time where computing technology could work predictively. True, much literature and cinema put this capability in the hands of androids. And, as cool as that will be someday, the nearer future is where computing technologies ranging from our PC’s, tablets, smartphones, automobiles, appliances, etc. begin to act in concert with each other to pre-automate processes on our behalf. Today’s Internet of Things (IoT) is a great example of this approach. Smart, yes but intelligent, no.
IoT represents a conglomeration of static processes into a unified outcome. The next iteration of this is the conglomeration of dynamic processes into a unified outcome, based on the formulaic weighting of the fourth component of the Intelligence Age: Fluidity.
Today’s tools do not require any contextual consideration to make an optimized decision. AI, by definition, should include a decision-making process, otherwise it would just be another “smart” device strung in with other static processes. To make that decision, the computation needs to evaluate inputs, weigh a set of variables and then decide on and orchestrate an event based on the optimal solution of the context, which may change of the time.
Camera’s are an example of IoT. Many people have security cameras in their home, or outside. Today’s cameras are “static”, they might alert you when there’s movement, might start recording at certain times of the day, but by no means are they smart yet along intelligent. Some consumer camera technologies are becoming “smart”, by being able to identify who is in view of the camera – for example you really don’t want to be alerted when you come home, but you do want to know when a stranger approaches the house. This is currently available in expensive business systems, and will make its way into consumer technology. However, the next level is having the camera system integrate into the house system and when it detects you car coming home will open the garage door, unlock the door and disable the alarm system. It’s a combination of the integration between the IoT devices (car, camera, home etc) and the computation ability and their associated algorithms that leads to the fluidity.
The Industrial Age
The Industrial Age
The evolution of commercial and consumer technology has been on an accelerated trajectory. From the 1860’s to the 1960’s, a mere century in the span of humanity, we went from horse-drawn carriages to steam locomotion to flight to landing on the moon. The activities that define the Industrial Age were investments and advancements lent to the mass production and distribution of common items, initially crude elements like coal, oil and lumber and later packaged goods and prefabricated products, including automobiles.
But alongside these manufacturing improvements came process improvements, communications capabilities and many of the other attributes that we now take for granted in our personal and work lives. The single-most impactful of these inventions was the telephone. Alexander Graham Bell’s invention created the first component of the Intelligence Age: Communication.
Prior to the telephone, social communication was conducted through formal correspondence – letters, memorandum and telegraphs – that conveyed specific intents, actions and consequences. That formality even drove our personal interactions, which even the most spontaneous of included the etiquette of the day.
The telephone changed all that, providing a channel for individuals to connect with each other to interact, inform and communicate on a whim. In the early 1900’s, the telephone evolved from a business device to a household device. Today it’s almost a fashion accessory where nearly every individual in modern societies has one for all types of fluid communications.
How we got here
How we got here
Without a doubt, the two most important inventions in modern time are the telephone and the personal computer. Each tool helped usher in a new age of technology and change the face of business and our personal lives. As we migrate to the Intelligence Age, it makes sense to take a moment to evaluate how we got here.