# Cascading Complexity and Logical Fragility How adding more steps, conditions, and branches can transform reliable systems into brittle ones—and strategies to maintain robustness. --- ## The Conjunction Fallacy in Tool Plans The conjunction fallacy (Linda problem) demonstrates that humans intuitively believe: ``` P(A ∧ B) > P(A) "Linda is a bank teller AND active in the feminist movement" seems more likely than "Linda is a bank teller" ``` This is mathematically impossible. Adding conditions can only maintain or reduce probability: ``` P(A ∧ B) ≤ P(A) ``` **Applied to tool plans:** ``` Plan A: 3 steps ───────────────────────────────────────────────────── Step 1 (P=0.95) → Step 2 (P=0.92) → Step 3 (P=0.90) P(success) = 0.95 × 0.92 × 0.90 = 0.787 (78.7%) Plan B: 8 steps ───────────────────────────────────────────────────── Step 1 (P=0.95) → Step 2 (P=0.92) → Step 3 (P=0.90) → Step 4 (P=0.93) → Step 5 (P=0.91) → Step 6 (P=0.94) → Step 7 (P=0.89) → Step 8 (P=0.92) P(success) = 0.95 × 0.92 × 0.90 × 0.93 × 0.91 × 0.94 × 0.89 × 0.92 = 0.478 (47.8%) Plan C: 20 steps (each P=0.95) ───────────────────────────────────────────────────── P(success) = 0.95^20 = 0.358 (35.8%) ``` **More steps = more conjunction = lower probability of complete success** --- ## The Fragility Spectrum ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ ROBUST ◄─────────────────────────────────────────────────────► FRAGILE │ │ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ 1 step │ │ 3 steps │ │ 8 steps │ │15 steps │ │25 steps │ │ │ │ P=0.95 │ │ P=0.78 │ │ P=0.48 │ │ P=0.28 │ │ P=0.13 │ │ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │ │ │ Simple Standard Complex Enterprise Ambitious │ │ task workflow pipeline process fantasy │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## Types of Fragility in Cascading Systems ### 1. Sequential Fragility Each step depends on the previous. One failure breaks the chain. ``` ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ A │───►│ B │───►│ C │───►│ D │───►│ E │ └─────┘ └─────┘ └──┬──┘ └─────┘ └─────┘ │ ✗ FAIL │ ▼ Everything after C is blocked ``` ### 2. Conditional Fragility Branching logic compounds failure modes. ``` ┌─────┐ │ A │ └──┬──┘ │ ┌────────┼────────┐ │ │ │ ▼ ▼ ▼ ┌─────┐ ┌─────┐ ┌─────┐ │if X │ │if Y │ │if Z │ └──┬──┘ └──┬──┘ └──┬──┘ │ │ │ ▼ ▼ ▼ ┌─────┐ ┌─────┐ ┌─────┐ │ B │ │ C │ │ D │ └─────┘ └─────┘ └─────┘ Each branch is its own failure domain. Condition evaluation itself can fail. Wrong branch selection = cascading wrongness. ``` ### 3. Accumulation Fragility Errors compound. Small inaccuracies become large ones. ``` Step 1: Extract data → 2% error rate Step 2: Transform data → 3% error rate Step 3: Analyze data → 2% error rate Step 4: Generate report → 1% error rate But errors compound: ┌─────────────────────────────────────────────────────────────────┐ │ │ │ Input: 1000 records │ │ │ │ After Step 1: 980 correct, 20 errors introduced │ │ After Step 2: 951 correct, 29 errors (some errors on errors) │ │ After Step 3: 932 correct, 19 new errors + propagated errors │ │ After Step 4: 923 correct, 9 new errors + all previous │ │ │ │ Final accuracy: ~77% (not 92% as naive multiplication suggests)│ │ │ │ Some errors AMPLIFY through the pipeline. │ │ │ └─────────────────────────────────────────────────────────────────┘ ``` ### 4. Context Fragility Information loss at each handoff. ``` ┌────────────────────────────────────────────────────────────────────────────┐ │ │ │ Original user intent: "Find cheap flights to Tokyo in cherry blossom │ │ season, preferably window seat, vegetarian meal" │ │ │ │ Step 1 output: { destination: "Tokyo", dates: "March-April" } │ │ ↓ │ │ Lost: "cheap", "window seat", "vegetarian" │ │ │ │ Step 2 output: { flights: [...] } │ │ ↓ │ │ Lost: "cherry blossom season" nuance │ │ │ │ Step 3 output: { booking: "confirmed" } │ │ ↓ │ │ User gets: expensive flight, middle seat, regular meal │ │ │ │ Each step loses context. By the end, original intent is unrecognizable. │ │ │ └────────────────────────────────────────────────────────────────────────────┘ ``` --- ## Occam's Razor Applied to Tool Plans > "When multiple explanations exist, the one requiring the fewest assumptions > is the most likely to be true." **Applied to tool orchestration:** ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ Task: "Convert this CSV to a formatted Excel report" │ │ │ │ PLAN A (Occam's Razor): │ │ ─────────────────────── │ │ ┌─────────────────────────┐ │ │ │ csv-to-xlsx-converter │ ← 1 tool, 1 assumption │ │ │ (handles formatting) │ │ │ └─────────────────────────┘ │ │ │ │ Assumptions: 1 │ │ P(success) ≈ 0.95 │ │ │ │ │ │ PLAN B (Over-engineered): │ │ ───────────────────────── │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │ │ csv-parser │──►│ data-cleaner │──►│ formatter │──►│ xlsx-writer │ │ │ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ │ │ │ │ Assumptions: 4 │ │ P(success) ≈ 0.95^4 = 0.81 │ │ │ │ │ │ PLAN C (Kitchen sink): │ │ ────────────────────── │ │ csv-parser → validator → type-inferrer → null-handler → normalizer │ │ → enricher → formatter → styler → chart-generator → xlsx-writer │ │ │ │ Assumptions: 10 │ │ P(success) ≈ 0.95^10 = 0.60 │ │ │ │ ═══════════════════════════════════════════════════════════════════════ │ │ Occam says: Use Plan A unless you have specific evidence you need more. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## The Determinism vs. Flexibility Tradeoff ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ DETERMINISTIC FLEXIBLE │ │ ───────────── ──────── │ │ │ │ ┌─────────────────────────┐ ┌─────────────────────────────────────┐ │ │ │ │ │ │ │ │ │ A → B → C → D │ │ A ──┬──► B ──┬──► D │ │ │ │ │ │ │ │ │ │ │ │ Same path every time │ │ └──► C ──┘ │ │ │ │ Predictable │ │ │ │ │ │ Testable │ │ Path varies by context │ │ │ │ Auditable │ │ Adaptive │ │ │ │ │ │ Handles edge cases │ │ │ │ But: Brittle to edge │ │ │ │ │ │ cases │ │ But: Unpredictable │ │ │ │ │ │ Hard to debug │ │ │ └─────────────────────────┘ └─────────────────────────────────────┘ │ │ │ │ │ │ THE LEARNED PATHWAY APPROACH: │ │ ───────────────────────────── │ │ │ │ Start flexible, converge toward deterministic based on usage: │ │ │ │ Week 1 Week 4 Week 12 │ │ ─────── ─────── ──────── │ │ │ │ A ─┬─► B A ─┬─► B A ────► B │ │ │ │ (85%) (99%) │ │ ├─► C │ │ │ │ │ └─► C │ │ │ └─► D (15%) ▼ │ │ C │ │ (99%) │ │ Many paths Dominant path Near-deterministic │ │ explored emerges with escape hatch │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## Strategies for Managing Fragility ### 1. Minimize Conjunction (Fewer Steps) ``` Before: 8 steps ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │ 1 │►│ 2 │►│ 3 │►│ 4 │►│ 5 │►│ 6 │►│ 7 │►│ 8 │ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ After: Combine into 3 "super-tools" ┌─────────┐ ┌─────────┐ ┌─────────┐ │ 1,2,3 │►│ 4,5,6 │►│ 7,8 │ └─────────┘ └─────────┘ └─────────┘ Same capability, fewer failure points. ``` ### 2. Parallel Over Sequential ``` Sequential (fragile): Parallel (robust): A → B → C → D A ──┬──► B ──┐ │ │ If B fails, C and D blocked. ├──► C ──┼──► E │ │ └──► D ──┘ If B fails, C and D still run. E gets partial results. ``` ### 3. Checkpoints and Recovery ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │ │ │ A │────►│ B │────►│ C │────►│ D │────►│ E │ │ │ └───┘ └─┬─┘ └───┘ └─┬─┘ └───┘ │ │ │ │ │ │ ▼ ▼ │ │ [CHECKPOINT] [CHECKPOINT] │ │ Save state Save state │ │ │ │ If D fails: │ │ • Don't restart from A │ │ • Resume from checkpoint after B │ │ • Retry only C → D → E │ │ │ │ Reduces effective conjunction from 5 steps to 3 steps max. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 4. Fallback Chains ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ Instead of: │ │ ┌─────────────┐ │ │ │ Tool A │──── FAIL ────► Pipeline stops │ │ └─────────────┘ │ │ │ │ Use: │ │ ┌─────────────┐ │ │ │ Tool A │──── FAIL ────┐ │ │ └─────────────┘ │ │ │ ▼ │ │ ┌─────────────┐ │ │ │ Tool A' │──── FAIL ────┐ │ │ │ (fallback) │ │ │ │ └─────────────┘ ▼ │ │ ┌─────────────┐ │ │ │ Tool A'' │ │ │ │ (last resort)│ │ │ └─────────────┘ │ │ │ │ P(at least one works) = 1 - P(all fail) │ │ = 1 - (0.05)³ │ │ = 0.999875 │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 5. Graceful Degradation ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ Full plan (ideal): │ │ A → B → C → D → E → F → G │ │ Output: Comprehensive report with charts, analysis, and recommendations │ │ │ │ Degraded plan (if D fails): │ │ A → B → C → [skip D] → E' → F' → G' │ │ Output: Report with analysis and recommendations (no charts) │ │ │ │ Minimal plan (if B and D fail): │ │ A → [skip B] → C' → [skip D] → E'' → G'' │ │ Output: Basic summary with key findings │ │ │ │ ═══════════════════════════════════════════════════════════════════════ │ │ Something is better than nothing. │ │ Define acceptable degradation levels upfront. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 6. Learned Pathway Weighting (K-Factor) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ Track which paths users actually take: │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Path A → B → C → D: Used 847 times (84.7%) ◄── K = 0.847 │ │ │ │ Path A → B → X → D: Used 102 times (10.2%) │ │ │ │ Path A → Y → C → D: Used 38 times ( 3.8%) │ │ │ │ Path A → B → C → Z: Used 13 times ( 1.3%) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ When generating new plans, weight toward learned paths: │ │ │ │ P(suggest path) = base_probability × (1 + K × learning_weight) │ │ │ │ As K → 1.0 for a path, it becomes effectively deterministic. │ │ But the escape hatch remains for the 0.1% edge cases. │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ K = 0.50: Suggest learned path, but explore alternatives │ │ │ │ K = 0.85: Strongly prefer learned path │ │ │ │ K = 0.99: Almost deterministic, rare deviation │ │ │ │ K = 1.00: Locked in (manual override to change) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## The Fragility Budget Every plan has a "fragility budget"—the maximum acceptable failure probability. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ FRAGILITY BUDGET ALLOCATION │ │ │ │ Acceptable failure rate: 10% (P(success) ≥ 90%) │ │ │ │ Budget equation: │ │ P(success) = P₁ × P₂ × P₃ × ... × Pₙ ≥ 0.90 │ │ │ │ If each step has P = 0.98: │ │ 0.98ⁿ ≥ 0.90 │ │ n ≤ 5.2 │ │ │ │ Maximum steps: 5 │ │ │ │ ───────────────────────────────────────────────────────────────────────── │ │ │ │ If each step has P = 0.95: │ │ 0.95ⁿ ≥ 0.90 │ │ n ≤ 2.0 │ │ │ │ Maximum steps: 2 (!) │ │ │ │ ───────────────────────────────────────────────────────────────────────── │ │ │ │ To allow more steps, you must: │ │ • Increase individual step reliability │ │ • Add fallbacks (changes the math) │ │ • Accept higher failure rate │ │ • Use parallel branches │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## When More Steps ARE Justified Not all conjunction is bad. More steps are justified when: ### 1. Each step genuinely adds value ``` Good: A (fetch) → B (parse) → C (analyze) → D (format) Each step transforms data in a necessary way. Bad: A (fetch) → B (validate fetch) → C (log fetch) → D (cache fetch) → E (parse) Steps B, C, D are defensive overhead that could be internal to A. ``` ### 2. Steps have independent failure recovery ``` A → [checkpoint] → B → [checkpoint] → C → [checkpoint] → D Each checkpoint isolates failure. Effective conjunction = max(steps between checkpoints), not total steps. ``` ### 3. The domain genuinely requires it ``` Medical diagnosis: symptoms → differential → tests → results → diagnosis → treatment You can't skip steps. The conjunction is inherent to the domain. Accept the fragility, but add maximum safeguards. ``` ### 4. Parallel execution changes the math ``` ┌── B ──┐ │ │ A ───┼── C ──┼─── E │ │ └── D ──┘ P(success) = P(A) × P(at least one of B,C,D) × P(E) = P(A) × (1 - P(B fails) × P(C fails) × P(D fails)) × P(E) = 0.95 × (1 - 0.05³) × 0.95 = 0.95 × 0.999875 × 0.95 = 0.902 Much better than sequential B → C → D! ``` --- ## Pathway Learning Algorithms Beyond simple "most used" frequency counting, here are algorithms for learning and suggesting pathways: ### 1. Multi-Armed Bandit (Explore vs Exploit) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ EPSILON-GREEDY STRATEGY │ │ ─────────────────────── │ │ │ │ ε = exploration rate (e.g., 0.1 = 10% exploration) │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Roll random(0,1) │ │ │ │ │ │ │ │ │ ├───► < ε ───► EXPLORE: Pick random path │ │ │ │ │ (discover potentially better routes) │ │ │ │ │ │ │ │ │ └───► ≥ ε ───► EXPLOIT: Pick best known path │ │ │ │ (use what's worked before) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Over time, ε decays: │ │ │ │ Week 1: ε = 0.30 ███████████░░░░░░░░░░░░░░░░░░░ 30% exploration │ │ Week 4: ε = 0.15 █████░░░░░░░░░░░░░░░░░░░░░░░░░ 15% exploration │ │ Week 12: ε = 0.05 ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 5% exploration │ │ Week 52: ε = 0.01 ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1% exploration │ │ │ │ System converges to best paths while always leaving door open. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 2. Upper Confidence Bound (UCB) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ UCB ALGORITHM: Optimism in the face of uncertainty │ │ ────────────── │ │ │ │ Score(path) = average_success + C × √(ln(total_runs) / path_runs) │ │ ─────────────── ───────────────────────────────── │ │ exploitation exploration bonus │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Path A: 100 runs, 92% success │ │ │ │ Score = 0.92 + 0.5 × √(ln(500)/100) = 0.92 + 0.12 = 1.04 │ │ │ │ │ │ │ │ Path B: 5 runs, 80% success │ │ │ │ Score = 0.80 + 0.5 × √(ln(500)/5) = 0.80 + 0.78 = 1.58 │ │ │ │ ▲ │ │ │ │ │ │ │ │ │ Path B wins! It has high uncertainty, deserves exploration. │ │ │ │ │ │ │ │ After 50 more runs of Path B (now 70% success): │ │ │ │ Score = 0.70 + 0.5 × √(ln(550)/55) = 0.70 + 0.24 = 0.94 │ │ │ │ │ │ │ │ Now Path A wins. Exploration revealed B is actually worse. │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Automatically balances exploration of uncertain paths vs exploitation. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 3. Thompson Sampling (Bayesian) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ THOMPSON SAMPLING: Sample from belief distributions │ │ ───────────────── │ │ │ │ Each path has a Beta distribution: Beta(successes + 1, failures + 1) │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Path A: 90 successes, 10 failures │ │ │ │ Beta(91, 11) │ │ │ │ │ │ │ │ Probability density: │ │ │ │ ▄▄▄▄ │ │ │ │ ▄██████▄ │ │ │ │ ▄██████████▄ │ │ │ │ ──────▄██████████████▄────── │ │ │ │ 0.7 0.8 0.9 1.0 │ │ │ │ ▲ │ │ │ │ tight peak (confident) │ │ │ │ │ │ │ │ Path B: 4 successes, 1 failure │ │ │ │ Beta(5, 2) │ │ │ │ │ │ │ │ Probability density: │ │ │ │ ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ │ │ │ │ ▄████████████████████▄ │ │ │ │ ▄████████████████████████▄ │ │ │ │ ────────────────────────── │ │ │ │ 0.2 0.4 0.6 0.8 1.0 │ │ │ │ ▲ │ │ │ │ wide spread (uncertain) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Selection: Sample one value from each distribution, pick highest. │ │ │ │ Path A sample: 0.88 │ │ Path B sample: 0.73 ← Sometimes samples high due to uncertainty! │ │ │ │ Naturally explores uncertain options proportional to their potential. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 4. Contextual Bandits (User/Query Aware) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ CONTEXTUAL BANDITS: Path selection depends on context │ │ ────────────────── │ │ │ │ Context features: │ │ • User type (developer, marketer, analyst) │ │ • Query complexity (simple, medium, complex) │ │ • Time of day (morning, afternoon, evening) │ │ • Previous success rate with this user │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Model learns: P(success | path, context) │ │ │ │ │ │ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ │ │ Context: {user: "developer", complexity: "high"} │ │ │ │ │ │ │ │ │ │ │ │ Path A (thorough): P(success) = 0.89 ◄── BEST FOR THIS │ │ │ │ │ │ Path B (quick): P(success) = 0.62 CONTEXT │ │ │ │ │ │ Path C (balanced): P(success) = 0.78 │ │ │ │ │ └─────────────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ │ │ Context: {user: "marketer", complexity: "low"} │ │ │ │ │ │ │ │ │ │ │ │ Path A (thorough): P(success) = 0.71 │ │ │ │ │ │ Path B (quick): P(success) = 0.94 ◄── BEST FOR THIS │ │ │ │ │ │ Path C (balanced): P(success) = 0.85 CONTEXT │ │ │ │ │ └─────────────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Different users/contexts get different "best" paths automatically. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 5. Collaborative Filtering (Similar Users) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ COLLABORATIVE FILTERING: "Users like you also used..." │ │ ─────────────────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ User-Path Success Matrix: │ │ │ │ │ │ │ │ Path A Path B Path C Path D Path E │ │ │ │ User 1: ✓ ✗ ✓ ✓ ? │ │ │ │ User 2: ✓ ✓ ✗ ✓ ✓ │ │ │ │ User 3: ✗ ✓ ✓ ✗ ✓ │ │ │ │ User 4: ✓ ✗ ✓ ✓ ? ◄── Current │ │ │ │ │ │ │ │ User 4 is most similar to User 1 (matching pattern). │ │ │ │ User 1 succeeded with Path E? → Recommend Path E to User 4. │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Matrix factorization finds latent features: │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ User 4 latent vector: [0.8, 0.2, 0.9, 0.1] │ │ │ │ Path E latent vector: [0.7, 0.3, 0.8, 0.2] │ │ │ │ │ │ │ │ Predicted score = dot_product = 0.56 + 0.06 + 0.72 + 0.02 = 1.36 │ │ │ │ │ │ │ │ High score → Recommend! │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 6. Q-Learning (Reinforcement Learning) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ Q-LEARNING: Learn value of state-action pairs │ │ ────────── │ │ │ │ Q(state, action) = expected future reward │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ State = (current_step, accumulated_context, user_feedback) │ │ │ │ Action = which tool to call next │ │ │ │ Reward = +1 (task success), -0.1 (per step), -1 (failure) │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ │ State: "just fetched webpage" │ │ │ │ │ │ │ │ │ │ │ │ Q-values: │ │ │ │ │ │ → parse-html: Q = 0.82 ◄── Highest, select │ │ │ │ │ │ → extract-text: Q = 0.71 │ │ │ │ │ │ → screenshot: Q = 0.45 │ │ │ │ │ │ → validate: Q = 0.23 │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ Update rule (after each execution): │ │ │ │ │ │ │ │ Q(s,a) ← Q(s,a) + α × [reward + γ×max(Q(s',a')) - Q(s,a)] │ │ │ │ ▲ ▲ │ │ │ │ learning rate discount future rewards │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Learns optimal policy through trial and error over time. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 7. Monte Carlo Tree Search (MCTS) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ MCTS: Simulate many possible futures, pick best path │ │ ──── │ │ │ │ Four phases: SELECT → EXPAND → SIMULATE → BACKPROPAGATE │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ ┌─────┐ │ │ │ │ │START│ visits: 1000 │ │ │ │ └──┬──┘ │ │ │ │ ┌───────┼───────┐ │ │ │ │ ▼ ▼ ▼ │ │ │ │ ┌───┐ ┌───┐ ┌───┐ │ │ │ │ │ A │ │ B │ │ C │ SELECT: Follow UCB down tree │ │ │ │ │420│ │380│ │200│ (balance visits & wins) │ │ │ │ └─┬─┘ └─┬─┘ └───┘ │ │ │ │ │ │ │ │ │ │ ▼ ▼ │ │ │ │ ┌───┐ ┌───┐ ┌───┐ │ │ │ │ │A1 │ │B1 │ │B2 │ EXPAND: Add new node │ │ │ │ │350│ │200│ │180│ │ │ │ │ └───┘ └─┬─┘ └───┘ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌───┐ │ │ │ │ │???│ SIMULATE: Random rollout to terminal │ │ │ │ │NEW│ → Success! │ │ │ │ └───┘ │ │ │ │ │ │ │ │ BACKPROPAGATE: Update all ancestors with result │ │ │ │ B1: 200 → 201 wins │ │ │ │ B: 380 → 381 wins │ │ │ │ START: 1000 → 1001 visits │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ After N simulations, pick path with most visits (most confident). │ │ Great for planning multiple steps ahead. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 8. Genetic Algorithms (Evolve Pathways) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ GENETIC ALGORITHM: Evolve better pathways over generations │ │ ───────────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Generation 1: Random pathways │ │ │ │ ───────────────────────────────── │ │ │ │ Path 1: [A, B, C, D, E] fitness: 0.65 │ │ │ │ Path 2: [A, C, B, E, D] fitness: 0.72 │ │ │ │ Path 3: [B, A, D, C, E] fitness: 0.58 │ │ │ │ Path 4: [A, B, D, C, E] fitness: 0.81 ◄── Best │ │ │ │ │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ │ │ │ │ SELECTION: Keep top 50% │ │ │ │ Path 4: [A, B, D, C, E] ✓ │ │ │ │ Path 2: [A, C, B, E, D] ✓ │ │ │ │ │ │ │ │ CROSSOVER: Combine successful paths │ │ │ │ Parent 1: [A, B, | D, C, E] │ │ │ │ Parent 2: [A, C, | B, E, D] │ │ │ │ ↓ │ │ │ │ Child: [A, B, | B, E, D] (take prefix from P1, suffix from P2)│ │ │ │ │ │ │ │ MUTATION: Random tweaks (5% chance per gene) │ │ │ │ [A, B, B, E, D] → [A, B, F, E, D] (B mutated to F) │ │ │ │ │ │ │ │ ───────────────────────────────────────────────────────────────── │ │ │ │ │ │ │ │ Generation 10: │ │ │ │ Best path: [A, B, D, E] fitness: 0.94 │ │ │ │ (Evolved to drop unnecessary step C!) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Discovers optimal pathways through evolution, not explicit programming. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 9. Inverse Reinforcement Learning (Learn from Experts) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ INVERSE RL: Infer reward function from expert demonstrations │ │ ────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Observe expert (power user) behavior: │ │ │ │ │ │ │ │ Expert Session 1: A → B → D → E (skipped C) │ │ │ │ Expert Session 2: A → B → D → E (skipped C) │ │ │ │ Expert Session 3: A → B → C → D → E (included C for edge case) │ │ │ │ Expert Session 4: A → B → D → E (skipped C) │ │ │ │ │ │ │ │ Inferred reward function: │ │ │ │ • High reward for: A → B, B → D, D → E │ │ │ │ • Low/negative reward for: B → C (usually skipped) │ │ │ │ • Context-dependent: C only when specific conditions met │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Now apply learned reward to new users: │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ New user at step B: │ │ │ │ │ │ │ │ Options: │ │ │ │ B → C: reward = -0.2 (experts usually skip) │ │ │ │ B → D: reward = +0.8 (experts prefer) ◄── SUGGEST │ │ │ │ B → E: reward = +0.1 (sometimes works) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ System learns "what experts value" rather than explicit rules. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 10. Bayesian Optimization (Efficient Exploration) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ BAYESIAN OPTIMIZATION: Smart exploration with Gaussian Processes │ │ ──────────────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Model uncertainty about unexplored paths: │ │ │ │ │ │ │ │ Success │ │ │ │ Rate │ │ │ │ │ │ │ │ │ 1.0┤ ╭───╮ │ │ │ │ │ ╭─┤ ├─╮ ← Uncertainty band │ │ │ │ 0.8┤ ● ╭─┤ │ ├╮ │ │ │ │ │ ╱ ╲ ╭─┤ │ │ │ ╲ │ │ │ │ 0.6┤ ╱ ╲ ╱ │ │ │ │ ╲ ● = observed data │ │ │ │ │ ╱ ╲╱ ╰─┤ │ ├───╲ │ │ │ │ 0.4┤ ● ● ╰───┴───╯ ╲ │ │ │ │ │ ╱ ╲● │ │ │ │ 0.2┤ ╱ │ │ │ │ │ ● │ │ │ │ 0.0┼──────────────────────────────────────────────── │ │ │ │ Path Path Path Path Path Path Path Path │ │ │ │ A B C D E F G H │ │ │ │ │ │ │ │ Acquisition function picks next path to try: │ │ │ │ • Expected Improvement (EI) │ │ │ │ • Upper Confidence Bound (UCB) │ │ │ │ • Probability of Improvement (PI) │ │ │ │ │ │ │ │ → Try Path E: High uncertainty + decent predicted mean │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Minimizes trials needed to find optimal path. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 11. Hierarchical Clustering (Path Families) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ HIERARCHICAL CLUSTERING: Group similar paths into families │ │ ─────────────────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ ┌───────────┴───────────┐ │ │ │ │ │ │ │ │ │ │ ┌───────┴───────┐ ┌───────┴───────┐ │ │ │ │ │ │ │ │ │ │ │ │ ┌─────┴─────┐ ┌─────┴─────┐ │ ┌─────┴─────┐ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ [A→B→D→E] [A→B→D→F] [A→B→C→E] [A→C→D→E] [B→A→D→E] [B→C→D→E] │ │ │ │ │ │ │ │ ════════════════════════════════════════════════════════════════ │ │ │ │ "Direct paths" "C-inclusive" "B-first variants" │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Benefits: │ │ • When "Direct paths" cluster works, prefer it as a family │ │ • If it fails, try "C-inclusive" family │ │ • Don't randomly jump between distant clusters │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Selection strategy: │ │ │ │ │ │ │ │ 1. Pick best cluster (based on cluster-level success rate) │ │ │ │ 2. Pick best path within cluster (based on path-level success) │ │ │ │ 3. If cluster fails repeatedly, move to sibling cluster │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### 12. Recency-Weighted Success (Time Decay) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ RECENCY WEIGHTING: Recent outcomes matter more than old ones │ │ ──────────────── │ │ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Path A history: │ │ │ │ │ │ │ │ Time Outcome Raw Weight Decayed Weight (λ=0.95) │ │ │ │ ───── ─────── ────────── ────────────────────── │ │ │ │ t-30 Success 1.0 0.95^30 = 0.21 │ │ │ │ t-20 Success 1.0 0.95^20 = 0.36 │ │ │ │ t-10 Failure 1.0 0.95^10 = 0.60 │ │ │ │ t-5 Success 1.0 0.95^5 = 0.77 │ │ │ │ t-2 Success 1.0 0.95^2 = 0.90 │ │ │ │ t-1 Failure 1.0 0.95^1 = 0.95 │ │ │ │ t-0 Success 1.0 0.95^0 = 1.00 │ │ │ │ │ │ │ │ Naive success rate: 5/7 = 71% │ │ │ │ Recency-weighted: (0.21+0.36+0.77+0.90+1.00) / total = 68% │ │ │ │ (recent failure pulls it down) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Why it matters: │ │ • Tools get updated (newer versions may be better/worse) │ │ • User preferences drift │ │ • External APIs change behavior │ │ • Old successes may not predict current performance │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ### Algorithm Comparison Matrix ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ ALGORITHM SELECTION GUIDE │ │ │ │ ┌──────────────────┬───────────┬───────────┬───────────┬─────────────┐ │ │ │ Algorithm │ Best For │ Data Req │ Compute │ Convergence │ │ │ ├──────────────────┼───────────┼───────────┼───────────┼─────────────┤ │ │ │ ε-Greedy │ Simple │ Low │ O(1) │ Slow │ │ │ │ UCB │ Balanced │ Low │ O(1) │ Medium │ │ │ │ Thompson │ Uncertain │ Low │ O(1) │ Fast │ │ │ │ Contextual │ Personlzd │ Medium │ O(n) │ Medium │ │ │ │ Collaborative │ Multi-usr │ High │ O(n²) │ Medium │ │ │ │ Q-Learning │ Sequences │ High │ O(s×a) │ Slow │ │ │ │ MCTS │ Planning │ Low │ O(sims) │ Fast │ │ │ │ Genetic │ Discovery │ Medium │ O(pop×gen)│ Variable │ │ │ │ Inverse RL │ Experts │ Medium │ O(demos) │ Fast │ │ │ │ Bayesian Opt │ Expensive │ Low │ O(n³) │ Very Fast │ │ │ │ Clustering │ Families │ Medium │ O(n²) │ N/A │ │ │ │ Recency │ Drift │ Low │ O(1) │ Adaptive │ │ │ └──────────────────┴───────────┴───────────┴───────────┴─────────────┘ │ │ │ │ Hybrid approaches often work best: │ │ • UCB + Recency for drifting environments │ │ • Contextual + Collaborative for personalization │ │ • MCTS + Q-Learning for complex sequential decisions │ │ • Clustering + Thompson for structured exploration │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## Summary: The Fragility Principles ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ 1. CONJUNCTION REDUCES PROBABILITY │ │ Every additional step multiplies failure risk. │ │ P(A ∧ B) ≤ P(A) │ │ │ │ 2. OCCAM'S RAZOR APPLIES │ │ Prefer fewer assumptions. Fewer steps = fewer assumptions. │ │ Don't add steps "just in case." │ │ │ │ 3. DETERMINISM EMERGES FROM LEARNING │ │ Don't design deterministic upfront. │ │ Let frequently-used paths become deterministic through K-factor. │ │ │ │ 4. BUDGET YOUR FRAGILITY │ │ Know your acceptable failure rate. │ │ Calculate maximum steps accordingly. │ │ │ │ 5. PARALLEL > SEQUENTIAL │ │ When possible, run steps in parallel. │ │ Changes multiplication to "at least one succeeds" math. │ │ │ │ 6. CHECKPOINTS BOUND FAILURE │ │ Divide long chains into recoverable segments. │ │ Effective fragility = longest segment, not total length. │ │ │ │ 7. FALLBACKS COMPOUND SUCCESS │ │ P(at least one works) = 1 - P(all fail) │ │ Three 95% tools as fallbacks = 99.99% effective reliability. │ │ │ │ 8. GRACEFUL DEGRADATION > TOTAL FAILURE │ │ Define "good enough" outputs at each degradation level. │ │ Something is better than nothing. │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## Visualizing the Tradeoff ``` CAPABILITY ▲ │ │ ╭────────────────────╮ │ ╱ ╲ │ ╱ OPTIMAL ZONE ╲ │ ╱ (enough steps for ╲ │ ╱ capability, not so ╲ │ ╱ many that it breaks) ╲ │ ╱ ╲ │ ╱ ╲ │ ╱ ╲ │ ╱ ┌─────────────────────────────────┐ │ ╱ │ │ │╱ │ FRAGILITY CLIFF │ │ │ (too many steps, │ │ │ system breaks more │ │ │ than it works) │ │ │ │ │ └─────────────────────────────────┘ │ └──────────────────────────────────────────► STEPS 1 3 5 8 12 20 50 Robust ◄───────────────────► Fragile ``` The goal: **Stay in the optimal zone**—enough capability to solve the problem, not so many steps that the system becomes unreliable.