A new AI dev team dropped on GitHub yesterday, and it’s built to say no to itself. Most multi-agent coding setups hand every agent the same god-mode prompt and hope for the best. u/NeitherRun3631, the developer behind this one, threw that idea out and built something that actually behaves like a real engineering org.
The project is a tiered roster of coding agents, T0 through T3, and it’s fully open source. Instead of one giant prompt trying to be junior dev, senior architect, and code reviewer all at once, each tier gets its own defined role. Every role comes with a hard ceiling on what it’s allowed to touch. Think of it less like “one AI that does everything.” It’s closer to an actual org chart, where the intern doesn’t get to sign off on the database migration.
That distinction matters more than it sounds. Anyone who’s run a serious multi-agent coding workflow knows the failure mode. A single mega-prompt agent gets a big task and makes a confident architecture call it has no business making. Three files later, you’re untangling a mess it created with total confidence. This roster structure is a direct answer to that problem, and honestly, it’s the kind of setup that should exist in every multi-agent stack.
Here’s the twist, and it’s the part that makes this worth stealing. The ceilings aren’t soft suggestions baked into a system prompt that the model can talk itself out of. A T0 agent literally cannot approve its own architecture decisions or merge its own work. It has to hand off to a higher tier through a structured process. That’s the same way a junior engineer would loop in a lead before shipping something risky. This handoff structure is the whole point of the project. It’s what stops your agent swarm from confidently doing the wrong thing at scale, instead of just hoping the prompt wording held.
How to try it in your own workflow
- 📋 Pull the repo and read the tier definitions first. Each tier, T0 to T3, has its own scope, permissions, and escalation rules baked in.
- 🧩 Map your actual coding tasks to a tier. Boilerplate, small fixes, and repetitive refactors go to T0. Architecture calls and cross-service changes go to T2 or T3.
- 🔗 Wire up the handoff points before you touch anything else. This is the part people skip, and it’s the part that matters most. A T0 agent should be blocked from merging without a higher-tier sign-off, not just told to ask nicely.
- ✅ Run one small task through the full chain before trusting it with anything real. Watch closely for where the handoff breaks. It usually breaks first, not last.
- Once the chain holds, expand scope gradually. Add one new task type per tier at a time, instead of dumping your whole backlog on day one.
Pro tip: don’t try to run all four tiers on day one. Start with just T0 and T2, junior and senior, and get the escalation path solid before you add the middle tiers. A two-tier system that actually enforces its ceiling beats a four-tier system where every agent quietly ignores its scope.
Second pro tip: log every handoff. When a T0 agent kicks something up to T2, write down why. That log becomes your best debugging tool later. When the agent team makes a call you don’t understand three tasks down the line, you’ll be glad you have it. No replaying the whole conversation history just to figure out where things went sideways.
Third pro tip: treat the tier ceilings as a living document, not a one-time setup. As you watch the agents work, you’ll find tasks that got assigned to the wrong tier. Move them. The whole system gets sharper the more you tune where each ceiling actually sits, and that tuning is honestly half the value here.
This is a sharp reframe for anyone running Claude, GPT, or local models in a multi-agent coding setup. The mega-prompt approach works fine for small stuff. It falls apart the moment you need real accountability in the chain. Giving agents an actual ceiling is one half of the fix. Forcing them to hand off instead of overreach is the other half. Together, they’re the kind of structure most of us should’ve built months ago. It’s a small idea with a big payoff!
If you’re running more than two agents on a real codebase, go check out the full repo and the discussion thread. 🚀 Grab the tier structure and adapt the ceilings to your own stack. Watch how fast your agent team starts acting like it actually has a manager.
Beyond prompts: seniority ceilings for coding agents
by u/NeitherRun3631 in PromptEngineering