From Issue to Human-Approved Merge in Four Hours

A real agent-swarm.dev session: a feature request went from pull request open to a human merge in 4 h 8 min — 6 commits, 29 files, 30 green checks.

  • Engineering
  • GitHub
  • Delegation
  • Code Review
How-to: From GitHub Issue to Approved Pull Request (swar.am)Watch on YouTube
Aim for your users to directly send PRs to your productWatch on YouTube

Real session, redacted. This ran in our own swarm on 1 October 2026. Names, task identifiers, and internal hosts are removed; the verifiable artifact is the public pull request linked below. All times are Barcelona time.

Request

A maintainer asked the swarm for a memory feature: memories should get logical paths, so a nightly consolidation workflow can write, move, and search a curated /longterm tree instead of a flat pile of entries. The lead made the design call up front — no new memory source; the key itself is the tier — and assigned the implementation to a coding worker on the public desplega-ai/agent-swarm repository. This is the intake shape documented in the feature development playbook: a request becomes a merged pull request through specialized agents that hand context off instead of losing it.

Starting context

The repository is registered with the swarm, so its guidelines were already known: which checks gate a pull request, how reviews work, and who may merge. The GitHub integration was connected, a security-scanning review bot watches the repository, and every worker starts in its own isolated container with the gh CLI available. The change touched the swarm's own memory architecture, so the worker had both the code and the documented design intent in front of it.

Task breakdown

  1. 18:07 — first commit. The worker implemented logical paths: a key to place a memory, newKey to move it, keyPrefix to search a subtree, and path weight so curated entries rank higher.
  2. 18:19 — pull request opened, with the design summarized in the PR body.
  3. 19:55 — bot finding. The security scanner flagged a P2: the HTTP memory index endpoint could derive a curated key from a caller-controlled path and skip the lead-only guard.
  4. 20:17 — triage and fix. The coding worker judged the finding valid, said so on the PR, and routed every key write through one shared permission check so no endpoint can bypass it.
  5. 21:33 — human review. A human maintainer requested changes: the memory skill the swarm ships with had to document the new behavior.
  6. 21:45 — fix pushed. At 21:51 the worker replied to the review thread with what changed.
  7. 22:19 — human approval. 22:27 — human merge.

Worker roles and handoffs

The lead took the design question and routed the work; it wrote no code. One coding worker held the whole session — implementation, bot triage, both fix rounds, and the review replies — so the security context and the review context never left the session that wrote the code. Review came from two directions: the security bot scanning the diff, and a human maintainer whose judgment closed the loop. Every handoff carried the full session history with it.

Approval points

Two gates stayed closed until a human opened them. The bot's review is advisory — the worker must triage it, but triage is not approval. The binding gates were the human's change request, the human's approval, and the human's merge. The swarm never approves or merges its own pull request.

Output

One merged pull request: feat(memory): logical paths under /longterm via key, newKey, keyPrefix and path weight — 6 commits, 29 files changed, +1920/-99, with the shipped memory skill updated to document the new paths.

Measurable result

From pull request open to merge: 4 hours 8 minutes on a Thursday evening, with about 30 checks green — lint and typecheck, split test shards, Docker builds, OpenAPI freshness, CodeQL, the security scan, and the merge gate, the only check the main branch requires. Two review rounds completed: one automated security review whose valid P2 finding was fixed the same evening, and one human review whose change request was answered in twelve minutes.

What stayed human-owned

The design question — whether /longterm deserved to exist at all — the change request, the approval, and the merge. The swarm did the implementation, the security triage, the fixes, and the paperwork; the human kept every decision that could not be undone.

Sources and tools

  • GitHub integration and the gh CLI — branching, committing, opening the pull request, and replying to review. See the GitHub integration docs.
  • Registered repo guidelines — the required checks, the conventional-commit convention, and the rule that a human merges.
  • The security-scanning review bot — automated review on every pull request; its findings arrive as review comments the assigned worker must triage.
  • Memory docs — the memory architecture page describes the system being changed.

More real sessions: the recurring research brief that runs every morning, the security-alert triage that closed thirty-three Dependabot alerts, the two-day orchestration loop that carried one request to four human-merged pull requests, and the fully public x402 payment session. Browse everything on the examples index.