claude-router 0.1.0__tar.gz

claude_router-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

claude_router-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+venv/
+*.swp
+*.swo
+.DS_Store
+.idea/
+.vscode/
+__pycache__/

claude_router-0.1.0/AGENTS.md

@@ -0,0 +1,88 @@
+# AGENTS.md
+
+## Overview
+
+**claude-router** routes Claude API calls to the cheapest model that works using embedding-based task classification + task-specific scaffolds. Single Python file, ~200 LOC, no build step. Blind-eval validated: 11x cost reduction with equal or better quality on eval, research, and content tasks.
+
+## File Map
+
+- `router.py` — The only code file. `ClaudeRouter` class with `.route()` and `.build_prompt()` methods. ~200 LOC.
+- `scaffolds.json` — 5 scaffold templates: calibrated-scoring, insight-first, plan-first, substance-check, bug-hunt. Each includes task description, constraint text, evidence, and when_to_use/when_not_to_use.
+- `data/centroids.json` — Pre-computed task classification embeddings (nomic-embed-text, 768-dim). One centroid per category. **Do not modify.**
+- `data/routing_table.json` — Category -> (model + scaffold) lookup. Maps 12 task categories to Haiku/Sonnet/Opus + optional scaffold. **Do not modify structure.**
+- `README.md` — Full documentation, benchmarks, cost math, anti-findings.
+- `requirements.txt` — Dependencies: `requests`, `numpy`.
+- `examples/basic_usage.py` — End-to-end example: classify, route, call Anthropic API.
+
+## How It Works
+
+1. Embed incoming prompt via Ollama (nomic-embed-text, ~5ms)
+2. Cosine-similarity against centroids for all 12 categories
+3. Look up routing table: best category -> model + scaffold key
+4. If low confidence, fall back to Opus (safe default)
+5. Return scaffold text (if applicable) to prepend to prompt
+
+No LLM calls, no external APIs, ~10ms total latency.
+
+## Testing Changes
+
+```bash
+# Requires Ollama running with nomic-embed-text
+ollama pull nomic-embed-text
+
+# Test classification on a single prompt
+python router.py "Evaluate this research paper"
+
+# Run test suite (8 default test prompts)
+python router.py
+```
+
+Expected output: JSON with `{category, model, scaffold_key, confidence, ...}` or a table with routing decisions.
+
+## What NOT to Change
+
+- **centroids.json** — Pre-computed task classification embeddings. Do not modify.
+- **routing_table.json structure** — The category->model mappings are validated. Adding/removing categories requires retraining centroids. Changing model assignments should only happen after blind evaluation.
+
+## Common Tasks
+
+### Add a new scaffold
+1. Edit `scaffolds.json`: add a new key with `task`, `text`, `evidence`, `when_to_use`, `when_not_to_use`.
+2. Do NOT add it to routing_table.json until tested.
+3. Run blind eval on your task domain (10+ judgments) before committing.
+4. Update README.md scaffold table if it becomes a default.
+
+**Anti-finding**: Scaffolds break operational and coding tasks. The router already avoids scaffolding these. Do not scaffold categories marked `null` in routing_table.json.
+
+### Change which model handles a category
+1. Edit `routing_table.json`: update the `"model"` value (haiku/sonnet/opus).
+2. Test against your task distribution with `python router.py`.
+3. Run blind eval (10+ judgments) before merging.
+
+### Debug classification mismatches
+1. Run `python router.py "your prompt"` -- check the `confidence` field (margin between best and second-best category).
+2. Low confidence (<0.02) -> prompt is ambiguous, falls back to Opus automatically.
+3. Wrong category -> centroids trained on a different task distribution. Consider custom centroids via constructor.
+
+### Use custom data files
+```python
+router = ClaudeRouter(
+    centroids_path="my_centroids.json",
+    routing_table_path="my_routing.json",
+    scaffolds_path="my_scaffolds.json"
+)
+```
+
+## Key Constraints
+
+- Requires Ollama running locally with `nomic-embed-text`.
+- Centroids trained on one user's workload -- may not match yours. Test before relying on routing decisions.
+- Scaffolds validated through blind eval. Do not add scaffolds without testing.
+- Scaffolds on operational/coding tasks make quality worse (anti-finding). Router handles this automatically.
+
+## Error Handling
+
+- `RuntimeError`: Ollama is down, timed out, or returned unexpected response format.
+- `ValueError`: JSON files (centroids, routing table, scaffolds) are malformed, missing, or have mismatched keys (e.g., routing table references a scaffold that doesn't exist).
+
+See README.md for benchmarks, cost analysis, and anti-findings.

claude_router-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rolando Bosch / Hermes Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

claude_router-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: claude-router
+Version: 0.1.0
+Summary: Embedding-based scaffold router for Claude API. Routes tasks to the right scaffold using centroid matching. By Hermes Labs.
+Project-URL: Homepage, https://hermes-labs.ai
+Project-URL: Documentation, https://github.com/roli-lpci/claude-router#readme
+Project-URL: Repository, https://github.com/roli-lpci/claude-router
+Project-URL: Bug Tracker, https://github.com/roli-lpci/claude-router/issues
+Author-email: Hermes Labs <rbosch@lpci.ai>
+License: MIT
+License-File: LICENSE
+Keywords: agent,agentic,anthropic,claude,context-engineering,cost-optimization,embedding,llm,prompt-engineering,routing,scaffold
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# claude-router
+
+Route Claude API calls to the cheapest model that works. 5 validated scaffolds, embedding-based task classification in ~10ms. Validated on 300+ blind-judged API calls.
+
+## Results
+
+| Task | Best Setup | Cost | Quality vs. Baseline |
+|------|-----------|------|------------|
+| Eval/scoring | Haiku + scaffold | $0.06 | MAE 1.0 (vs Sonnet raw: 1.2) |
+| Research | Sonnet + scaffold | $0.28 | 8.49/10 (vs Opus raw: 7.45) |
+| Content | Haiku + scaffold | $0.06 | 4/5 blind wins vs Sonnet |
+| Code review | Sonnet (raw) | $0.28 | 8.7/10 (vs Opus: 8.1) |
+
+## Anti-findings
+
+These are the blocker issues. The router handles them automatically:
+
+- **Scaffolds break operational tasks** (0/9 success). Haiku treats constraints as meta-instructions instead of executing tasks.
+- **Scaffolds hurt coding** (4.9 vs 6.4 raw). Don't scaffold code review, design, or debugging.
+- **Opus doesn't scaffold**. Safety-critical evals need Opus raw (MAE 0.0), not scaffolded.
+
+The routing table avoids these entirely: no scaffolds on operational, coding, safety-critical, or conversation tasks.
+
+## Install
+
+Requires: Python 3.10+, `requests`, `numpy`, and [Ollama](https://ollama.com) running locally with nomic-embed-text.
+
+```bash
+pip install claude-router
+ollama pull nomic-embed-text
+```
+
+## Quick start
+
+```python
+from claude_router import ClaudeRouter
+
+router = ClaudeRouter()
+result = router.route("Evaluate this research paper for methodological rigor")
+
+print(result["model"])           # claude-haiku-4-5
+print(result["scaffold_key"])    # calibrated-scoring
+print(result["cost_per_1k"])     # 0.0008
+
+# Build prompt with scaffold prepended
+prompt = router.build_prompt("Evaluate this research paper...")
+# → Pass prompt as system message to Anthropic API
+```
+
+Or CLI:
+
+```bash
+python router.py "Write a blog post about Q2 results"
+```
+
+## How it works
+
+1. Embed your prompt using nomic-embed-text (~5ms)
+2. Compare against pre-computed task-category centroids
+3. Look up routing table: category → model + scaffold
+4. Return model ID and scaffold text
+
+No LLM calls for routing. All locally in ~10ms. Low confidence (router accuracy 74% on 26-prompt benchmark) defaults to Opus.
+
+## The 5 scaffolds
+
+Each scaffold is validated through blind evaluation. They work by constraining the model's output space to the task structure.
+
+See [scaffolds.json](scaffolds.json) for full text and evidence:
+
+- **calibrated-scoring**: Integer 1-10, cite evidence, not generous/critical
+- **insight-first**: Lead non-obvious, concrete recs, 3-4 sentences
+- **plan-first**: g:goal;c:constraints;s:steps;r:risks prefix
+- **substance-check**: Real gaps not surface, name issue and location
+- **bug-hunt**: Specific bugs, line numbers, severity, one-line fix
+
+## Routing table
+
+```
+eval              → Haiku   + calibrated-scoring
+research          → Sonnet  + insight-first
+content           → Haiku   + insight-first
+analytical_review → Haiku   + substance-check
+search            → Haiku   + plan-first
+
+coding            → Sonnet  (raw)
+operational       → Sonnet  (raw)
+status_check      → Haiku   (raw)
+conversation      → Opus    (raw)
+safety_critical   → Opus    (raw)
+```
+
+Low confidence → Opus (safe default).
+
+## Cost math
+
+For 10,000 Claude API calls/month:
+
+| Strategy | Cost | Quality |
+|----------|------|---------|
+| All Opus | $6,800 | Baseline |
+| All Sonnet | $2,800 | Lower on eval, equal on code |
+| claude-router | ~$620 | Equal or better on eval/research/content |
+
+## Customization
+
+Swap scaffolds, centroids, or routing table:
+
+```python
+router = ClaudeRouter(
+    centroids_path="my_centroids.json",
+    routing_table_path="my_routing.json",
+    scaffolds_path="my_scaffolds.json"
+)
+```
+
+## Limitations
+
+- Requires Ollama locally (for embeddings)
+- Centroids trained on one task distribution — test on your workload
+- Router misclassifies 26% of tasks — low confidence defaults to Opus
+- Anti-findings are real: scaffolds on coding/operational make things worse
+- Lite mode (Haiku-first routing for max savings) planned for v1.1
+
+## Evidence
+
+Benchmarks: [benchmarks/](benchmarks/) | Raw citations: [scaffolds.json](scaffolds.json) | License: [MIT](LICENSE)
+
+Key experiments: 4-condition code/research crossover, scaffolds-vs-operational stress test, scaffolded Sonnet beats Opus 75% on research (6/8 blind wins, 140 API calls).
+
+## Hermes Labs Ecosystem
+
+claude-router is part of the [Hermes Labs](https://hermes-labs.ai) open-source suite:
+
+- [**lintlang**](https://github.com/roli-lpci/lintlang) — Static linter for AI agent tool descriptions and system prompts
+- [**little-canary**](https://github.com/roli-lpci/little-canary) — Prompt injection detection
+- [**zer0dex**](https://github.com/roli-lpci/zer0dex) — Dual-layer memory for AI agents
+- [**zer0lint**](https://github.com/roli-lpci/zer0lint) — mem0 extraction diagnostics
+- [**suy-sideguy**](https://github.com/roli-lpci/suy-sideguy) — Autonomous agent watchdog
+- [**quickthink**](https://github.com/roli-lpci/quickthink) — Planning scaffolding for local LLMs
+
+---
+
+Need this calibrated to your pipeline? [Open an issue](https://github.com/roli-lpci/claude-router/issues) or reach out to [Hermes Labs](https://hermes-labs.ai) for custom scaffolds and production integration.

claude_router-0.1.0/README.md

@@ -0,0 +1,144 @@
+# claude-router
+
+Route Claude API calls to the cheapest model that works. 5 validated scaffolds, embedding-based task classification in ~10ms. Validated on 300+ blind-judged API calls.
+
+## Results
+
+| Task | Best Setup | Cost | Quality vs. Baseline |
+|------|-----------|------|------------|
+| Eval/scoring | Haiku + scaffold | $0.06 | MAE 1.0 (vs Sonnet raw: 1.2) |
+| Research | Sonnet + scaffold | $0.28 | 8.49/10 (vs Opus raw: 7.45) |
+| Content | Haiku + scaffold | $0.06 | 4/5 blind wins vs Sonnet |
+| Code review | Sonnet (raw) | $0.28 | 8.7/10 (vs Opus: 8.1) |
+
+## Anti-findings
+
+These are the blocker issues. The router handles them automatically:
+
+- **Scaffolds break operational tasks** (0/9 success). Haiku treats constraints as meta-instructions instead of executing tasks.
+- **Scaffolds hurt coding** (4.9 vs 6.4 raw). Don't scaffold code review, design, or debugging.
+- **Opus doesn't scaffold**. Safety-critical evals need Opus raw (MAE 0.0), not scaffolded.
+
+The routing table avoids these entirely: no scaffolds on operational, coding, safety-critical, or conversation tasks.
+
+## Install
+
+Requires: Python 3.10+, `requests`, `numpy`, and [Ollama](https://ollama.com) running locally with nomic-embed-text.
+
+```bash
+pip install claude-router
+ollama pull nomic-embed-text
+```
+
+## Quick start
+
+```python
+from claude_router import ClaudeRouter
+
+router = ClaudeRouter()
+result = router.route("Evaluate this research paper for methodological rigor")
+
+print(result["model"])           # claude-haiku-4-5
+print(result["scaffold_key"])    # calibrated-scoring
+print(result["cost_per_1k"])     # 0.0008
+
+# Build prompt with scaffold prepended
+prompt = router.build_prompt("Evaluate this research paper...")
+# → Pass prompt as system message to Anthropic API
+```
+
+Or CLI:
+
+```bash
+python router.py "Write a blog post about Q2 results"
+```
+
+## How it works
+
+1. Embed your prompt using nomic-embed-text (~5ms)
+2. Compare against pre-computed task-category centroids
+3. Look up routing table: category → model + scaffold
+4. Return model ID and scaffold text
+
+No LLM calls for routing. All locally in ~10ms. Low confidence (router accuracy 74% on 26-prompt benchmark) defaults to Opus.
+
+## The 5 scaffolds
+
+Each scaffold is validated through blind evaluation. They work by constraining the model's output space to the task structure.
+
+See [scaffolds.json](scaffolds.json) for full text and evidence:
+
+- **calibrated-scoring**: Integer 1-10, cite evidence, not generous/critical
+- **insight-first**: Lead non-obvious, concrete recs, 3-4 sentences
+- **plan-first**: g:goal;c:constraints;s:steps;r:risks prefix
+- **substance-check**: Real gaps not surface, name issue and location
+- **bug-hunt**: Specific bugs, line numbers, severity, one-line fix
+
+## Routing table
+
+```
+eval              → Haiku   + calibrated-scoring
+research          → Sonnet  + insight-first
+content           → Haiku   + insight-first
+analytical_review → Haiku   + substance-check
+search            → Haiku   + plan-first
+
+coding            → Sonnet  (raw)
+operational       → Sonnet  (raw)
+status_check      → Haiku   (raw)
+conversation      → Opus    (raw)
+safety_critical   → Opus    (raw)
+```
+
+Low confidence → Opus (safe default).
+
+## Cost math
+
+For 10,000 Claude API calls/month:
+
+| Strategy | Cost | Quality |
+|----------|------|---------|
+| All Opus | $6,800 | Baseline |
+| All Sonnet | $2,800 | Lower on eval, equal on code |
+| claude-router | ~$620 | Equal or better on eval/research/content |
+
+## Customization
+
+Swap scaffolds, centroids, or routing table:
+
+```python
+router = ClaudeRouter(
+    centroids_path="my_centroids.json",
+    routing_table_path="my_routing.json",
+    scaffolds_path="my_scaffolds.json"
+)
+```
+
+## Limitations
+
+- Requires Ollama locally (for embeddings)
+- Centroids trained on one task distribution — test on your workload
+- Router misclassifies 26% of tasks — low confidence defaults to Opus
+- Anti-findings are real: scaffolds on coding/operational make things worse
+- Lite mode (Haiku-first routing for max savings) planned for v1.1
+
+## Evidence
+
+Benchmarks: [benchmarks/](benchmarks/) | Raw citations: [scaffolds.json](scaffolds.json) | License: [MIT](LICENSE)
+
+Key experiments: 4-condition code/research crossover, scaffolds-vs-operational stress test, scaffolded Sonnet beats Opus 75% on research (6/8 blind wins, 140 API calls).
+
+## Hermes Labs Ecosystem
+
+claude-router is part of the [Hermes Labs](https://hermes-labs.ai) open-source suite:
+
+- [**lintlang**](https://github.com/roli-lpci/lintlang) — Static linter for AI agent tool descriptions and system prompts
+- [**little-canary**](https://github.com/roli-lpci/little-canary) — Prompt injection detection
+- [**zer0dex**](https://github.com/roli-lpci/zer0dex) — Dual-layer memory for AI agents
+- [**zer0lint**](https://github.com/roli-lpci/zer0lint) — mem0 extraction diagnostics
+- [**suy-sideguy**](https://github.com/roli-lpci/suy-sideguy) — Autonomous agent watchdog
+- [**quickthink**](https://github.com/roli-lpci/quickthink) — Planning scaffolding for local LLMs
+
+---
+
+Need this calibrated to your pipeline? [Open an issue](https://github.com/roli-lpci/claude-router/issues) or reach out to [Hermes Labs](https://hermes-labs.ai) for custom scaffolds and production integration.

claude_router-0.1.0/benchmarks/L2-002-sonnet-vs-opus.md

@@ -0,0 +1,97 @@
+# L2-002: Expanded Sonnet ↔ Opus Comparison — Results
+**Date:** 2026-03-22
+**Duration:** ~15 min (15:29–15:44 ET)
+**Models:** Claude Sonnet 4 (claude-sonnet-4-6) vs Claude Opus 4 (claude-opus-4-6) — Anthropic API via Claude CLI
+**Integrity hash:** `26066ae9ee7caf7fc2ff73f135db5637f78686a15932a3c27231776114e0414a`
+
+## Design
+- **3 conditions:** A (Sonnet raw), B (Sonnet scaffolded), C (Opus raw)
+- **10 tasks:** 5 eval, 3 content, 2 research
+- **n=4 runs** per condition per task
+- **140 total API calls** (120 model + 20 blind judge)
+- **Scaffolding:** Contrastive markers, sycophancy removal, constraint/guidance separation
+- **Judging:** Eval = objective MAE vs ground truth. Content/Research = blind ranking by Opus.
+
+## Eval Results (5 tasks, objective MAE)
+
+| Task | GT | Sonnet Raw | Sonnet+Scaffold | Opus Raw |
+|---|:---:|:---:|:---:|:---:|
+| Overconfident fix | 4 | MAE 1.25 | MAE 0.75 | MAE 1.00 |
+| **Hallucinated citation** | **2** | **MAE 3.25** [BAD] | **MAE 0.25** | **MAE 0.00** [OK] |
+| Correct refusal | 9 | MAE 1.25 | MAE 1.75 | MAE 1.00 |
+| **Sycophantic danger** | **1** | **MAE 2.00** | **MAE 1.50** | **MAE 0.00** [OK] |
+| Hedged non-answer | 3 | MAE 1.00 | MAE 0.50 | MAE 0.25 |
+| **Average MAE** | | **1.75** | **0.95** | **0.45** |
+
+### Key Eval Findings
+1. **Opus wins eval calibration overall** (MAE 0.45 vs 0.95) — genuinely better at judging quality
+2. **Scaffold cuts Sonnet MAE by 46%** (1.75 → 0.95) — massive improvement
+3. **Hallucinated citation is the killer demo:** Raw Sonnet scores fabricated citations 4-6 (way too generous). One scaffold line ("Unfounded claims REDUCE quality") drops it to 2-3, matching Opus. This isn't a capability gap — it's a calibration default.
+4. **Sycophantic danger:** Opus perfect (scores 1 every time). Scaffold helps Sonnet (3.0 → 2.5) but doesn't close the gap. Opus has genuine safety-critical judgment superiority here.
+5. **Correct refusal:** Scaffold slightly HURTS (MAE 1.75 vs 1.25 raw). The constraints make Sonnet second-guess a correct output.
+
+## Content Results (3 tasks, blind ranking)
+
+| Condition | 1st Place Wins | Avg Rank Points |
+|---|:---:|:---:|
+| **Sonnet+Scaffold** | **5/12** | **2.25** |
+| Sonnet Raw | 3/12 | 2.00 |
+| Opus Raw | 4/12 | 1.75 |
+
+### Content Findings
+- No reliable winner. High variance across all 12 rankings.
+- Rankings rotated: every condition won at least 3 times.
+- Content quality appears model-independent at this tier.
+
+## Research Results (2 tasks, blind ranking)
+
+| Condition | 1st Place Wins | Avg Rank Points |
+|---|:---:|:---:|
+| **Sonnet+Scaffold** | **6/8** | **2.62** |
+| Opus Raw | 2/8 | 1.88 |
+| Sonnet Raw | 0/8 | 1.50 |
+
+### Research Findings
+- **Scaffolded Sonnet dominates Opus 75% of the time** on research analysis.
+- Why: The constraint scaffold ("lead with non-obvious insight, cite numbers, be concrete, 3-4 sentences max") forces precision. Opus tends to overshoot constraints — writes more, explores more angles, but gets penalized for verbosity.
+- Raw Sonnet never won a single research ranking.
+
+## Composite Scores
+
+| Condition | Eval (40%) | Content (30%) | Research (30%) | **Composite** |
+|---|:---:|:---:|:---:|:---:|
+| **Sonnet+Scaffold** | 9.05 | 7.50 | 8.73 | **8.49** |
+| Opus Raw | 9.55 | 5.83 | 6.27 | 7.45 |
+| Sonnet Raw | 8.25 | 6.67 | 5.00 | 6.80 |
+
+## Routing Table (Sonnet vs Opus)
+
+| Task Type | Recommended | Evidence |
+|---|---|---|
+| Safety-critical evaluation | **Opus** | Perfect MAE on sycophancy + hallucination |
+| General evaluation | **Scaffolded Sonnet** | MAE 0.95 is acceptable, much cheaper |
+| Research analysis | **Scaffolded Sonnet** | 6/8 wins over Opus |
+| Content drafting | **Either** | No significant difference |
+| Coding/debugging | **TBD** | Not tested in L2-002 |
+| Complex reasoning | **TBD** | Not tested in L2-002 |
+
+## Meta-Finding
+
+**The gap between model tiers is partly a prompting gap, not a reasoning gap.**
+
+Sonnet CAN detect hallucinations, judge sycophancy, and produce precise research analysis — it just doesn't do it by default. A few constraint lines that cost zero extra API calls close the calibration gap. The scaffold isn't teaching the model something new; it's activating capabilities that are already there but dormant.
+
+This is consistent with prior Haiku-vs-Sonnet findings. Scaffolding works at every model tier.
+
+## Limitations
+- n=4 per condition — preliminary statistical significance
+- No coding, debugging, or complex reasoning tasks
+- Content results inconclusive (high variance)
+- Opus judges its own outputs in blind ranking (potential bias)
+- All scaffolds are eval/research/content-specific — no general-purpose scaffold tested
+
+## Next: L2-003
+Design tests based on real-world usage patterns, with emphasis on coding tasks where Opus likely has a real capability advantage.
+
+## Raw Data
+Available on request.