┌──────────┐    ┌─────────────┐    ┌───────────┐    ┌──────────────┐    ┌────────────┐
│ Distill  │ ─► │ Decompose   │ ─► │   Solve   │ ─► │  Synthesize  │ ─► │   Verify   │
│          │    │             │    │           │    │              │    │            │
│ Extract  │    │ Break into  │    │ Work each │    │ Combine      │    │ Validate   │
│ relevant │    │ sub-problems│    │ sub-task  │    │ results      │    │ solution   │
│ context  │    │             │    │           │    │              │    │            │
└──────────┘    └─────────────┘    └───────────┘    └──────────────┘    └────────────┘
                                                                               │
                                                                    ┌──────────┴──────────┐
                                                                    │                     │
                                                                  PASS                  FAIL
                                                                    │                     │
                                                                    ▼                     ▼
                                                                Complete            Iterate with
                                                                                    feedback

/rlm-workflow

/rlm-workflow

Add rate limiting to our API:
- Per-user limits (100 req/min)
- Per-endpoint limits (configurable)
- Redis-backed for distributed deployments
- Should not add >10ms latency

---

## Example: Debugging a Complex Issue

### The Request

### The Execution

```markdown
## RLM Workflow Execution

### Phase 1: Initialize

**Problem Statement**: Intermittent 500 errors on checkout (~5% of requests)
**Complexity Assessment**: complex (debugging with unclear cause)
**Workflow Depth**: deep (3) - may need multiple investigation rounds
**Success Criteria**:
- Root cause identified
- Fix implemented
- Error rate drops to <0.1%
- No regression in checkout flow

### Phase 2: Distill

**Distillation Summary**:
- Original scope: Full codebase + 3 days of logs
- Distilled scope: checkout module + error logs + related services
- Compression: 95%

**Key Context Extracted**:
- Checkout flow: Cart → Payment → Inventory → Confirmation
- Error logs show: "Connection refused" to inventory service
- Pattern: Errors cluster around XX:00 and XX:30 (cron times?)
- Inventory service has 2 replicas behind load balancer

### Phase 3: Decompose

**Decomposition Strategy**: by-dependency (follow the error path)

| # | Sub-problem | Dependencies | Status |
|---|-------------|--------------|--------|
| 1 | Analyze error logs for patterns | none | done |
| 2 | Review inventory service health | 1 | done |
| 3 | Check connection pool settings | 2 | done |
| 4 | Examine cron job interference | 1 | done |
| 5 | Identify root cause | 1-4 | done |
| 6 | Implement fix | 5 | done |
| 7 | Verify fix in staging | 6 | done |

### Phase 4: Solve Sub-problems

#### Sub-problem 1: Analyze error logs
**Result**: Errors correlate with inventory sync cron at XX:00, XX:30

#### Sub-problem 2: Review inventory service health
**Result**: Service healthy, but CPU spikes to 100% during sync

#### Sub-problem 3: Check connection pool settings
**Result**: Pool size = 10, timeout = 5s, no retry logic

#### Sub-problem 4: Examine cron job interference
**Result**: Inventory sync locks database tables for 3-8 seconds

#### Sub-problem 5: Identify root cause
**Result**:
- Cron job locks tables
- Checkout queries timeout waiting for lock
- Connection pool exhausted
- New requests get "connection refused"

#### Sub-problem 6: Implement fix
**Result**:
- Add retry logic with exponential backoff
- Increase connection pool to 25
- Add circuit breaker for inventory service
- Optimize cron job to use smaller batches

#### Sub-problem 7: Verify fix in staging
**Result**: Simulated load during cron - 0 errors

### Phase 5: Synthesize

**Root Cause**: Inventory sync cron job causes database lock contention,
exhausting connection pool during high-traffic checkout periods.

**Fix**: Multi-layered resilience
1. Retry logic catches transient failures
2. Larger pool handles burst
3. Circuit breaker prevents cascade
4. Optimized cron reduces lock duration

### Phase 6: Verify

**Tier 1**: PASS - Code compiles, tests pass
**Tier 2**: PASS - Unit tests for retry logic, circuit breaker
**Tier 3**: PASS - Staging load test during cron = 0 errors

**Overall Confidence**: 88%

### Final Output

**Status**: VERIFIED
**Root Cause**: Database lock contention from inventory sync cron
**Fix**: Retry logic + larger pool + circuit breaker + optimized cron
**Expected Result**: Error rate <0.1%

# Good
"Add user authentication with JWT tokens, refresh token rotation,
and secure httpOnly cookies. Must work with existing User model."

# Vague
"Add auth to the app"

# Good
"Success means: tests pass, latency <100ms, no security warnings from OWASP ZAP"

# Vague
"Should work well"

# Good
"Must use existing Redis instance, cannot add new dependencies,
needs to be backwards compatible with v2 API"

# Missing context
"Add caching"

/rlm-workflow

[Describe your complex problem here]

Include:
- What you're trying to achieve
- Any constraints or requirements
- How you'll know it's successful

@misc{zhang2025recursivelanguagemodels,
      title={Recursive Language Models}, 
      author={Alex L. Zhang and Tim Kraska and Omar Khattab},
      year={2025},
      eprint={2512.24601},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2512.24601}, 
}