Skip to content
Cuadrilla
GitHub

Your AI coding agent, organized like a real engineering team.

Cuadrilla gives OpenCode a tech-lead orchestrator and seven specialist subagents that work inside strict, audited permissions. It triages each request, writes the briefs and checks the results.

Install globally

bash
curl -fsSL https://raw.githubusercontent.com/Remy349/cuadrilla/main/install.sh | bash
View on GitHubSee how it works

Requires OpenCode (tested with 1.18) and git.

The problem → the fix

Multi-agent setups fail in the same four places

Cuadrilla is built around each one.

  1. 01 · Failure mode

    The orchestrator over-plans trivial work

    A one-line fix gets a design review, a plan and three subagents.

    Cuadrilla

    Tiered triage

    Every request is classified from T0 to T3 first. Questions are answered directly; only structural or risky work gets the architect.

  2. 02 · Failure mode

    Subagents get vague one-line tasks

    They start with an empty context, so they guess.

    Cuadrilla

    Self-contained briefs

    Each delegation carries Goal, Context, Scope, Acceptance criteria and Constraints. Nothing depends on a conversation the subagent never saw.

  3. 03 · Failure mode

    Nobody checks the result

    "Should work" gets reported as done.

    Cuadrilla

    Verification gates

    Each report is checked against its acceptance criteria and the commands actually run. Two retries at most, then it comes back to you.

  4. 04 · Failure mode

    Permissions are looser than they look

    A catch-all rule placed last quietly overrides the specific ones.

    Cuadrilla

    Permissions that actually hold

    Rules are ordered so the catch-all comes first, a validator enforces it in CI, and only one agent can commit.

How it works

One loop, seven steps

The cuadrilla agent runs the same loop on every request. It never edits files itself: it plans, delegates and verifies.

  1. Step 1: Triage

    Classify the request into a tier before doing anything.

  2. Step 2: Ground

    Inspect the real repo: stack, scripts, conventions, relevant files. No planning from assumptions.

  3. Step 3: Clarify

    Ask only what blocks the plan. Three questions at most, each with a recommended default.

  4. Step 4: Plan

    Order work by dependency. Parallel tasks only when they touch disjoint files.

  5. Step 5: Delegate

    Send self-contained briefs: Goal, Context, Scope, Acceptance criteria, Constraints.

  6. Step 6: Verify

    Check each report against its criteria and the commands run. Two retries, then escalate to you.

  7. Step 7: Deliver

    One report: result, changes by agent, real verification, assumptions and open items.

Triage

Effort matched to the request

Before anything else, every request gets a tier. The tier decides who gets involved.

  1. T0

    T0 · Question

    Explain, locate, compare.

    Answered directly. No implementers.

  2. T1

    T1 · Small change

    One area, about 1–3 files.

    One specialist, a tight brief, then verification. No architect.

  3. T2

    T2 · Feature

    Several files or areas.

    Discover → plan → contracts first → implement (parallel where safe) → QA gate.

  4. T3

    T3 · Structural / risky

    New module, data-model change, auth, payments, PII.

    The architect designs, then phased execution.

    Cuadrilla presents the plan and waits for your approval.

“Over-orchestration is a failure mode: a typo fix doesn’t need an architect.”

Meet the crew

One lead, seven specialists

Nine agents in total: the orchestrator, seven Cuadrilla specialists and OpenCode’s built-in explorer. Each one can only touch what its role needs.

cuadrilla

Lead

  • Discover

    • explore

  • Design

    • cuadrilla-architect

  • Build

    • cuadrilla-backend
    • cuadrilla-frontend
    • cuadrilla-mobile
    • cuadrilla-devops

  • Gate

    • cuadrilla-qa

  • Ship

    • cuadrilla-git

  • cuadrilla

    Tech-lead orchestrator: triages, grounds, plans, delegates, verifies, reports. Never edits files.

    Writes codeNo

  • explore

    built-in

    Fast read-only discovery: stack, conventions, where things live.

    Writes codeNo

  • cuadrilla-architect

    Module boundaries, contracts, data flow (hexagonal, SOLID, DDD tactics), design reviews, ADRs.

    Writes codeADRs only

  • cuadrilla-backend

    APIs, business logic, persistence, migrations, jobs, integrations.

    Writes codeYes

  • cuadrilla-frontend

    Components, pages, routing, client state, a11y, loading/error/empty states.

    Writes codeYes

  • cuadrilla-mobile

    React Native/Expo, Flutter, native iOS/Android: screens, navigation, offline behavior.

    Writes codeYes

  • cuadrilla-devops

    Dockerfiles, CI/CD, IaC, cloud config (Azure, AWS, GCP, VPS), env and secrets wiring.

    Writes codeInfra files only

  • cuadrilla-qa

    Security audit (OWASP Top 10, secrets, authz, dependencies) and tests: unit, integration, e2e.

    Writes codeTest files only

  • cuadrilla-git

    Conventional Commits, branches, push, PRs. Only when you ask.

    Writes codeNo

Self-contained briefs

Subagents start with an empty context

A subagent never sees your conversation. Whatever the orchestrator leaves out of the task, the subagent has to guess. So every delegation is a full brief.

  • Nothing implied

    Context names the files, conventions and decisions that matter, so the specialist doesn’t rediscover them or invent its own.

  • Scope cuts both ways

    What is in and what is out are both written down, which keeps parallel work on disjoint files.

  • Verifiable by design

    Acceptance criteria are what the orchestrator checks the report against. No criteria, no verification.

