Introducing Processing Strategies: Explicit Mode Selection for AitherOS

AitherOS has always been powerful under the hood — CouncilReview, AitherDeliberation, SwarmCodingEngine, DeepResearchPipeline, deep reasoning, PRISM debugging — but until now, every one of these subsystems was gated behind auto-detection. IntentEngine classified effort, DeepReasoningHelper scored depth, and the pipeline auto-engaged features based on heuristics. There was no way for a user to explicitly say "use the council" or "debug this with long exploratory tool chains."

Today that changes with the Processing Strategy System — a unified strategy selector that lets users explicitly engage processing modes, including three new PRISM-powered debugging strategies backed by cloud GPU reasoning.

The Problem

Auto-detection is great for most messages. But sometimes you know exactly what you want:

• You're debugging a production issue and need systematic investigation with 40+ tool calls and expert debugging personas — not the orchestrator's best guess.
• You want a council of 6 specialists to review a response before you see it.
• You need the full reasoning model on cloud GPU — DeepSeek R1 or Gemma 4 — not the local orchestrator.
• You're curious whether deep research or deep reasoning gives a better answer — and you want to find out by running both in parallel.

How It Works

Trigger Prefixes

The simplest way to use strategies is trigger prefixes in your message:

@think What are the implications of quantum error correction?
@debug Why is the Redis connection timing out?
@troubleshoot The worker service keeps crashing
@investigate Memory leak in the context pipeline
@research Latest developments in nuclear fusion
@council Review my API design for the payment service
@swarm Build a REST API for inventory management
@compete Explain the CAP theorem

The @ prefix is detected before IntentEngine runs, the trigger is stripped from the message, and the strategy's constraints override the pipeline's auto-detection.

The strategy Field

For programmatic callers, ChatRequest now has a strategy field:

{"message": "Explain recursion", "strategy": "think"}

MCP Tools

Four new MCP tools are available:

• list_strategies() — see all 14 strategies with descriptions
• set_strategy(strategy, message) — process with an explicit strategy
• compete_strategies(message, strategies?, preset?) — parallel compete mode
• get_strategy_config(strategy) — inspect a strategy's full config

The 14 Strategies

PRISM Debugging Integration

The three debugging strategies are the most sophisticated addition. They integrate the PRISM (Problem Resolution through Iterative Strategy Mutation) system — six expert debugging personas inspired by legendary engineers:

The Six Personas

How Debug Mode Works

When you send @debug why is Redis timing out?:

1. Strategy Resolution: effort_floor=8, agentic=True, use_reasoning=True
2. PRISM Overlay: The first persona (CARMACK — Methodical Isolation) is injected as a system prompt supplement into the agentic runtime
3. Reasoning Model: Effort 8 routes to vllm_cloud_reasoning backend, which connects to DeepSeek R1 on Vast.ai GPU
4. Long Tool Chains: Up to 40 turns of exploratory tool calls — search_code, read_file, run_command, reason, knowledge_search, web_search
5. Investigation Protocol: Each tool call requires a stated hypothesis, analysis of results, and hypothesis revision
6. Strategy Rotation: If the current persona stalls, the agent explicitly rotates to the next debugging persona

The Three Debug Strategies

@debug — Full PRISM rotation with all 6 personas and 40 tool turns. For deep code-level debugging where you need systematic root cause analysis.

@troubleshoot — Infrastructure-focused with HOPPER (physical verification), GOSLING (trace injection), and CARMACK (isolation). Only 30 tool turns, but includes council review of findings — 6 specialists validate the diagnosis before you see it.

@investigate — Maximum exploration: 50 tool turns with reasoning checkpoints — every 3-5 tool calls, the agent pauses and uses the reason tool (cloud GPU DeepSeek R1) to synthesize findings, identify unknowns, and plan next steps. Prevents tunnel vision during long investigations.

Cloud GPU Reasoning Pipeline

All three debug strategies route through the cloud GPU reasoning model:

@debug msg
  -> StrategyResolver (effort_floor=8, use_reasoning=True)
  -> IntentEngine (constrained — effort raised to 8+)
  -> EffortScaler: tier=deep -> backend=vllm_cloud_reasoning
  -> ReasoningNodeManager: discover Vast.ai instance (label: aither:reasoning)
  -> SSH tunnel: localhost:8176 -> Vast.ai vLLM:8000
  -> DeepSeek R1 14B (or Gemma 4 26B MoE at effort 9+)

The reason tool is automatically registered for effort >= 7. The orchestrator (aither-orchestrator) stays as the primary model for tool calling, but can invoke the cloud reasoning model as a tool whenever it needs extended analysis. This lets the orchestrator be the router: it uses file tools, search tools, AND the reasoning model as needed.

Fallback chain: vllm_gemma4_reasoning -> vllm_cloud_reasoning -> vllm (local orchestrator). If cloud GPUs are unavailable, the system degrades gracefully to the local model with a quality warning.

Compete Mode

The compete mode launches N strategies in parallel via asyncio.gather, collects their responses, then runs a single LLM judge call that scores each candidate on relevance, correctness, depth, and clarity.

Named presets make compete easy to use:

• reasoning — think vs reason vs deliberate
• coding — auto vs swarm vs agentic
• comprehensive — auto vs think vs research vs council
• debugging — debug vs troubleshoot vs investigate
• debug_vs_reason — debug vs reason vs council

Architecture

The strategy system is an explicit override layer that sits in ChatEngine.process() between request setup and IntentEngine classification. It does NOT replace IntentEngine — it pre-configures the request so IntentEngine's decisions get overridden.

Request -> Strategy Resolution -> IntentEngine (constrained) -> Pipeline
               | (if subsystem)
         Subsystem Fast-Path:
           research   -> DeepResearchPipeline.research()
           council    -> UCB.think() + CouncilReview.review()
           deliberate -> POST /deliberate to AitherDeliberation:8230
           swarm      -> SwarmCodingEngine.execute()
           debug      -> PRISM overlay + agentic runtime (40-50 turns)
                         + reasoning tool (cloud GPU)
                         + optional council review
           compete    -> asyncio.gather(N strategies) + LLM judge

Composition rules are clean: effort_floor = max(strategy.floor, user.min_effort), effort_ceiling = min(strategy.ceiling, user.max_effort), and user ForceToggles override strategy ForceToggles.

Test Coverage

88 tests covering all 14 strategies, all subsystem executors, PRISM integration, compete mode, and the full debug/troubleshoot/investigate chain. All passing.

The strategy system is live on the cleanup/repo-organization branch and will be available in the next release.