A monorepo of internal Slack agents that share one runtime and a cross-agent routing protocol. Each bot answers questions in its own domain, hands off to the right peer when a question isn't its own, and learns from in-thread corrections — the way a colleague would refer you down the hall, then remember what you told them.
A teammate @-mentions product-agent in #ask-eng with a question about the codebase.
When the device drops connectivity, each mutation is written to a local queue and flushed to the sync API in order once it's back online. Field-level conflicts resolve last-write-wins, and the queue is persisted to the browser's localStorage so a refresh doesn't lose pending edits.
product-agent reads the product's actual source code to answer — it clones the repos and greps them live, then cites the exact files. Every reply carries a confidence level and its sources.
Another codebase question — but watch what happens before the answer ever reaches the channel.
Completed inspections are submitted via POST /v1/inspections/submit.
POST /v2/inspections (api/routes/inspections.ts:42). The /v1 route was removed in the March migration. Re-answering.Every draft is re-checked by an independent reviewer agent — a fresh context, no memory of how the answer was written — against the actual code. Here it catches a stale endpoint the first pass got wrong and fails the draft.
POST /v2/inspections.
The client batches the inspection payload and retries with backoff on 5xx. The old /v1/inspections/submit route was retired.
Only the verified answer reaches the channel. If the reviewer can't confirm a draft after a retry, product-agent says it couldn't figure it out — rather than posting something wrong. Hallucinated answers don't make it to the team.
A vendor security questionnaire lands in the channel — 25 questions in an Excel file — @-mentioned to product-agent.
Wrong bot — product-agent knows the codebase, not compliance. Instead of guessing, it hands the whole file to infosec-agent. A cheap classifier decides who owns the request and passes the baton — no human dispatcher, and it's hop-capped so it can't loop.
Working through Globex_Security_Review.xlsx — answering each row from the security knowledge base.
| A · Question | B · Response | |
|---|---|---|
| 1 | Is data encrypted at rest? | Yes — AES-256 (SOC 2 CC6.1) |
| 2 | Is MFA enforced for all staff? | Yes — enforced org-wide via Okta |
| 3 | Do you hold a SOC 2 Type II report? | Yes — current through this quarter |
| 4 | Data residency for EU customers? | eu-west-1; no data leaves region |
| 5 | Describe your incident-response SLA… | ⚑ needs human review |
infosec-agent reads the spreadsheet and fills each answer from its knowledge base — the same Drive/Sheets KB it answers chat questions from. It isn't just Q&A: it completes real .xlsx / .csv / .docx questionnaires, cell by cell.
2 questions had no confident source, so I left them blank and flagged them for a human rather than guessing.
It returns the completed file and — crucially — flags what it couldn't source instead of inventing answers. Every cell runs the same draft → review → redraft loop; anything that can't be verified is left for a person. Two specialists, one conversation, no human triaging tickets.
A teammate replies in-thread to correct the earlier answer — just normal Slack, no special command.
Thanks for the correction. I've saved it as a lesson anchored to the file I cited, so it'll steer future answers.
mobile/src/sync/offline.ts · hashedThe reviewer catches answers that contradict the code; a subtler detail like this slipped past it — so a human corrected it, and product-agent distills the reply into a durable lesson anchored (and hashed) to the exact file. Corrections are leads, not gospel: the code stays the source of truth.
3 days later, a different teammate asks essentially the same question — with no idea a correction was ever made.
Each mutation is persisted to an IndexedDB store on the device, then flushed to the sync API in order once it's back online.
Storage: localStorage → IndexedDB
mobile/src/sync/offline.ts — unchanged since the lesson was saved, so the correction still holdsSame question — but product-agent answers correctly now, because it applied the saved correction. Before trusting the lesson it re-hashes the anchored file: if the code had changed, the lesson would be flagged stale and the reviewer would re-check from scratch. That's the loop closing: answer → verify → route → correct → recall.