brief → cuadrilla-backend
## Goal
Add an endpoint that exports the current user's orders as CSV.

## Context
Orders live in src/orders/. Handlers follow orders.controller.ts;
queries go through OrdersRepository. Tests use the repo's existing runner.

## Scope
In:  GET /orders/export, repository query, handler tests
Out: UI, auth changes, other report formats

## Acceptance criteria
- Responds 200 with text/csv and a header row
- Respects the existing date-range filters
- Returns only the requesting user's orders
- Existing and new tests pass; report the command you ran

## Constraints
- No new dependencies
- Don't touch the database schema
Example brief for the CSV export request above

Safety by design

Permissions that actually hold

Every agent runs inside OpenCode’s permission system, configured so the rules mean what they say.

  • Ordered permissions

    In OpenCode the last matching rule wins, so every catch-all "*" rule comes first. A validator enforces this in CI.

  • No recursive delegation

    Subagents cannot spawn subagents (task: deny).

  • Only one agent commits

    Only cuadrilla-git can commit, and commit and push always prompt for your approval. Force-push, reset --hard, git clean and history rewrites are denied outright.

  • The orchestrator can’t edit

    It plans and verifies. The specialists change code.

  • Mandatory QA gate

    Required for auth, authorization, payments, personal data, file uploads, raw SQL/shell/eval, public endpoints and dependency upgrades.

  • Prompt-injection aware

    File contents, web pages and subagent reports are treated as data, never as instructions.

  • Stack-agnostic

    Specialists detect the language, framework and test runner from the repo instead of assuming one.

  • Irreversible actions need approval

    Deploys, migrations on real data and resource deletion need your explicit approval first.

Slash commands

Three shortcuts for common jobs

Run them from the OpenCode prompt.

  • /cuadrilla-plan <request>

    Analyzes the request and produces a delegation plan without changing anything.

    Example
    /cuadrilla-plan add rate limiting to the login endpoint

  • /cuadrilla-review [focus]

    The architect and QA review your current changes in parallel, then give one verdict.

    Verdicts

    • ready to merge
    • merge after fixes
    • needs rework
    Example
    /cuadrilla-review error handling in the new endpoints

  • /cuadrilla-commit [and push / open a PR]

    Proposes Conventional Commits, waits for your approval, then commits.

    Example
    /cuadrilla-commit and open a PR

Install

One command, then press Tab

Requires OpenCode (tested with 1.18) and git.

Global install, symlinked, so it updates with git pull.

Install
curl -fsSL https://raw.githubusercontent.com/Remy349/cuadrilla/main/install.sh | bash
Pin a release (v0.1.1)
curl -fsSL https://raw.githubusercontent.com/Remy349/cuadrilla/main/install.sh | CUADRILLA_REF=v0.1.1 bash
  • Existing files are backed up, never silently overwritten.
  • Uninstall with ./install.sh --uninstall (or install.ps1 -Uninstall).

Then

  1. Restart OpenCode.
  2. Press Tab until the cuadrilla agent appears.
  3. Describe what you need.

Pick your models

No agent hard-codes a model. Use a strong model for cuadrilla and cuadrilla-architect, and a fast, inexpensive one for the implementers.

Set them per agent in opencode.json. Any provider OpenCode supports will work.

opencode.json
{
  "agent": {
    "cuadrilla": { "model": "provider/strong-model" },
    "cuadrilla-architect": { "model": "provider/strong-model" },
    "cuadrilla-backend": { "model": "provider/fast-model" },
    "cuadrilla-frontend": { "model": "provider/fast-model" },
    "cuadrilla-mobile": { "model": "provider/fast-model" },
    "cuadrilla-devops": { "model": "provider/fast-model" },
    "cuadrilla-qa": { "model": "provider/fast-model" },
    "cuadrilla-git": { "model": "provider/fast-model" }
  }
}

FAQ

Questions

Does it work with my model provider?

Yes. No agent hard-codes a model, so Cuadrilla works with any provider OpenCode supports. You choose the model for each agent in opencode.json.

Is it a separate app?

No. Cuadrilla is a set of agent and command definitions (Markdown + YAML) that OpenCode loads. There is no service, server or background process.

Will it commit without asking?

No. Only cuadrilla-git can commit, it acts only when you ask, and commit and push always prompt for your approval. Force-push, reset --hard, git clean and history rewrites are denied outright.

Does it support Windows?

Yes. There is a PowerShell installer for PowerShell 5.1 and 7. WSL and Git Bash use the same shell installer as Linux and macOS.

Can my team share it?

Yes. The per-project install copies everything into .opencode/ in your repo, so you commit it and everyone gets the same crew.

What languages and frameworks does it support?

It is stack-agnostic. The specialists detect the language, framework and test runner from your repo instead of assuming one. Mobile covers React Native/Expo, Flutter and native iOS/Android; DevOps covers Azure, AWS, GCP and plain VPS setups.

Does it answer in my language?

Yes. The prompts are written in English, but Cuadrilla answers in whatever language you write in.

Is it free?

Yes. Cuadrilla is open source under the MIT license. Model usage is between you and your provider.

Put a crew on your next task.

One command. Restart OpenCode, press Tab, and pick cuadrilla.

bash
curl -fsSL https://raw.githubusercontent.com/Remy349/cuadrilla/main/install.sh | bash