How to Build a Slack Agent Concierge for 100+ Engineers
For Platform engineers at mid-size companies · Based on Solmaz On-Demand Disposable Agent Orchestration Framework
// TL;DR
If your engineering org wants agents on Slack but a single shared bot bottlenecks under 100+ users, the Solmaz framework's concierge pattern solves it. A persistent concierge agent receives each request and dispatches an on-demand disposable agent pod on Kubernetes for that specific task, returning a UI link to the session. The concierge stays free for the next request while a goal operator handles pod lifecycle. No manual Slack app manifests, no single-instance bottleneck. Ideal for production error triage, on-demand debugging, and any concurrent agent workload where each engineer needs their own full compute environment rather than competing for one shared instance.
Why does a single shared Slack agent break under load?
One agent instance per platform integration cannot serve 100+ concurrent engineers. This is the single-instance bottleneck anti-pattern: everyone queues behind one shared session, context collides, and throughput collapses. The naive fix — provisioning more Slack apps by clicking through app-creation UIs — is unscalable and a maintenance nightmare. You need an architecture where each request gets its own full compute environment without you hand-managing manifests.
What is the concierge pattern?
Deploy a single concierge agent on Slack that every human talks to. It's the persistent front door. When an engineer asks about, say, new production errors after a release, the concierge doesn't do the work itself — it dispatches an on-demand disposable agent pod on Kubernetes for that specific debug task. It returns a UI link — for example an in-cluster React app hosted per session — and the engineer continues the work there. The concierge immediately returns to available, ready for the next request.
This inverts the bottleneck. Instead of N users sharing one agent, you get N disposable agents, each with a full computer, dispatched by one lightweight front-door agent. A goal operator (like the Spritz pattern, textcortex/spritz) handles all provisioning, wiring to Slack, state, and teardown — so you never touch app manifests by hand.
How do you handle multi-agent provisioning Slack doesn't support?
Slack, Teams, and Discord don't natively support spinning up cosmetically distinct agents per task. That's exactly why the concierge returns a UI link rather than trying to fake multiple bot identities. The disposable agent's session lives in-cluster and is surfaced through a URL. Automate every step of this through the operator from day one — manual app creation clicks do not scale and will become your on-call burden.
How do you keep parallel debug agents from colliding?
When multiple engineers trigger disposable agents that touch shared code or infrastructure, add a state synchronization layer. Grant read/write GitHub access and layer an rsync-style or Dropbox-algorithm sync so file state stays consistent. Without this, parallel pods silently produce conflicting artefacts — one of the hardest failure modes to detect because nothing errors; the outputs just diverge.
What does a real triage flow look like?
An engineer types into Slack: "What broke after this morning's prod release?" The concierge dispatches a fresh disposable pod scoped to that debug task, hands back a UI link, and the engineer investigates in a full agent session with real compute. Meanwhile ten other engineers do the same thing concurrently, each in their own pod, none blocking the others. The concierge never becomes the bottleneck because it never does the heavy work.
Next step: Deploy a goal operator on your cluster, stand up ACPX to bind a Slack channel to your chosen harness via ACP, and wire a minimal concierge that dispatches one disposable pod per request with a returned UI link — then load-test it against a handful of simultaneous triage requests.
// FREQUENTLY ASKED QUESTIONS
Why not just run more copies of one agent bot?
Manually provisioning more Slack apps by clicking through app-creation UIs is unscalable and becomes a maintenance burden. The concierge pattern automates provisioning through a goal operator instead: one persistent front-door agent dispatches on-demand disposable pods per task. You get horizontal scale without hand-managing app manifests, and each engineer gets a full compute environment rather than a shared queue slot.
Why does the concierge return a UI link instead of replying in Slack?
Because Slack, Teams, and Discord don't natively support multi-agent cosmetic provisioning — you can't cleanly surface many distinct agent identities per task. The concierge hosts each disposable agent's session in-cluster, often as a React app, and returns a URL. This sidesteps the platform limitation while giving each engineer a full dedicated session.
What happens to the agent pod after the task?
It's torn down. On-demand disposable agents are ephemeral by design — the goal operator provisions the pod for a specific task and destroys it on completion. This is deliberately wasteful in resource terms but delivers the better abstraction: each task gets a full computer rather than competing for a constrained shared sandbox.