Rambl
isaacdll23/rambl
Frota de agentes de código paralelos controlada por PM interativo
Ver no GitHubOrquestra 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/rambl1 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
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
claudeCLI 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
| command | what it does |
|---|---|
rambl | launch the PM in the current repo, or pick one from a TUI if you're not in a repo |
rambl pick | choose 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 doctor | preflight 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 version | print version, commit, and build date |
Settings
rambl config reads and writes ~/.rambl/config.json. Current keys:
| key | default | what it does |
|---|---|---|
turn-timeout | 15m | per-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
mainare never touched. Branches stay local until you ask the PM to open a PR (or an auto-opened feature PR), which pushes that onerambl/<task>orrambl/feat/<slug>branch toorigin.