RepoBird.ai: One-Shot Cloud Coding Agents

Most AI coding tools want a conversation. You prompt, they answer, you correct, they retry — and nothing ships until you've babysat every step.

RepoBird works differently. It's a cloud coding agent built for one-shot execution: you describe a task once (usually as an issue), an agent picks it up in an isolated cloud sandbox, and you get back a pull request. It works with both GitHub and GitLab. No chat loop, no local setup, nothing running on your machine.

"Cloud" is doing real work in that sentence. Running agents in the cloud instead of on your machine buys you:

• Full isolation — each run gets its own sandboxed VM with a dedicated filesystem. Agents can't touch your local files, SSH keys, or credentials, and an agent that goes sideways can't hurt anything but its own disposable sandbox.
• Zero permission fatigue — no "allow agent to run this command?" prompts all day. The sandbox is the permission boundary.
• Real parallelism — every task runs in its own environment, so submitting ten issues means ten agents working at once. Your laptop couldn't do that; the cloud doesn't care.
• Run from anywhere — close the lid. Runs live in the cloud, not in a terminal session, so you can fire one off from your phone on the dashboard, check status from the train, and review the PR when you're back. No machine to babysit.

How it works

The flow is short:

1. Connect your repos. On GitHub, install the RepoBird GitHub App. On GitLab, invite the @repobirdbot user to your project (or group) and connect the project URL from the RepoBird dashboard — no access tokens to manage.
2. Describe the task — a GitHub issue with clear instructions, file paths, or code snippets works best.
3. Trigger a run from the dashboard, via the CLI, or with a GitHub comment.
4. Review the PR. The agent researches the codebase, implements the change, runs what it can, commits, and opens a pull request against your target branch.

That's the whole loop. If the PR needs adjustments, comment on it with new instructions and the agent pushes follow-up commits to the same branch.

Quickstart 1: From the dashboard

The simplest path, and it works the same for GitHub and GitLab. Sign in at repobird.ai and open the Run page:

1. Pick a connected repository and base branch
2. Describe the task — same rules as a good issue: what to change, where, and how you'll know it's done
3. Launch, and watch the run's live status until the PR lands

No terminal, no setup beyond connecting the repo.

Quickstart 2: From the CLI

For terminal workflows and bulk runs, there's the RepoBird CLI.

Grab an API key from Dashboard → User Profile → API Keys at repobird.ai, then:

export REPOBIRD_API_KEY="rb_live_xxxxxxxxxxxxx"
repobird auth verify

Fire off a task with a plain prompt:

repobird run -r your-org/your-repo -p "Fix the login bug where users get stuck on the loading screen"

Or define tasks as files — JSON, YAML, or Markdown with frontmatter all work:

repobird run task.json --follow   # --follow streams live status
repobird run task.yaml
cat task.json | repobird run -    # from stdin, easy to script

Check on everything from the terminal:

repobird status                   # list all runs
repobird status --follow RUN_ID   # live updates for one run

The file-based input is what makes bulk work practical: generate a batch of task files from your backlog, loop over them, and come back to a stack of PRs.

The power-user setup: install the CLI plus the RepoBird skill for your coding agent. With the skill loaded, your local agent — Claude Code, or whatever you drive day to day — can dispatch RepoBird cloud runs itself: you stay in one conversation, and well-scoped tasks get offloaded to cloud agents that come back as PRs while your local agent keeps working.

Quickstart 3: From a GitHub comment

On any issue in a repo where the app is installed, comment:

@repobird run

The agent reads the issue, implements it, and opens a PR. You can add instructions and options inline:

@repobird run base:main pr-target:develop Fix the login redirect loop on expired sessions

• base:<branch> — which branch the agent starts from
• pr-target:<branch> — where the PR points
• Free-text instructions after the options are passed straight to the agent

It also works on existing pull requests. Comment @repobird run Refactor this to use the shared client on a PR and the agent pushes updates directly to that PR's branch.

Smart Git handling

