conductor
install

for Claude Code + Codex

Same work. Up to 80% less plan usage.

It's Wednesday and your weekly limit is gone. Not on judgment: on greps, boilerplate, and test files that all ran at your primary model's rate. Conductor keeps your best model for the thinking and routes the labor to cheaper tiers. No magic, just routing.

Backs up everything it touches. Managed markers. One-command undo.

install
$ curl -fsSL https://conductorskill.com/install.sh | bash
how it works ↓ 

              
            

          

          
One expensive thinker. Five cheap pairs of hands on this one job.

        

      

    

  


  
  

    

      

        
        
the problem

        
Your best model is doing your worst work.

        
Fable 5 is the best model you can rent and the fastest way to torch a week's plan. Every grep, every boilerplate edit, every test file burns at your primary model's rate. Subagents make it worse: by default they inherit that same expensive model, which is how people lose half a weekly limit in one afternoon. The fix is not a cheaper model. It is the right model for each job.

      

    

  


  
  

    

      

        
        
what actually happens

        
You don't run Conductor. Your next session becomes it.

      


      
    
        
  1. 
          01
          
    
            
    Install once.
    
            
    One command writes four pinned agents and one managed block into your CLAUDE.md (AGENTS.md on Codex).
    
          
    
        
    2. 
        
  2. 
          02
          
    
            
    Open a new session.
    
            
    It reads that block and takes the podium: from your first message it plans on your primary model and hands greps, builds, and reviews to the cheap tiers on its own. Nothing to remember, no new workflow.
    
          
    
        
    3. 
        
  3. 
          03
          
    
            
    Save /conductor for the big ones.
    
            
    Hand it a whole objective and it runs the full loop: recon, plan, parallel waves, verification rounds, synthesis. (Codex: $conductor.)
    
          
    
        
    4. 
      


      

        

          

          CLAUDE.md
        

        

          
  # ...your existing notes, untouched...
+ <!-- conductor:start -->
+ Plan on your primary model.
+ Route greps, builds, and reviews to sonnet and haiku.
+ <!-- conductor:end -->
  # ...the rest of your CLAUDE.md, untouched...

        

      

    

  


  
  

    

      

        
        
how it works

        
You conduct. Cheaper models play.

      


      
    
        
  1. 
          
    You conduct.
    
          
    The session's primary model does only what expensive reasoning is for: intent, decomposition, routing, judgment, synthesis.
    
        
    2. 
        
  2. 
          
    The crew plays.
    
          
    Builders write the code, scouts gather facts, critics review, all in parallel, all at crew prices.
    
        
    3. 
        
  3. 
          
    Your plan stretches.
    
          
    Weekly limits weight usage by per-token cost, and the labor is the bulk of the tokens. Move the labor down a tier and the same plan does more work.
    
        
    4. 
      


      

        One conductor node fanning out to a builder, a scout, a critic, and an architect worker nodeprimaryplan · judgebuildermid tierscoutsmall tiercriticmid tierarchitecttop tierepics onlysynthesisback to you

        Conductor stacked above four workers, feeding down into synthesisprimaryplan · judgebuildermid tierscoutsmall tiercriticmid tierarchitecttop tier · epics onlysynthesisback to you
        
one conductor, four workers, one verified result

        
mid tier = sonnet · small tier = haiku · top tier = opus

      

    

  


  
  

    

      

        
        
the crew

        
Four agents, pinned to a tier.

      


      

        

          
          
buildersonnet

          
Features, fixes, refactors, tests, scripts, drafts.

        

        

          
          
scouthaiku

          
Greps, inventories, config dumps, status checks. Read-only.

        

        

          
          
criticsonnet

          
Adversarial review panels that try to break the work.

        

        

          
          
architectopus

          
Deep design for epics. Used sparingly.

        

      


      
Every agent's model is pinned in its own config file, so a dispatch can never silently run at your primary's rate. That silent inheritance is exactly how subagent-heavy sessions eat weekly limits.

    

  


  
  

    

      

        
        
