GPT 5.4 + ACP + Opus
Opus Dispatch Visual System
Context routing, not blind model loyalty

Opus Dispatch
From local GPT to deep ACP handoff

This page makes the bridge visible. Simple work stays local on GPT 5.4. High-value work gets scored, packed into a tight XML prompt, dispatched through Claude Code ACP to Opus, validated, then returned clean.

Routing threshold
13+
Complex score dispatches to Opus. 9 to 12 is gray zone.
Current architecture
GPT + ACP
Daily work local. Deep work bridged into Opus through ACP.
Core templates
7
Book, framework, soul, strategy, architecture, content, custom.
Fallback chain
3 layers
GPT local first, ACP Opus second, direct paid models only if needed.

1. Animated Flow Diagram

Run the simulation and watch the system branch. Green path stays inside GPT. Red path builds context, constructs XML, spawns ACP, and brings the result back.

Mode: complex dispatch
1
User message arrives
A request lands in chat before any routing logic starts.
2
GPT 5.4 evaluates complexity
Score novelty, emotional depth, voice precision, reasoning, framework load, synthesis, ambiguity, and downside of failure.
3
Decision gate
0 to 8 stays local. 9 to 12 is gray zone. 13 to 16 dispatches.
4
Local answer on GPT
Fast path for routine ops, clear fixes, and lightweight summaries.
dispatch branch
5
Context assembly
Pull only the smallest useful context. Voice, decisions, framework notes, product docs, or source excerpts.
6
XML prompt construction
Build a self-contained prompt with context, constraints, output format, and task.
7
ACP spawn to Claude Code
OpenClaw hands the packaged prompt through ACP into Claude Code on Opus.
8
Opus processes
Deep reasoning, stronger synthesis, higher voice fidelity, cleaner structure.
9
Result returns
Output lands at save path or comes back with a concise result summary.
10
Validation
Confirm the artifact exists. Fix minor issues locally. Re-dispatch only if structure breaks.
11
Response to user
Short answer back. Path, validation state, and what was produced.
12
Cost-aware memory
GPT first by default. Opus only when the quality jump is worth the routing cost.
Ready. Current demo route: Complex request to Opus dispatch.
Dispatch path

2. Live Complexity Evaluator

Type a request. The page scores it in real time and decides whether GPT should handle it or whether the job should cross the bridge to Opus.

14
Dispatch to Opus
Est. prompt: 11.8K tokens

3. Context Assembly Visualizer

When the route goes red, these are the files the assembler considers. The page highlights what gets pulled for the selected template and current request type.

Template: book_chapter

4. Template Preview

Pick the closest template. The actual XML structure updates below, including save path, stateless reminder, and ordered context blocks.

book_chapter

When this template gets used

