Gitbutler Multiagent

Workflow Patterns

Pattern 1: Parallel Feature Development

# Agent 1
but branch new agent-1-auth
echo "auth code" > auth.ts
but rub auth.ts agent-1-auth
but commit agent-1-auth -m "feat: add authentication"

# Agent 2 (simultaneously, same workspace!)
but branch new agent-2-api
echo "api code" > api.ts
but rub api.ts agent-2-api
but commit agent-2-api -m "feat: add API endpoints"

# Result: Two independent features, zero conflicts

Pattern 2: Sequential Handoff

# Agent A: Initial implementation
but branch new initial-impl
# ... code ...
but commit initial-impl -m "feat: initial implementation"

# Agent B: Takes ownership and refines
but rub <agent-a-commit> refinement-branch
# ... improve code ...
but commit refinement-branch -m "refactor: optimize implementation"

Pattern 3: Cross-Agent Commit Transfer

# Instant ownership transfer
but rub <commit-sha> agent-b-branch  # Agent A → Agent B
but rub <commit-sha> agent-a-branch  # Agent B → Agent A

Pattern 4: Agent Code Review Cycle

Reviewer agent commits fixes separately, then swap/merge:

# Author agent implements
but branch new author-impl
but commit author-impl -m "feat: implement feature"

# Reviewer agent creates sibling branch for fixes
but branch new reviewer-fixes
# ... reviewer makes fixes ...
but commit reviewer-fixes -m "fix: address review feedback"

# Adopt reviewer fixes into author branch
but rub <reviewer-commit> author-impl

# Clean audit trail, final branch has both

Pattern 5: Agent Swarm (Many Agents, One Branch)

Multiple agents contribute to a single feature:

but branch new shared-feature

# Agent A assigns their work
but rub <a-file-id> shared-feature

# Agent B assigns their work
but rub <b-file-id> shared-feature

# Agent C assigns their work
but rub <c-file-id> shared-feature

# Single commit with all contributions
but commit shared-feature -m "feat: collaborative implementation"

Use with Workspace Rules (but mark) for auto-assignment to branches.

Pattern 6: Pre-Created Stack (Multi-Agent)

Orchestrator pre-creates the stack structure, then agents target specific branches:

# Orchestrator: set up stack structure
but branch new db-migration
but branch new api-endpoints --anchor db-migration
but branch new frontend-views --anchor api-endpoints

# Agent A: targets db-migration (use -p, NOT but stage)
but commit db-migration -m "feat: add user tables" -p m6,p9

# Agent B: targets api-endpoints
but commit api-endpoints -m "feat: add REST endpoints" -p q3,r7

# Agent C: targets frontend-views
but commit frontend-views -m "feat: add user views" -p s1,t4

# All agents work in parallel, same workspace, no checkout

Critical: Use but commit <branch> -p <id> to target specific branches in the stack. Do NOT use but stage — staging is per-stack, not per-branch. but stage silently routes to the stack head when targeting empty branches. See gitbutlerapp/gitbutler#12293.

Once each branch has at least one commit, but stage and but absorb work correctly for subsequent changes.

Pattern 7: Exploratory Development

Compare multiple approaches in parallel:

# Parent branch with shared setup
but branch new perf-parent
but commit perf-parent -m "chore: benchmark setup"

# Strategy A
but branch new perf-strategy-a --anchor perf-parent
but commit perf-strategy-a -m "perf: try caching approach"

# Strategy B
but branch new perf-strategy-b --anchor perf-parent
but commit perf-strategy-b -m "perf: try batching approach"

# Run benchmarks on each, keep winner
but rub <winning-commit> perf-parent

Pattern 8: Emergency Hotfix (Feature Work Continues)

Ship a fix without disturbing ongoing multi-agent work:

# Create isolated hotfix branch
but branch new hotfix-urgent
but rub <file-id> hotfix-urgent
but commit hotfix-urgent -m "fix: prod outage"

