The Martial Arts School Keeps No Secrets: Strategy Blueprints That Grow Themselves
> Three Ledgers of Compute · Part 3: The Strategy Ledger > Paper: Strategist: Evolving Reasoning with Agents > arXiv: 2611.03618 | Princeton University + Meta
The Problem of Half a House
An AI system has two halves, but they receive vastly different treatment.
One half is the model — the trained parameters that set the system's intelligence ceiling. This half gets all the industry's attention: scaling laws, distillation, RLHF, MoE, trillion-parameter stacks. Every new model release is a tech headline.
The other half is the reasoning strategy — how to invoke the model, in what order, with what methods, how many steps, how many verification passes, when to use a fast model and when to bring in the heavy artillery. If the model is the engine, the strategy is the transmission, suspension, steering, and navigation combined. No matter how good the engine, wrong gear means slow.
Yet this half is treated as artisanal handcrafting. AI engineers worldwide write prompts, tune workflows, orchestrate agents, and design multi-step pipelines — from scratch, per task. A code-review flow tuned over three weeks in project A gets rebuilt from zero in project B. A Chain-of-Thought template designed for translation doesn't work on math — not because CoT is bad, but because the reasoning structure differs per task.
Worse: experience doesn't accumulate. The discovery that "self-verification before voting works well" lives in your head, your Notion notes, your code comments. You leave, it dies. The next engineer starts from zero, repeats your mistakes, and might — if lucky — arrive at the same conclusion.
The industry's strategy design is literally reinventing the wheel: one person invents "decompose then solve step by step" and blogs it; another independently invents "least-to-most prompting" and publishes; a third writes "step-by-step works well" in an internal wiki. Three inventions of the same wheel.
Strategist asks an obvious-but-unanswered question: Why can't reasoning strategies evolve on their own? Why does every deployment start from scratch? Why can't one task's experience transfer automatically to the next?
The Blueprint: Making Strategies Transcribable
Strategist's foundational invention is the Strategy Blueprint — like giving a martial arts world a unified manual format so techniques can be copied between schools.
A blueprint is a Python program capturing the structure of a reasoning strategy — which model to call, in what order, what verification, under what conditions to branch — but excluding task-specific prompts. The interface is one signature: execute(llm, task) -> str. Any blueprint can call any other as a subroutine, like Lego bricks: a decompose-and-solve blueprint can invoke a self-verification blueprint for each step; a multi-agent debate blueprint can use three single-turn QA blueprints as debaters.
There are only two base primitives: chat (single/multi-turn direct answering) and agent (tool- and environment-using). Everything else composes from these, forming a directed graph governed by four protocols: unified interface (every node callable), no forward references (only call earlier-created blueprints), no cycles, and no duplicates (functionally equivalent blueprints kept only once). The result is a clean, acyclic, redundant-free hierarchy where strategy becomes reusable code — experience moves from oral tradition to a library.
The Meta-Agent: A Designer Who Never Answers
With a manual format, you need someone who writes manuals. Strategist is a meta-agent — itself powered by GPT-6 via Codex CLI — that designs how questions get answered but never answers benchmark questions directly. Task models are Qwen3 at three scales (0.6B fast, 1.7B balanced, 4B complex), each with thinking on/off — six configurations. Strategist is the coach; these are the athletes.
Each iteration runs a four-step loop:
1. Retrieve. Hybrid search (TF-IDF + embedding similarity) over the blueprint library — not just code, but each blueprint's feature tags, measurement cards (accuracy/cost records), and experience notes (when it worked, when it failed, why). The library also returns adjacent inspiration from other domains — cross-domain structural transfer is a key innovation source. 2. Propose. K=5 candidates, each of three types: novel (from scratch), composed (wrap/extend existing blueprints), or reuse (existing blueprint + task prompt). At least one of each per round balances exploration and exploitation. 3. Evaluate. Candidates run on real samples with careful data splits: training set (Strategist sees full agent traces and scores), validation set (aggregate scores only — preventing overfitting to training noise), hidden set (choosing the round's winner), and test set (untouched, final confirmation). Standard ML hygiene, transplanted from model training to strategy design. 4. Accumulate. Each candidate's underlying blueprint (not the strategy, which contains non-transferable task prompts) is written back with measurement cards, experience notes, and dedup checking.
The models stay frozen throughout. No training, no gradients. Only the strategy — that other half of the house — evolves.
Thirty Duels, Twenty-Four Wins
The evaluation is large: 40 benchmarks across seven categories (math, commonsense, knowledge, multi-hop QA, logic, code, recommendation); 30 random ones for the main experiment, 10 held out. Against 18 baselines — from direct prompting to Self-Consistency, Tree of Thoughts, Reflexion, Chain-of-Verification, multi-agent debate, MetaGPT, AutoGen, Chain-of-Agents — across 6 model configurations (108 cells per benchmark). The strongest baseline (BL) is the best cell on each training set, simulating real deployment. Cost is weighted by model tier (1× / 2.83× / 6.67×), reflecting true FLOPs ratios.
Result: 24 wins, 2 ties, 2 accuracy-for-cost trades, 2 slightly costlier at equal accuracy. Average accuracy 74.7% vs BL's 74.0% — essentially tied — but weighted inference cost dropped 39%.
The 24 wins aren't about being smarter — identical underlying models — but about deployment: which steps run on fast models, when to verify, when to decompose, when simple single-turn suffices. Highlights: SQuAD v2 accuracy 73.2% → 79.1% at 23% of the cost; TriviaQA +9.8% accuracy at −60% cost; on near-ceiling benchmarks (MMLU, GSM8K, ASDiv, SciQ), accuracy held while cutting cost 66–89%. Honest downsides: on MedQA and AIME 2024 it traded 4–5 accuracy points for cheaper cost; on HotpotQA and COPA it cost 6–9% more at equal accuracy. Strategist isn't Pareto-optimal; sometimes it trades wrong.
Transferable Secrets: One-Shot Retrieval and Cross-Model Transfer
Two capabilities elevate Strategist beyond a good auto-designer:
One-shot retrieval. After 30 benchmarks, the library held 1,865 blueprints. On 10 unseen benchmarks — no iterative search, no GPT-6, no new code — just retrieve the top-5 blueprints, test each on dev data, pick the best: average accuracy 81.4% vs BL's 77.8%, 6 outright wins, all 10 within 2 points. Experience transfers almost out-of-the-box. (Caveat: against ultra-cheap single-call baselines like BoolQ's, any multi-step strategy costs more.)
Cross-model transfer. Blueprints found on Qwen3 ran on GPT-5 and Gemini-2.5 with zero changes: 7/10 and 8/10 wins, total cost down 35% and 40% respectively. AQuA-RAT on GPT-5: +189% accuracy, −86.5% cost. Blueprints capture task structure, not model quirks — unlike some baselines (Self-Refine, Multi-Agent Debate) whose prompt templates broke outright on GPT-5. Bonus: model upgrades no longer mean rewriting your reasoning pipelines.
Anatomy of a Strategy
The paper showcases a discovered Amazon-Rec recommendation pipeline:
1. Profile: fast model builds a user preference profile. 2. Signal extraction: fast model extracts brand/category signals. 3. Conditional routing — the crux: deterministic logic checks if preferences are stable. Stable users get simple recommendation; drifting/contradictory ones trigger a three-agent debate (price-focused, brand-focused, feature-focused advisors). 4. Merge: confidence-weighted combination. 5. Audit: consistency check against the user profile.
The routing embodies dynamically allocating compute by input difficulty — echoing LAND's difficulty-adaptive sampling from part 2 of this series.
Ablations confirm each component: without the library (search but no accumulation), average accuracy falls 78.7% → 65.4%; zero-shot with neither, 39.4% — worse than most baselines. Strategist's first instincts aren't good; its value is iteration and cross-task learning. Against five published auto-design frameworks (AFlow, ADAS, EvoFlow, StrategyLLM, AgentSquare) with the same meta-LLM and executor, Strategist wins 8/10, averaging 78.7% vs AFlow's 67.0% — the gap coming from free-form Python, cross-task accumulation, and a larger search space.
Not Overclaiming
- Search itself costs. ~50 candidate evaluations per benchmark, each possibly thousands of model calls — not fully counted in the reported costs. For one-off tasks, hand-writing may be cheaper.
- Some winning strategies are simple. Some wins came from simple baseline scripts found during search. Strategist's real contribution may be automated strategy–task matching at scale, not exotic strategies.
- Library evolution is open. Will retrieval quality degrade as the library grows? Do experience notes go stale when models change? Is garbage collection needed?
- Selection bias. Hidden-set-selected strategies beat the test set by only 0.7 points on average (vs 4.3 on the hidden set) — real-world gains are likely smaller than hidden-set numbers suggest.
- Interpretability at scale. With 1,865 readable blueprints, human review becomes "explainable but nobody actually explains it" — technical debt, agent edition.
- Library bias. The library likely over-represents math and commonsense reasoning patterns from the search benchmarks, which could mislead future searches in very different domains.
- Lu, T., Xu, Q., Hua, Z., & Liu, Z. (2026). Strategist: Evolving Reasoning with Agents. arXiv:2611.03618. Princeton University + Meta.
- Hu, S., Lu, C., & Clune, J. (2025). Automated Design of Agentic Systems. ICLR 2025.
- Zhang, J., et al. (2025). AFlow: Automating Agentic Workflow Generation. ICLR 2025.
- Wang, X., et al. (2024). Voyager: An Open-Ended Embodied Agent with Large Language Models. TMLR.
- Zhao, A., et al. (2024). ExpeL: LLM Agents Are Experiential Learners. AAAI 2024.
- Shinn, N., et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. NeurIPS 2023.
- Gao, C., et al. (2024). StrategyLLM: Large Language Models as Strategy Generators, Executors, Optimizers, and Evaluators for Problem Solving. NeurIPS 2024.
- Hong, S., et al. (2024). MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. ICLR 2024.
The Second Half Starts Evolving Itself
The paper's conclusion is bold: "Until now, only the model in an AI system could learn. Now the rest of it can too."
Strategist shows reasoning strategies can be versioned like software, accumulated like knowledge, and improved like evolution. Thirty tasks left 1,865 blueprints — each a validated reasoning structure with measured performance and inherited experience notes. At a thousand or ten thousand tasks, the library's compounding effect has only begun.
Framed within this series' three ledgers: SIMPLE Law covered physical-layer efficiency (the electricity cost per token), LAND covered algorithmic-layer efficiency (allocating samples by marginal value), and Strategist covers the metacognitive layer — even the knowledge of "how to spend least" can be automatically accumulated and evolved.
As the learning curve of the models themselves flattens, strategy- and system-level optimization becomes the next major source of performance gains — a shift from "bigger models" to "smarter usage." The engine keeps getting stronger; now the transmission evolves too — not hand-built, but by itself.