the fable 5 era

        
Reserve your primary for the hardest 10%.

        
You already run the pattern by hand: plan on the expensive model, hand the labor to Sonnet and Haiku, save the top tier for hard problems and review. Conductor is that pattern, installed. Your primary does judgment and synthesis only. The crew does everything else, at crew prices.

      

    

  


  
  

    

      

        
        
the math, honestly

        
Usually 60-80% less. Sometimes more.

        
Weekly plan limits (or your API bill) weight usage by per-token cost. On build-heavy work the execution tokens dwarf the orchestration tokens, so routing the labor to cheaper tiers commonly burns 60-80% less, the same fact as stretching a plan up to 5x longer. That range is measured against a top-tier metered primary. Less if your primary is already mid-tier, more if you delegate aggressively. No magic, just routing.

        
          
          
          0%60%80%100%already on a cheap defaultdelegating aggressively
        
      


      

        
install

        
One command. Then forget it's there.

      


      

        

          

            

              
            

            

              

                

                  

                  install
                

                

                  

                    $
                    curl -fsSL https://conductorskill.com/install.sh | bash
                    
                  

                

              

              
Then open a new session. It conducts from the first message. For a big objective, hand it /conductor <your objective> (Codex: $conductor).


              
Uninstall anytime:

              

                

                  

                  uninstall
                

                

                  

                    $
                    curl -fsSL https://conductorskill.com/install.sh | bash -s -- --uninstall
                    
                  

                

              

            

          

        


        

          
Requirements

          
    
            
  • 
              
              Claude Code: the sonnet and haiku tiers (any paid plan). opus only for the architect.
            
    • 
            
  • 
              
              Codex CLI: GPT-5.4 and GPT-5.4-mini. GPT-5.5 only for the architect.
            
    • 
          

        

      

    

  


  
  

    

      

        
        
faq

        
Ask the annoying questions.

      


      

        

          
          

            
Yes. Conductor writes its block between managed markers, backs the file up first, and --uninstall removes exactly that block and nothing else. If the markers ever look tampered with, it refuses to guess and tells you instead.

          

        

        

          
          

            
All of it is visible in the script itself. For each harness it detects, it writes four agent files and one skill folder (under ~/.claude for Claude Code; under ~/.codex and ~/.agents for Codex), appends one clearly marked block to your CLAUDE.md or AGENTS.md, records a per-harness manifest of every file it created, and backs up anything it replaces with a timestamped copy. Only if you say yes when it asks: it can also set your Claude Code default model in settings.json, backed up first and flagged again at uninstall. It makes no network calls beyond fetching itself and never touches your code, your keys, or anything outside those folders.

          

        

        

          
          

            
No. Your primary model still thinks, judges, and verifies. It just stops typing the boilerplate itself.

          

        

        

          
          

            
Any paid Claude Code plan with sonnet and haiku. No Opus needed for the core. On Codex, the same routing applies: GPT-5.5 stays for judgment, GPT-5.4 and mini do the labor, and OpenAI's credit metering rewards it the same way.

          

        

        

          
          

            
No. Open a new session after you install and it starts delegating from your first message, because the managed block in your CLAUDE.md tells it to. That's doctrine your session follows, not code that enforces it. Nothing to memorize. Save /conductor for the big ones.

          

        

        

          
          

            
Because then the cheap model does your thinking too. Conductor keeps the judgment expensive and the labor cheap: your primary model plans, routes, and verifies; the cheap tiers type. You could do this by hand with /model. You will not remember to.

          

        

        

          
          

            
Routers put a proxy between you and the API and pick models with heuristics. Conductor doesn't sit in the traffic path. It's instructions plus four pinned agent files inside your harness: no keys, no gateway, no new dependency, and your primary model keeps deciding what to delegate. Uninstall removes the managed block and the agents and you are back to stock.

          

        

        

          
          

            
Send the run guide and, occasionally, a note when a new skill ships, via Resend. Stored in our own database. One-click unsubscribe. Never sold, never shared.

          

        

      

    

  


  
  

    

      

        
Your best model has better things to do.

        

          

            
          

          

            

              

                

                install
              

              

                

                  $
                  curl -fsSL https://conductorskill.com/install.sh | bash
                  
                

              

            

          

        

        
One command. Every session after this one conducts on its own.