Engineering capacity you didn’t have to hire.
Meet your engineering agent teams: an eng team, an SRE team, and a sprint manager — on your events, running your playbooks, reporting back with receipts.
For engineering leads with more roadmap than headcount.
MEET THE TEAMS
Three teams. Three jobs nobody on your team wants back.
THE LOOP
How a bobi team works. Every team, every run.
Four beats, always in this order. The run logs below show the same loop on real events — this is the only time the page explains the mechanism.
A real event lands — a labeled issue, a page, a cron tick — on one bus.
The director matches it to a named playbook, or leaves it alone.
Workers spin up in separate sessions, each with its own role and tools.
A named artifact lands where you work — with a human gate where it matters.
TEAM 01 · ENG TEAM
Ship more, with confidence.
The eng team: from issue to reviewed PR without you routing the work.
The moment
9:02am: a bug labeled agent-ok lands in Linear. 9:41am: a PR with the fix, a regression test, and review notes is sitting in GitHub — waiting on your merge, not your morning. Nobody triaged it, assigned it, or wrote the ticket back.
What a run of issue-to-pr produces: timestamps, roles, artifacts, and the gate.
Meet the team — who did which line
Director
LeadOwns: Reads every incoming issue and decides if a playbook applies.
watches Linear + GitHub issues
runs issue-to-pr
Implementation engineer
Owns: Traces the root cause and writes the fix.
watches dispatch from the director
runs implement
Test engineer
Owns: Adds the regression test and keeps the suite green.
watches dispatch, in parallel
runs test-and-verify
Review engineer
Owns: Reviews the diff against the checklist before it reaches you.
watches PRs opened by the team
runs review-checklist
“Won't it merge junk into main?”
It can't merge at all. The playbook ends at an open PR with review notes attached; merging is a human gate in the workflow, not a suggestion in a prompt.
“How does it know which issues to pick up?”
Only issues you label agent-ok trigger the playbook. Everything else stays yours. The trigger is a node in the workflow file — you can read it, diff it, and change it.
eng-team.yamlTemplate
team: engdirector: { triggers: [linear.issue, github.issue] }workers: implementation: { tools: [repo, ci] } test: { tools: [repo, ci] } review: { tools: [repo] }workflow: issue-to-pr.yaml gate: human_merge # requiredTEAM 02 · SRE TEAM
Incidents root-caused in the moment.
The SRE team: on call so nobody else is.
The moment
3:14am: a P2 fires. 3:19am: the diagnosis, the suspect commit, and a proposed rollback are sitting in #incidents. Nobody’s laptop opened. The engineer who acks the page starts from a five-minute head start instead of a blank terminal.
The five minutes between the page and the head start, line by line.
Meet the team — who did which line
Director
LeadOwns: Matches every page to an incident playbook — or wakes a human when none fits.
watches PagerDuty + Datadog alerts
runs latency-p2, error-spike
Diagnosis engineer
Owns: Correlates the alert with deploys, metrics, and logs to name a suspect.
watches dispatch on page
runs diagnose
Comms engineer
Owns: Opens the channel, drafts the status page, keeps the timeline.
watches dispatch, in parallel
runs incident-comms
Postmortem writer
Owns: Turns the timeline into a draft postmortem by morning.
watches incident resolved
runs postmortem-draft
“Won't it hallucinate a rollback?”
It can't. Rollbacks run a fixed playbook with a human approval gate; the model works inside the recipe, not around it. What lands in the channel is a proposal with evidence, never an action.
“Three agents on one outage sounds like chaos.”
Each worker runs in its own session with a structured handoff. Diagnosis and comms never share a context window — they share a timeline the director owns.
sre-team.yamlTemplate
team: sredirector: { triggers: [pagerduty.incident, datadog.alert] }workers: diagnosis: { tools: [metrics, logs, repo] } comms: { tools: [slack, statuspage] } postmortem: { tools: [slack, docs] }workflow: latency-p2.yaml gate: human_approval # before any rollbackTEAM 03 · SPRINT MANAGER
A board that never goes stale.
The sprint manager: standup prep, drift flags, and groomed tickets every morning.
The moment
6:30am: the nightly sweep starts. By 6:47am there’s a standup brief in #eng-standup: three tickets flagged stale, one sprint-goal drift called out with the diff, and grooming proposals filed as comments — not silent edits. Standup starts with answers instead of archaeology.
The quiet kind of run: mostly reads, one brief, and edits held at the gate.
Meet the team — who did which line
Director
LeadOwns: Runs the sweep on schedule and on board events worth reacting to.
watches cron + Linear board events
runs morning-groom
Board auditor
Owns: Finds stale tickets, sprint-goal drift, and missing estimates.
watches dispatch on sweep
runs audit-board
Standup writer
Owns: Turns the audit into the morning brief your team actually reads.
watches audit complete
runs standup-brief
“Will it re-order my roadmap overnight?”
No. The playbook is read-heavy and write-light: it flags, comments, and proposes. Board edits sit behind a sign-off gate, so the only thing that lands unprompted is the brief.
“Isn't this just another bot posting noise?”
One brief, once a morning, and only flags that carry a diff — the playbook bans restating the board. If the sweep finds nothing, it posts nothing.
sprint-manager.yamlTemplate
team: sprintdirector: { triggers: [cron.0630-weekdays, linear.board] }workers: auditor: { tools: [linear] } writer: { tools: [linear, slack] }workflow: morning-groom.yaml gate: human_signoff # before board editsWHY TEAMS HOLD UP
The same three mechanisms, under every team on this page.
Playbooks agents can't wander off
Deterministic workflows: the model works inside a fixed recipe. Rollbacks, merges, and board edits are nodes it has to pass, not vibes it might follow.
Separate sessions per worker
Diagnosis and comms, implementation and review — parallel work in isolated sessions with structured handoffs. No crossed wires, no shared context window.
The sleep cycle
Every session is distilled into team policy overnight. The conventions you correct today are the conventions the team ships with tomorrow.
Every team on this page runs on bobi, the open-source harness you can deploy today. The run logs above show what a run produces — timestamps, roles, artifacts, and the human gate. As team templates and real deployments ship, their numbers land here. Not before.
Explore bobi on GitHubDeploy your first agent team.
Pick a team above, point bobi at your events, and keep every gate. It runs on your infrastructure, end to end.
Open source · MIT · self-hosted · built on the Claude Agent SDK