A detail that matters more than it sounds: the agent never runs Git. It only writes code. When the run finishes, RepoBird's post-processing step takes over — it reviews the workspace, builds the commit from an approved staged diff, pushes to a generated output branch, and opens the PR.

Why this is better than letting an LLM drive git:

• Deterministic Git operations — commits, pushes, and PRs come from platform code, not model output, so they work the same every run
• Clean, reviewable diffs — only the approved staged changes ship; agent scratch files never leak into your PR
• Guardrails by construction — direct writes to your base branch are rejected; every run lands on its own output branch

You still control the flow: pr-target: sets where the PR points, and branch-only mode (outputMode:branch + output-policy:reuse) pushes a branch without a PR so follow-up runs can keep building on it.

Core features

• One-shot execution — describe the task once, get a PR. No iterative chat sessions.
• Parallel cloud runs — each task gets its own isolated sandbox, so many agents can work simultaneously without file conflicts or worktree juggling.
• Smart Git handling — the agent writes code, RepoBird's post-processing handles commit, push, and PR/MR creation deterministically from an approved staged diff.
• PR follow-ups — comment on a RepoBird PR with instructions and the agent updates the branch.
• GitHub and GitLab — install the GitHub App, or add @repobirdbot to your GitLab project and connect it from the dashboard.
• Three triggers — the web dashboard, the CLI, and GitHub comments (@repobird run). GitLab runs launch from the dashboard or CLI.
• Agent-to-agent dispatch — pair the CLI with the RepoBird skill so local coding agents like Claude Code can launch cloud runs on your behalf.
• Flexible task input — plain prompts, JSON, YAML, Markdown frontmatter, or stdin.
• Live monitoring — repobird status --follow in the terminal, plus run history in the dashboard.
• OpenCode-powered runtime — repository-aware code generation with flexible model routing and BYOK support for individual Pro usage.
• Full development sandbox — agents get real environments with common language runtimes, package managers, build tooling, and internet access for docs and dependencies.
• Security by isolation — agents never touch your machine; no local credentials, SSH keys, or files are exposed.
• Credit-based execution and teams — control spend, share repository access, and manage members on team plans.
• Zero infrastructure — nothing to host, configure, or clean up. Install the app and go.

Where it fits

RepoBird is not trying to replace your editor's AI assistant. Local tools are great for exploratory work and tight visual iteration. RepoBird is for the other pile: everything you can describe clearly in an issue.

What teams hand off:

• Bug backlogs — submit the whole pile; agents triage, fix, and test in parallel while your team stays on feature work
• Large-scale refactors — split a big refactor into focused tasks and run them simultaneously instead of grinding through sequentially
• Dependency updates — bump every service in isolation, each with its own PR and test run
• Boilerplate and scaffolding — CRUD endpoints, new components, config plumbing
• Documentation — generate and update docs across projects without burning engineer hours
• Tech-debt sprints — clear the "someday" column while nobody's machine slows down

For power users, the ceiling is parallelism. Anyone who has tried running multiple agents locally knows the failure mode: git worktrees each needing their own dependency install, agents overwriting each other's files, a machine brought to its knees by three model contexts. RepoBird sidesteps all of it — every task gets an isolated cloud sandbox, so submitting 20 tasks is no harder than submitting one. Script it through the CLI, or let your local coding agent dispatch runs via the RepoBird skill.

For teams, it's capacity you don't have to hire, provision, or manage. No infrastructure, no orchestration layer, no agent-ops burden — the backlog moves while your engineers spend their time on the problems that actually need them. Credit-based execution keeps spend visible and controllable.

The habit shift is small but real: instead of context-switching into every small task, write a good issue, hand it off, and review the PR when it lands.

Try it

There's a free tier, so the experiment costs nothing:

1. Install the GitHub App (github.com/apps/repobird) — or on GitLab, invite @repobirdbot to your project and connect it at repobird.ai
2. Pick an open issue with a clear description
3. Launch a run from the dashboard — or just comment @repobird run on the issue
4. Review the PR

Docs and full command reference: repobird.ai/docs