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.

Deploy your first agent team Meet the teams

MEET THE TEAMS

Three teams. Three jobs nobody on your team wants back.

01\ The Eng team\ Ship more,with confidence. \ From issue to reviewed PR without you routing the work.\ See the run log

02\ The SRE team\ Incidents root-causedin the moment. \ Diagnosis in the channel before the page is acked.\ See the run log

03\ The Sprint manager\ A board thatnever goes stale. \ Standup prep, drift flags, and groomed tickets every morning.\ See the run log

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.

Fig. 01 · Signal → Triage → Dispatch → Report Every run
◇

Signal A real event lands — a labeled issue, a page, a cron tick — on one bus.

▤

Triage The director matches it to a named playbook, or leaves it alone.

▢

Dispatch Workers spin up in separate sessions, each with its own role and tools.

✓

Report 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.

run log · issue-to-pr

Meet the team — who did which line

Director

Lead Owns: 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.yaml

team: eng
  director: { 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        # required

Build the Eng team with bobi Read the docs

TEAM 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.

run log · latency-p2

Meet the team — who did which line

Director

Lead Owns: 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.yaml

team: sre
  director: { 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 rollback

Build the SRE team with bobi Read the docs

TEAM 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.

run log · morning-groom

Meet the team — who did which line

Director

Lead Owns: 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.yaml

team: sprint
  director: { triggers: [cron.0630-weekdays, linear.board] }
  workers:
    auditor: { tools: [linear] }
    writer:  { tools: [linear, slack] }
  workflow: morning-groom.yaml
    gate: human_signoff      # before board edits

Build the Sprint manager with bobi Read the docs

WHY TEAMS HOLD UP

The same three mechanisms, under every team on this page.

01

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.

02

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.

03

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 framework for agent teams 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 GitHub

Deploy 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.

View on GitHub Read the docs