A deadline board that caught this hackathon's wrong deadline, and a producer agent that tells the truth about a dormant pipeline.

I run 64 ventures with a fleet of AI agents and exactly one human: me. The portfolio's state lives in a deadline register with 123 tracked commitments, a watch layer that monitors our machines, and a GitHub repo that acts as the fleet's brain. The information was never the problem. Where it lived was. Every status check meant leaving the conversation and opening another tool.

For Flip the Switch, we moved the work into the rooms where it's discussed: two channels on our self-hosted Switch deployment, each with an agent of its own.

Room one: the Portfolio Ops Room

Ask @ops-agent for deadlines, gates, money, health, brief, status, or prs, and it answers in a second or two — from the real board:

  • deadlines — 97 active items, what's overdue, what's due in 24 hours, the next five. That evening: four overdue items, including a $17.17 bill, a grant window that crossed its 18:59 deadline — and, for a while, this hackathon itself. Our register first recorded Flip the Switch's deadline as 13:29; the live form was still open hours later, and the board now carries the verified close.
  • gates — the ten actions only I can take (payments, submissions, ID checks), most urgent first, each with its estimated minutes.
  • money — $1,512.65 of overdue money sat on the board that evening.
  • health — the watch layer, per monitor. It reported one monitor DOWN. The agent doesn't do reassurance; it reads the watcher file and says what's there.

The room doesn't wait to be asked: a digest lands twice a day on a timer, and at 21:45 it fired unattended, with nobody in the room.

Room two: the Creator Room

The second room came later the same evening, for the other half of my work life: a media pipeline — a faceless animated-shorts lane (MiniMax H3) plus a clipping lane. Its agent, @producer, answers eleven questions — ideas, script, renders, clips, next, help, status, credits, review, sources, health — from a labelled snapshot of the pipeline files: which shorts are queued, whether any episode script exists (template ready; episode 1 not written), and which test clips exist on disk, measured rather than remembered.

Tonight the Producer also learned to publish. It maintains two room documents — the pipeline snapshot, and the pipeline state with its review gate. When the snapshot refreshes, you can re-ask and watch the documents and the answers move together; we proved that end-to-end before writing this sentence. And if a snapshot can't be read, it degrades honestly — last-good copy, labelled, or an explicit "unavailable" — never an invented number.

Neither agent is an LLM. Both are deterministic services: every number traces to a labelled snapshot, and every answer prints that snapshot's timestamp, because a snapshot should never pretend to be a live query.

How Switch carries it

There is no bot bolted onto the side of Switch. Each agent is registered through Switch's agent API, holding its own Switch-issued key and an owner-only addressing policy — zero tools, zero models, read-only by construction. A human posts in Mattermost; the bridge carries it into the room; the agent receives it on its Switch event stream, answers through the Switch message API, and the bridge publishes the answer under the agent's bot account. Switch's identity guard is visibly on duty: because our demo chat account isn't linked to a Switch user, it posts its "I only take instructions from my owner…" notice ahead of the answers — correct behaviour, since an unlinked account shouldn't be able to instruct someone else's agent.

Two plumbing facts. The rooms weren't created the same way: the ops channel was auto-bridged when we registered the bridge; the Creator Room's channel was gateway-provisioned on the same deployment. And a genuine discovery: the agent API has no document endpoints — room documents live on the gateway API. We found that by reading the live API surface, not the docs.

Take Switch away and both agents are formatters with nobody to talk to. That was the test we set ourselves, because "is Switch central?" is the first judging criterion — and it's the right question to ask of any entry, including ours.

The honest limits

A section most hackathon posts skip. This pipeline's state is the reason the second room exists, so here it is plainly:

  • The media pipeline is dormant. The clipping pipeline was built on October 16 and hasn't run since. Nothing it made has ever been posted. It has earned $0.
  • Generation is blocked. Exactly two H3 test renders exist; both passed review on October 29. The free generation credits stand at 2 of 150, and the cheapest clip costs 28 — so no new clip can be made until I decide the production route (the Producer's estimate: API-first, roughly $2.60–3.90 per kept clip) — a wait the room can report but not end.
  • The Producer's snapshot refresh is manual — a one-command script. The ops snapshot refreshes every five minutes by cron; the Producer's refresh timer ships in the repo, not yet installed.
  • The room documents are owner-visible. The gateway refused room-scoped visibility, so the documents are attached to the room and visible to the console owner — not yet verified visible to room members.
  • The Watch Agent hasn't posted a real transition. Its flip logic is dry-run verified; no monitor flipped that evening, and we won't pretend otherwise.

What we learned

  1. The API teaches you the setup. Our bridge registration failed: Switch's outbound SSRF guard refuses the literal 127.0.0.1 — and the error names the allowlist setting that fixes it. localhost worked immediately. Every blocker we hit was like this: the error message was the documentation.
  2. Bang commands are Switch's, not yours. !help is answered by Switch itself. Build your agent's interface on mentions and plain words.
  3. Claims are code too. Our own README carried one sentence that overstated the machinery — it said both rooms' snapshots refreshed every five minutes. One did; the Producer's didn't. We corrected it the same night, and every claim in this post was checked against the repo and the live evidence before it shipped.
  4. The trust layer is real — and chatty. The guard is right; firing before every answer is noise a room should be able to tune to once per account. Our one improvement request.

What's next

The rooms stay live: the digest keeps landing twice a day, and the register keeps running the portfolio — it exists because we lost a hackathon entry earlier this year to a decision that sat unmade while a deadline passed. The Creator Room stays live too. Next: make the production-route decision, install the refresh timer, and write episode 1.

The code is MIT-licensed. The repo carries reproduction steps, an architecture document, and a licence-checked survey of fourteen comparable projects — plus an offline quickstart that prints the Ops Agent's seven answers, no Switch stack required. Clone it, point it at your register, and your room gets a staff agent too.

— Mission Winning (team T3RBB9)