What it optimizes for

    
            
    
          
    
        
    
      
    

      
    
        
    
          
    
            
    
              
    Real use cases
    
              
    Each card routes the system for a real scenario. Click one. The request loads, the template switches, and the flow animates for that case.
    
            
    
            
    Selected: Write a book chapter
    
          
    

          
    
        
    

        
    
          
    
            
    
              
    Scenario outcome
    
              
    This panel shows what the active use case is proving. Keep it concrete. Why GPT here. Why Opus there.
    
            
    
          
    

          
    
        
    
      
    

      
    
        
    
          
    
            
    
              
    Strategy stack
    
              
    The model plan is not one tool. It is a routing stack. Cheap daily engine first. Deep engine second. Paid premium only when quality or reliability forces it.
    
            
    
          
    

          
    
            
    
              
    Phase 1. Current
    
              
    GPT 5.4 + Claude Code ACP Opus
    
              
    Free + free
    
              
    GPT 5.4 handles daily work locally. Claude Code ACP on Opus handles deep work through stateless dispatch. Best current value.
    
              
      
                
    • Daily work cost stays near zero
      • 
                
    • Deep reasoning still available
      • 
                
    • Needs ACP to stay alive
      • 
              
    
            
    
            
    
              
    Upgrade path
    
              
    Sonnet via OpenRouter + Opus ACP
    
              
    $50 to $80/mo
    
              
    Move daily work from GPT to Sonnet through OpenRouter if GPT quality starts costing more time than it saves. Keep Opus ACP for heavy synthesis.
    
              
      
                
    • Better everyday writing and coding quality
      • 
                
    • Still keeps deep work on ACP Opus
      • 
                
    • Adds monthly cost but controlled
      • 
              
    
            
    
            
    
              
    Premium path
    
              
    Direct Anthropic API Sonnet + Opus on demand
    
              
    $100 to $300+/mo
    
              
    Use direct API access when reliability, throughput, or ACP fragility becomes a real blocker. Highest cost. Highest control.
    
              
      
                
    • Best operational stability
      • 
                
    • Fastest premium fallback
      • 
                
    • Only worth it when output bottleneck is expensive
      • 
              
    
            
    
          
    
        
    

        
    
          
    
            
    
              
    Timeline
    
              
    This is the current plan. Not forever. Just the right move for this phase.
    
            
    
          
    
          
    
            
    
              
    Phase 1. Now
    
              
    GPT + ACP
    
              
    Default stack until GPT quality clearly becomes the bottleneck. Optimize routing discipline first. Avoid buying premium before the free stack is fully exploited.
    
            
    
            
    
              
    Phase 2. Triggered only if needed
    
              
    Sonnet + ACP
    
              
    Upgrade daily engine only if GPT misses too often on tone, reasoning, or coding quality. Keep ACP Opus for deep work until a stronger reason appears.
    
            
    
          
    
        
    

        
    
          
    
            
    
              
    Risk matrix
    
              
    This is where the stack can break. The point is not fear. The point is having a clean fallback before the break happens.
    
            
    
          
    
          
    
            
    
              
                
    
                  Risk
                  Impact
                  What breaks
                  Fallback move
                
    
                  
              
                
    
                  Anthropic closes ACP access
                  High
                  Deep dispatch path disappears. Opus bridge stops.
                  Move deep work to direct Anthropic API or Claude subscription flow if still possible.
                
    
                
    
                  OpenAI changes Codex OAuth or GPT access
                  Medium
                  Daily local engine quality or access shifts.
                  Shift daily work to Sonnet via OpenRouter fast.
                
    
                
    
                  OpenRouter reliability degrades
                  Medium
                  Phase 2 daily engine becomes unstable.
                  Route high-value work to direct APIs only. Keep local free stack for trivial jobs.
                
    
                
    
                  OAuth tokens expire silently
                  Moderate
                  Sudden auth failures across providers.
                  Track token status and refresh windows in dashboard status tab.
                
    
                  
            
    
          
    
        
    

        
    
          
    
            
    
              
    Decision criteria for upgrading to Phase 2
    
              
    Upgrade only when the free stack costs more in missed quality than the paid stack costs in cash.
    
            
    
          
    
          
    
            
    
              
    Quality misses
    
              
    GPT misses tone, logic, or code quality often enough that we spend real time rewriting.
    
            
    
            
    
              
    Throughput pressure
    
              
    Daily workload grows and local GPT quality becomes the pacing constraint.
    
            
    
            
    
              
    Revenue sensitivity
    
              
    More outputs become client-facing, public, or directly tied to revenue and trust.
    
            
    
            
    
              
    Fallback fragility
    
              
    ACP feels too fragile and paid direct access becomes worth the insurance premium.
    
            
    
          
    
        
    
      
    

      
    
        
    
          
    
            
    
              
    Monthly breakdown by strategy
    
              
    Not fake precision. Useful ranges. Enough to compare the stack against output quality and revenue leverage.
    
            
    
          
    

          
    

          
    
            
    
              
                
    
                  Strategy
                  Monthly cost
                  Output quality
                  Speed
                  Best use
                
    
                  
              
            
    
            
          
    
        
    

        
    
          
    
            
    
              
    Token usage estimates
    
              
    Based on current patterns. Heavy local work every day. Dispatch only for high-value jobs. Paid premium stays conditional.
    
            
    
          
    
          
    
            
    
              
    Daily local work
    
              
    400K to 1.2M
    
              
    Mostly operational prompts, quick writing, coding fixes, summaries, and routing logic.
    
            
    
            
    
              
    Deep dispatch prompts
    
              
    8K to 18K
    
              
    Curated context per dispatch. Tight excerpts. No whole-file dumping.
    
            
    
            
    
              
    Deep output return
    
              
    3K to 12K
    
              
    Long-form writing, framework memos, architecture specs, and analysis artifacts.
    
            
    
          
    
        
    

        
    
          
    
            
    
              
    ROI view
    
              
    Cost only matters in relation to the value the system creates.
    
            
    
          
    
          
    
            
    
              
    Cost vs output vs revenue
    
              
      
                
    • Phase 1 is absurdly high ROI if it already improves execution, consistency, and speed.
      • 
                
    • Phase 2 only needs a small quality uplift to justify $50 to $80 per month.
      • 
                
    • Premium direct API access is easy to justify if it removes a bottleneck tied to clients, launches, or content production.
      • 
              
    
            
    
            
    If Siera helps close 1 coaching client at €16K, the API cost pays for itself 30x over.
    
          
    
        
    
      
    

      
    
        
    
          
    
            
    
              
    Current system status
    
              
    Operational snapshot. Which model is live. Whether ACP is healthy. What the fallback order is. Which credentials look stable.
    
            
    
          
    

          
    
            
    
              
    Current model
    
              
    GPT 5.4
    
              
    Active local engine for daily work. Default route stays here until complexity threshold gets crossed.
    
              
    
                Active
                Local
              
    
            
    
            
    
              
    ACP status
    
              
    Healthy
    
              
    Last test result: dispatch path reachable, Claude Code ACP handoff working, response return intact.
    
              
    
                Last test: pass
                Deep work ready
              
    
            
    
          
    
        
    

        
    
          
    
            
    
              
    Fallback chain
    
              
    Ordered by cost discipline first, then depth, then paid stability.
    
            
    
          
    
          
    
            
    1
    GPT 5.4 local
    Default for routine tasks, ops, small writing jobs, and tool-driven fixes.
    
            
    2
    Claude Code ACP on Opus
    Used for deep framework work, voice-sensitive writing, strategic synthesis, and heavy analysis.
    
            
    3
    Sonnet via OpenRouter or direct Anthropic API
    Paid fallback when local quality misses too often or ACP reliability becomes the constraint.
    
          
    
        
    

        
    
          
    
            
    
              
    Credentials snapshot
    
              
    Simple operational view. Active versus watch closely.
    
            
    
          
    
          
    
            
    OpenAI / Codex OAuthActive
    
            
    Claude Max / ACP pathActive
    
            
    OpenRouter tokenOptional fallback
    
            
    Anthropic direct APIOnly for premium path
    
          
    
          
    Expiring first is usually OAuth state, not the model itself. This tab makes the operational weak points visible before the routing fails.