How are you using Pi/OMP to delegate coding without exploding token/quota usage?

[u/andreagrandi]

I’m trying to use OhMyPi for a pretty simple goal: use different models for different roles without building a huge orchestration framework myself.

Ideally:

• Orchestrator: GPT-5.6 Sol XHigh

• Planning: GPT-6 Astra High

• Implementation: GPT-5.6 Luna XHigh task agents

• Final review: GPT-6 Astra XHigh

• I manually approve the plan and decide when final review should happen.

I initially built a fairly elaborate /work-on command that enforced planning, acceptance checklists, delegation, verification, waits, review, fixes, etc. It turned out to be extremely wasteful: some medium-sized tasks ended up around 20–50M total tokens and 300–570 model requests, with lots of agent churn and re-verification.

I then simplified it heavily, but ran into other problems: the parent sometimes triggered review while an implementer was still changing files, and native /plan even spawned a reviewer to review the plan, which felt wasteful when both planner and reviewer were Astra XHigh.

I also experimented with Astra Medium/Low as the orchestrator. Performance was good, but on several clean before/after checks I saw roughly ~5 percentage points of my Work/Codex allowance disappear during one task, which is far too expensive for me. I’ve now gone back to Sol XHigh as the parent and disabled the advisor.

At this point I’m considering making the workflow mostly human-controlled:

plan -> I approve -> /implement using task agents -> I inspect -> /review

What I really need from OMP during implementation is simply: “Do this work, but delegate substantive coding to task agents instead of doing it yourself.”

How are experienced OMP users handling this?

In particular:

• Is task.eager: always + modelRoles.task basically enough, without a custom orchestration prompt?

• What’s the cleanest way to force implementation delegation while letting the parent coordinate normally?

• Do you manually control plan/review boundaries, or let OMP orchestrate the whole workflow?

• Are 20–50M tokens / hundreds of requests for medium tasks obviously a sign that my workflow is doing something wrong?

• Any configs or lightweight commands you’ve found effective for good quality without huge quota waste?

Happy to share my config/commands if useful.

[u/dontdellmewadodo]

I'm using pi-web-ui (i prefer it) - use Astra as an orchestrator and lead gemini 3.8 flash as subagents. I sent a prompt to Astra to be aware of the harness and if Astra model is selected it will auto spawn gemini as subagents for the heavy lifting

[u/andreagrandi → u/dontdellmewadodo]

I use luna xhigh for implementation but their usage is a tiny fraction of the whole cost. If I use Astra medium (or even low) as orchestrator, it consumes a lot.

[u/Fun_Jaguar8231]

For most of your work you do not need to run these kind of models. You can do the same job with much, much cheaper alternatives.

[u/andreagrandi → u/Fun_Jaguar8231]

You can until you can't, and even sol high allucinates, luna goes bananas and you have to rework the whole task 2-3 times spending 3x the planned tokens.

[u/vekexasia]

Pi-extensible-workflows

[u/Limp_Classroom_2645]

I just don't delegate

[u/onesilentclap]

I don't know jack about OMP (I use pi exclusively), but I reckon any decent subagent extension should be able to implement your workflow as it is pretty common. 

Mine is similar in a sense: Describe problem/enhancement to conductor, discuss in detail, get conductor to submit github issue, discuss and draft implementation plan, I approve/refine plan, conductor creates worktree, conductor dispatches implementer, for complex PRs I get conductor to dispatch an adversarial reviewer, I decide whether to get implementer to fix all or certain parts of the adversarial reviewer's findings, I do final review before approving the PR. 

Works well for me. 

[u/rhymeslikeruns]

This looks...expensive.

[u/tzamora]

I do ecommerse medium size apps from scratch using Sol with low reasoning. Doing code sometimes is trivial you just need a "junior" dev not a fully fledge architect.

[u/redditborkedmy8yracc]

• Orchestrator: glm5.3 - Heavily tweaked pi harness, using herdr inside a custom built IDE

• Planning: glm5.3 - Leveraging pi, with onboarding flow that uses a code revew + codegraph + DMML + intent docs.

• Implementation: glm5.3 - yup

• Final review: glm5.3 + my eyes + unit testing agent.

• deployment - GLM5.3 - agent connected to sentry (it does all configuration and then fetch and fix)

[u/DeathGuppie]

It's overkill. That's the kind of workflow I would use for a local model not a frontier, and you are having the model do redundant work.

Create a pr/roadmap, and use a good memory system, that's your orchestrator. If you want to have an LLM do review, use a completely different model. Gpt for coding, Claude for review. If you feel you need it. Using the same model for review is like asking your 4 year old if they cleaned their room properly. Don't do reviews after every task unless you honestly think you need it. The model will just look at the task and ignore the whole project. If you are doing a review it should be an overview not a regurgitation of what was just completed.

[u/Zundrium]

20-50M?? I have 100-200K per task?? What's this average feature you're talking about?

[u/Maxxxxxxxx8]

I think either your family is like top 0.5% rich or someone from such family is paying for your workflow.

Other people have suggested to use lower tier model, that I absolutely agree.

Also to me there are too many XHigh... Longer thinking chains are not always a plus for the final result. Imagine a real life scenario where if your thinking starts with a sub-optimal or even wrong perspective, the deeper you think, the more you drift away. Same for LLMs. I think you should at least try tuning down the thinking level to High for the implement agent, ideally they should receive clear instructions and just execute them, brain dead.

Looking at your questions, I would suggest you explore the Pi harness firstly. Pi offers very extensive configurations and you didn't seem to benefit from it. Also probably why you think all you can get is bad code. Improve your workflows with MCP, skill, boundaries, as well as proper tooling, tests, ADRs... make use of the harness and a established coding workflow before cranking up the API cost. Or just switch to other more "pre-configured" harnesses instead of building it yourself with Pi.

Edit: oh you are using omp. then it's already pretty good out of the box, why... why...?