QuadWork

QuadWork hands your product backlog to an autonomous four-agent team using Codex and Claude to ship complex work through rigorous reviews, with ticket-sized execution for maximum token efficiency.

Comment

Inspiration

AI coding agents can now produce impressive changes from a single prompt. But shipping software is more than generating code. Someone still has to break down the work, review the implementation, challenge risky assumptions, handle feedback, merge safely, and decide what should happen next.

That becomes the bottleneck for solo founders and small engineering teams. A single agent can move quickly, but manually supervising every pull request removes much of the leverage. Letting an agent merge directly to main creates a different problem: speed without a reliable quality gate.

QuadWork was inspired by a simple question: what if a founder could queue meaningful product work, then rely on a small AI team to carry it through a real engineering workflow until the whole batch is complete?

What it does

QuadWork turns a GitHub backlog into an autonomous, governed delivery loop.

A four-agent team works through a batch of tickets:

  • Head creates and manages the queue, assigns the next item, and merges approved work.
  • Dev implements the ticket in an isolated git worktree, opens a pull request, and addresses feedback.
  • Reviewer 1 independently reviews the pull request and can request changes or veto it.
  • Reviewer 2 performs a separate independent review with the same authority.

Each ticket follows the same contract:

Issue → Branch → Pull Request → Two independent reviews → Merge → Next ticket

The key is that QuadWork keeps going. Once a ticket is merged, Head picks the next queued item. A scheduled trigger can keep the team moving through an overnight batch, while the dashboard shows every ticket's live state from queued to in review to merged.

Tickets are not a limitation on the complexity of the work. They are the unit of planning, accountability, and verification. A ticket can represent a migration, feature, refactor, investigation, or quality sweep. By making each unit explicit, QuadWork makes complex roadmap work reviewable, traceable, and manageable as a complete batch.

How we built it

QuadWork is a local-first open-source application built with a Next.js dashboard, a Node.js and Express control server, WebSockets, node-pty, xterm.js, GitHub CLI integration, and isolated git worktrees.

The dashboard brings together four live agent terminals, shared coordination chat, GitHub state, batch progress, and operator controls in one view. GitHub remains the system of record for issues, pull requests, reviews, and merges.

QuadWork supports Codex, Claude, and Gemini CLI backends per role. This is intentional: implementation and skeptical review are different jobs, and operators should not have to bet an entire delivery pipeline on one model. Codex is a first-class backend with per-agent model and reasoning configuration, including GPT-5.6 variants, plus local MCP-based agent coordination.

We also built an operator MCP server, so an external agent can inspect team status, define a batch, start or stop it, and monitor progress without manually operating the dashboard.

Challenges we ran into

The hardest challenge was making autonomy trustworthy.

It is easy to start several coding agents. It is much harder to make their work safe, observable, and recoverable when the operator is not actively watching. We addressed this with isolated worktrees, GitHub pull requests, branch protection, two required independent reviewer approvals, sender identity safeguards, local history snapshots, and explicit controls for starting, stopping, and recovering a batch.

A second challenge was making multiple coding CLIs work consistently. Codex, Claude, and Gemini use different model flags, reasoning controls, permission modes, and MCP configuration patterns. QuadWork normalizes those operational differences behind role-based configuration while preserving each backend's strengths.

A third challenge was avoiding an opaque agent swarm. The queue, GitHub state, per-ticket progress, live terminals, and visible chat history all exist so an operator can understand what the team is doing and intervene when needed.

Accomplishments that we're proud of

We are proud that QuadWork is a complete workflow rather than a concept demo. It has a local installer, npm distribution, multi-project support, a live dashboard, GitHub-native delivery, Telegram and Discord monitoring bridges, an operator MCP server, and review-only batch modes.

The most important accomplishment is the governance model. QuadWork does not treat review as an optional final button. Two independent reviewers are part of the delivery protocol, and the queue does not advance as successfully shipped work until the required approvals and merge are complete.

We are also proud of the deliberate queue design. It gives long-running work a clear operating rhythm and lets the user reason about progress and model budget at the ticket level instead of trusting one enormous, open-ended agent session.

What we learned

We learned that autonomous coding is primarily a systems-design problem, not just a prompting problem.

Better models help, but reliable delivery comes from clear roles, explicit state, narrow handoffs, independent review, and recoverable operations. The useful measure is not simply how much code an agent can write. It is how much verified product work a team can ship with a bounded model budget and minimal human coordination.

We also learned that multi-model workflows are most valuable when roles have real independence. A reviewer is more useful when it can challenge the builder's assumptions, rather than simply continuing the same conversation.

What's next for QuadWork

Next, we want to make batch planning, quality signals, and recovery even stronger. We are exploring richer ticket decomposition, better dependency-aware queueing, more useful run analytics, and clearer ways to surface repeated review findings as future work.

We will continue improving support for Codex and other coding agents, but the product principle will remain the same: autonomy should be earned through visible process and reliable safeguards, not assumed because an agent can write code.

Our long-term goal is to give a solo founder the operational leverage of a small engineering team, without requiring them to become the full-time manager of their own agents.

Built With

Share this project:

Updates