After months of experimentation, I realized one generalist AI isn't enough.
So I built Cipher — a crew of 7 specialized agents, each with their own personality, expertise, and communication style.
The Cipher Agent Crew:
- Forge— Battle-tested coder. Obsessed with clean architecture and performance.
- SAGE— Testing & QA specialist. Lives for edge cases and reliability.
- Cypher— Security & compliance paranoid (in the best way).
- Atlas — System architect. Handles big-picture design and scalability.
- Pixel — Frontend & UX perfectionist.
- Oracle — Data layer expert.
- Swift — DevOps & deployment engineer.
How they work together:
You give a high-level goal (voice or text).
The crew self-organizes — Atlas creates the plan, Forge writes code, SAGE runs tests, Cipher checks security, etc.
They use a shared memory system + structured handoffs.
They only interrupt you when they need a decision, with clear context + options.
Full audit trail and rollback capability.
Current Status:
- Working orchestration using CrewAI + Groq (sub-1.5s latency)
- Phone app beta launching soon
- Planning deep integration with AR glasses
I'm actively looking for technical feedback on the orchestration layer and agent handoff mechanisms.
Would love to hear from other builders working on multi-agent systems.
Join the waitlist → https://tally.so/r/rjGk9R
Top comments (5)
"Supervision" is the right word and an underrated agent role - most multi-agent setups are all do-ers and no checker, which is how you get confident garbage shipped fast. A dedicated supervisor/critic agent whose only job is to review the workers' output against intent is one of the highest-ROI patterns I've found, because catching a bad step early is 10x cheaper than unwinding it downstream.
The nuance I keep hitting: a supervisor agent is only as good as the criteria it checks against, and an LLM supervising an LLM can rubber-stamp plausible-but-wrong work. So I pair the critic with deterministic gates where possible. In Moonshift (a multi-agent pipeline: prompt to a shipped SaaS on your own GitHub + Vercel) the "supervision" is hybrid - hard checks for what's checkable, critic agent for the judgment calls - and routing keeps the whole crew ~$3 flat. First run's free, no card. Cool project - is your supervisor purely LLM-based, or does it lean on hard checks too? The pure-LLM version worries me most about false-confidence approvals.
Completely agree on the importance of a dedicated supervisor/critic role.
Pure “doer” agents are dangerous without strong oversight.
I'm currently mostly LLM-based for supervision but actively moving toward hybrid (deterministic gates + LLM critic). Your point about LLM-on-LLM rubber-stamping is exactly the risk i am trying to mitigate.
Would love to learn how you designed the hybrid system in Moonshift.
Also if you think you'll find Cipher useful, i've shared the waitlist link above in the post!
Appreciate that, will take a look at the waitlist. A dedicated supervisor is the right instinct: the failure mode of multi-agent crews is one agent's bad output silently becoming the next one's trusted input, and a supervisor that gates between steps is what stops the compounding. The thing I'd pressure-test as you build it: what authority does the supervisor actually have, can it halt/roll back a bad step, or only flag? Veto power is where supervision goes from observation to safety. We're clearly circling the same problem (I work on a multi-agent build pipeline, Moonshift) so genuinely rooting for Cipher. Good luck with the launch.
You’re touching on one of the most critical parts i'm designing right now.
On supervisor authority: The supervisor agent will have real veto power, not just flagging.
Specifically: It can halt execution immediately when it detects high-risk or low-confidence output.
It can request rollback to the last safe checkpoint.
It can escalate to the user with clear options (e.g., “This change introduces a security risk — Approve, Modify, or Rollback?”).
I'm building structured checkpoints between major steps so the supervisor can actually prevent compounding errors instead of just observing them.
This hybrid approach (deterministic gates + strong LLM critic with veto rights) is a top priority
Really glad to hear you’re working on something similar with Moonshift.
Would love to exchange more ideas sometime — multi-agent safety is such an important (and underrated) topic.
Thanks again for the high-quality feedback