<!-- LLM_VERSION_INFO
FORMAT: text/markdown
CONTENT_TYPE: article
ORIGINAL_URL: https://www.buildmoda.ai/bobi/engineering
ALTERNATE_VERSION: bobi/engineering/index.html (text/html)
EXTRACTION_DATE: 2026-08-04T00:46:38.350Z

This is the markdown version with text-only content (images converted to alt-text).
For rich formatting with images, request the HTML version at: bobi/engineering/index.html
-->

# BOBI FOR ENGINEERING

## 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](https://github.com/moda-labs/bobi-agent) [Meet the teams](/content/bobi/engineering#teams/index.html)

## MEET THE TEAMS

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

1. **The Eng team**  
   **Ship more, with confidence.**  
   From issue to reviewed PR without you routing the work.  
   [See the run log](/content/bobi/engineering#eng-team/index.html)

2. **The SRE team**  
   **Incidents root-caused in the moment.**  
   Diagnosis in the channel before the page is acked.  
   [See the run log](/content/bobi/engineering#sre-team/index.html)

3. **The Sprint manager**  
   **A board that never goes stale.**  
   Standup prep, drift flags, and groomed tickets every morning.  
   [See the run log](/content/bobi/engineering#sprint-manager/index.html)

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

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

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

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

4. **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

| Timestamp           | Action                | Details                                                  |
|---------------------|----------------------|----------------------------------------------------------|
| 09:02:14            | signal               | linear webhook: ENG-482 "CSV export drops header row" labeled agent-ok |
| 09:02:16            | triage               | director: matches playbook "issue-to-pr"               |
| 09:02:19            | dispatch             | implementation engineer + test engineer (parallel sessions) |
| 09:24:51            | work                 | implementation: root cause in exporter stream flush, fix in exporter.ts |
| 09:31:08            | work                 | test: regression test added, full suite green             |
| 09:38:02            | work                 | review engineer: diff checked against style + risk playbook|
| 09:41:47            | report               | PR #513 opened with review notes — awaiting your merge ← human gate, by design|

### 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
```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](https://github.com/moda-labs/bobi-agent) [Read the docs](https://github.com/moda-labs/bobi-agent#readme)

## 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

| Timestamp           | Action                | Details                                                  |
|---------------------|----------------------|----------------------------------------------------------|
| 03:14:07            | signal               | pagerduty webhook: P2 — checkout latency > 4s          |
| 03:14:09            | triage               | director: matches incident playbook "latency-p2"       |
| 03:14:11            | dispatch             | diagnosis engineer + comms engineer (parallel sessions)  |
| 03:16:40            | work                 | diagnosis: deploy 4d2f81a correlates with latency spike  |
| 03:17:02            | work                 | comms: incident channel opened, status page drafted      |
| 03:19:23            | report               | #incidents: root-cause summary, rollback proposed — awaiting approval ← human gate, by design|

### 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
```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](https://github.com/moda-labs/bobi-agent) [Read the docs](https://github.com/moda-labs/bobi-agent#readme)

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

### run log · morning-groom

| Timestamp           | Action                | Details                                                  |
|---------------------|----------------------|----------------------------------------------------------|
| 06:30:00            | signal               | cron: weekday 06:30 board sweep                        |
| 06:30:02            | triage               | director: matches playbook "morning-groom"            |
| 06:30:05            | dispatch             | board auditor + standup writer (parallel sessions)      |
| 06:39:41            | work                 | auditor: 3 tickets stale >5 days, ENG-501 drifting from sprint goal |
| 06:43:17            | work                 | auditor: grooming proposals filed as comments on 4 tickets |
| 06:47:29            | report               | #eng-standup: brief posted — board edits held for your sign-off ← human gate, by design|

### 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
```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](https://github.com/moda-labs/bobi-agent) [Read the docs](https://github.com/moda-labs/bobi-agent#readme)

## WHY TEAMS HOLD UP

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

1. **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.

2. **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.

3. **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](https://github.com/moda-labs/bobi-agent)

## 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](https://github.com/moda-labs/bobi-agent) [Read the docs](https://github.com/moda-labs/bobi-agent#readme)