150d48d0ba
- Replace orbital spinner with 3x3 grid of blocks - Diagonal wave animation matches dithering aesthetic - Sharp squares, no rounded corners (brutalist) - Inline horizontal layout with monospace text - Consistent styling across all loading states The new loader evokes "tools being constructed" - fitting for a tool registry. Uses staggered opacity/scale animation creating a wave pattern across the grid. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
1112 lines
90 KiB
Markdown
1112 lines
90 KiB
Markdown
# 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.
|