convez.ai
AgenteDesenvolvimento WebAvançado
isaacdll23

Rambl

isaacdll23/rambl

Frota de agentes de código paralelos controlada por PM interativo

Ver no GitHub
InicialPluginScore · de 0 a 100

Orquestra múltiplos agentes Claude Code em paralelo, com um gerente de produto que você controla interativamente. Cada worker executa tarefas autônomas em seus próprios git worktrees, com revisão de diffs e abertura de PRs no GitHub.

Instalação

$npx convez-ai isaacdll23/rambl

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
1
Saúde
28%
Último commit
há 5 meses
Versão
v0.6.2
Issues abertas
0
Contribuidores
1

Casos de uso

  • Executar múltiplas tarefas de codificação em paralelo com supervisão
  • Organizar trabalho em features com múltiplas subtarefas relacionadas
  • Gerar PRs automatizados com revisão antes de push

Veredito

Rambl é uma solução experimental sofisticada para orquestração paralela de agentes de codificação. Requer setup com CLI Claude autenticado, mas oferece isolamento seguro em worktrees e integração nativa com GitHub para fluxos de trabalho de desenvolvimento em equipe.

README

A tradução para o português deste README ainda está na fila.

rambl

Run a fleet of Claude Code agents in parallel on your Claude subscription — driven by a product-manager agent you talk to.

rambl launches one persistent environment: an interactive PM session (a real Claude Code session, so it uses your subscription — not API billing) that plans your work, dispatches autonomous coding workers, monitors them, answers their questions, reviews their diffs, and — when you want — opens GitHub PRs. Each worker runs in its own git worktree; their results land on rambl/<task> branches for you to review. Related tasks can be grouped into a feature that lands as a single PR (see Features). A separate read-only TUI lets you watch them.

Early and experimental. Workers run autonomously with permissions disabled, contained to their git worktree — point it at repos where that's acceptable.

How it works

you ⇄ rambl  (one environment process)
        ├─ SQLite state            (~/.rambl/state.db)
        ├─ MCP server (HTTP)       the PM's tools
        └─ PM = interactive Claude (your subscription), wired to those tools:
              plan → dispatch → monitor → resolve blockers → review → open PR
                └─ workers: autonomous Claude Code sessions, one git worktree each

It deliberately drives the real interactive claude CLI (never claude -p or the Agent SDK), which is what keeps usage on your subscription — see ADR 0001. Workers are isolated in out-of-repo git worktrees (ADR 0002).

Requirements

  • The claude CLI installed and logged in (claude → /login) with a Pro/Max plan
  • git

(Building from source additionally needs Go 1.26+.)

Install

curl -fsSL https://raw.githubusercontent.com/isaacdll23/rambl/main/install.sh | sh

The script detects your platform, downloads the matching prebuilt binary from the latest release, verifies its checksum, and installs to /usr/local/bin. Override the target with BINDIR=… or pin a version with VERSION=v0.1.0. Linux and macOS, amd64/arm64.

Prebuilt binaries are published on every tagged release. Grab the archive for your platform from the releases page, extract it, and put rambl on your PATH:

tar -xzf rambl_<version>_<os>_<arch>.tar.gz   # e.g. rambl_0.1.0_darwin_arm64.tar.gz
sudo mv rambl /usr/local/bin/
rambl version

Go 1.26+; clone first — the module path isn't go-installable:

git clone https://github.com/isaacdll23/rambl && cd rambl
go build -o rambl ./cmd/rambl

Use

rambl                # in a git repo: launches here. Elsewhere: pick a repo from the TUI
rambl pick           # always choose a repo from the TUI, then launch
rambl monitor        # in another pane: watch the workers (read-only)

Worktrees and state both live under ~/.rambl/, so the repo stays pristine — no .gitignore changes needed.

Then review the work:

git log --oneline --all
git diff main..rambl/<task>

The PM reviews and verifies each worker's diff before surfacing it as done, and can open a GitHub PR for you on request. Nothing is pushed until you ask for a PR.

Features

A feature is a named group of related tasks that land together as a single pull request, instead of one PR per task. The PM creates the feature, attaches tasks to it with the right dependencies, then runs it end-to-end: ready tasks dispatch in parallel, each completed task is squash-merged into a rambl/feat/<slug> branch in dependency order, an integration gate keeps that branch building/passing, and once everything is merged and green the feat→main PR is opened automatically. Use a feature when several interdependent tasks should ship as one reviewable unit; use a standalone task for isolated one-offs.

Commands

commandwhat it does
rambllaunch the PM in the current repo, or pick one from a TUI if you're not in a repo
rambl pickchoose a repo from a TUI, then launch the PM environment
rambl pm -repo <path> [-db <p>] [-base <ref>] [-model <m>]explicit environment launch
rambl monitor -repo <path> [-db <p>] [--once]read-only worker dashboard (--once prints a snapshot and exits)
rambl env-once -repo <path> -brief <text> [-base <ref>] [-timeout <dur>]drive the PM through one brief (non-interactive)
rambl doctorpreflight check: claude and git on PATH, ~/.rambl writable
rambl config [list|get|set|path] [<key>] [<val>]view or change settings in ~/.rambl/config.json
rambl versionprint version, commit, and build date

Settings

rambl config reads and writes ~/.rambl/config.json. Current keys:

keydefaultwhat it does
turn-timeout15mper-turn wall-clock cap for a worker's Claude session (also settable via RAMBL_TURN_TIMEOUT)
gate-command(auto-detect)verification gate command run to confirm work is green; empty means auto-detect (go build ./... && go test ./... for a Go module). Also settable via RAMBL_GATE_COMMAND

Per-project verification gate

The integration and per-task gates confirm a worker's (or a feature's) work builds and passes before it is accepted. The gate command is resolved in this order: a per-repo .rambl/gate file (its trimmed contents, if non-empty) wins, then the global gate-command setting, then Go auto-detect. Because the gate is an arbitrary shell command, a non-Go or web project can verify correctly — drop a .rambl/gate containing e.g.

npm run build && npx playwright test

and a browser/Playwright journey runs as a gate step with no change to the orchestration loop. A Go project with no declared gate keeps the default go build ./... && go test ./....

Tailoring the PM

Drop a .rambl/pm.md in your repo; its contents are appended to the PM's system prompt. The PM also honors your repo's CLAUDE.md, settings, and configured MCP servers, since it's an ordinary Claude Code session.

Releasing

Releases are cut by Woodpecker CI: every push runs go vet / go test -race / go build, and pushing a v* tag triggers GoReleaser, which cross-compiles the linux/darwin × amd64/arm64 binaries, archives them with checksums, and publishes a GitHub release. The version, commit, and build date are stamped into the binary via -ldflags and surfaced by rambl version.

git tag v0.1.0
git push origin v0.1.0   # Woodpecker builds and publishes the release

CI needs a github_token secret (a GitHub token with repo scope) configured on the Woodpecker repo.

Notes & limits

  • Workers share one subscription usage pool; keep concurrency modest until rate-limit backoff lands.
  • Containment is the git worktree by convention — workers can still run arbitrary tools. Use accordingly.
  • Your working tree and main are never touched. Branches stay local until you ask the PM to open a PR (or an auto-opened feature PR), which pushes that one rambl/<task> or rambl/feat/<slug> branch to origin.
Ver o original no GitHub

Bom para

Relacionados