# Push and create PR
but push hotfix-urgent
but pr new hotfix-urgent

# Other agents continue unaffected in their lanes

Branch Naming Convention

<agent-name>-<task-type>-<brief-description>

Examples:
- claude-feat-user-auth
- droid-fix-api-timeout
- codex-refactor-database-layer

Makes ownership immediately visible in but status --json.

AI Integration Methods

1. Agents Tab (GUI)

• Branch-agent binding in GitButler GUI
• Each virtual branch = independent agent session
• Automatic commit management per session
• Parallel execution with branch isolation
• Access: but gui then navigate to Agents Tab

2. Lifecycle Hooks (CLI)

Example Claude Code hooks config (.claude/hooks.json):

{
  "hooks": {
    "PostToolUse": [{"matcher": "Edit|Write", "hooks": [{"type": "command", "command": "but claude post-tool"}]}],
    "Stop": [{"matcher": "", "hooks": [{"type": "command", "command": "but claude stop"}]}]
  }
}

3. MCP Server

but mcp  # Start MCP server for programmatic access

Exposes gitbutler_update_branches tool for async commit processing.

4. Workspace Rules (Auto-Assignment)

but mark agent-auth-branch
but mark agent-api-branch

New changes auto-route to the marked branch.

Key Instruction for All Agents:

"Never use the git commit command after a task is finished"

For detailed hook configs and MCP schemas, see references/ai-integration.md.

The but rub Power Tool

Single command handles four critical multi-agent operations:

Coordination Protocols

Status Broadcasting:

# File-based coordination
but status --json > /tmp/agent-$(whoami)-status.txt

# Or use Linear/GitHub comments
# "[AGENT-A] Completed auth module, committed to claude-auth-feature"

Concurrent Safety:

1. Snapshot before risky operations
2. Broadcast status regularly to other agents
3. Respect 🔒 locks — files assigned to other branches
4. Use but --json for programmatic state inspection

vs Other Workflows

Decision Framework: When to Use What

Use GitButler when:

• Multiple agents work in same repo simultaneously
• Exploratory development (organize code after writing)
• Frequent reorganization of commits between branches
• Visual organization preferred (GUI + CLI)
• Early conflict detection matters

Use Graphite when:

• Fully automated CLI workflows (scripted end-to-end)
• Terminal-first teams
• Established stacked PR practices
• Need gt up/gt down stack navigation

Use Git Worktrees when:

• Complete branch isolation required
• Different dependencies per branch
• CI/CD needs separate checkouts

Don't mix in same repo - Choose one model per repository.

ALWAYS:

• Use unique branch names per agent: <agent>-<type>-<desc>
• Use but commit <branch> -p <id> when targeting branches in a stack — especially empty ones
• Assign files immediately after creating: but rub <id> <branch>
• Snapshot before coordinated operations
• Broadcast status to other agents when completing work
• Check for 🔒 locked files before modifying

NEVER:

• Use but stage to target empty branches in a stack — staging is per-stack and silently routes to stack head; use -p flag on commit instead
• Use git commit — breaks GitButler state
• Let files sit in "Unassigned Changes" — assign immediately
• Modify files locked to other branches
• Mix git and but commands during active agent sessions

Troubleshooting

Recovery

# Find orphaned commits
git reflog

# Recover agent work
but oplog --json
but undo

# Extract from snapshot
git show <snapshot>:index/path/to/file.txt

Limitations

• Overlapping file edits — adjacent lines can only go to one branch
• No stack navigation CLI — no gt up/gt down equivalent (all branches always applied)
• MCP server limited — only gitbutler_update_branches tool currently exposed

Reference Files

• references/ai-integration.md — Detailed hook configs, MCP schemas, troubleshooting

Related Skills

• gitbutler-guide — Complete GitButler lifecycle guide

External

• GitButler AI Docs — Official AI integration
• Agents Tab Blog — Claude Code integration details