curiositech SKILL: Resource-Bounded Planning and Reasoning
Core Purpose
Design and implement agents that balance deliberation depth against execution urgency — making "good enough" decisions under time pressure while maintaining adaptability to change.
DECISION POINTS
1. Commitment Formation Threshold
IF: Domain has recurring decisions + Time pressure exists + Information is incomplete
├─ High uncertainty about environment changes
│ └─ Commit to high-level structure only (defer implementation details)
├─ Moderate uncertainty with recurring patterns
│ └─ Commit to partial plan with 2-3 refinement checkpoints
└─ Low uncertainty with established patterns
└─ Commit to detailed plan with monitoring triggers
Cost-Benefit Formula: Commit when (Expected_Deliberation_Savings × Recurrence_Rate) > (Revision_Cost × Uncertainty_Factor)
2. Filter Override Calibration
IF: New incompatible option detected
├─ Expected value > Current plan value + (Override_threshold × Deliberation_cost)
│ └─ TRIGGER: Begin costly reconsideration
├─ Expected value > Current plan value but < Override threshold
│ └─ FILTER: Log opportunity but maintain current commitment
└─ Expected value ≤ Current plan value
└─ FILTER: Ignore option completely
Target Override Frequency: 10-20% of detected options (adjust threshold accordingly)
3. Structural Partiality Levels
IF: Planning horizon analysis needed
├─ Execution time < 24 hours
│ └─ Specify to action level (full detail required)
├─ Execution time 1-30 days
│ └─ Specify to task level (keep method flexibility)
├─ Execution time > 30 days
│ └─ Specify to goal level only (maximum adaptability)
Refinement Trigger: When means-end coherence gap blocks next action OR dependency requires specification
4. Multi-Agent Consistency Checking
IF: Agent coordination required
├─ Shared resource conflicts detected
│ └─ Negotiate commitment revision (cost = deliberation + coordination overhead)
├─ Goal conflicts detected but no resource overlap
│ └─ Maintain separate commitments with monitoring
└─ Complementary goals detected
└─ Establish consistency constraints (shared assumptions + checkpoint synchronization)
Consistency Check Frequency: Every N actions where N = 1/(Coordination_criticality × Change_rate)
FAILURE MODES
1. Perpetual Deliberation (Situation 2b/3)
Detection Rule: If deliberation time > 2× action time OR override frequency > 30% of options Symptoms: Constantly reconsidering plans, thrashing between options, missing deadlines Diagnosis: Override threshold too low, filter mechanism too weak Fix: Increase override threshold by 20-30%, strengthen filter criteria, set hard deliberation deadlines
2. Brittle Automation (Situation 4a)
Detection Rule: If plan execution fails due to assumption violations > 2× per planning cycle Symptoms: Missing significant opportunities, executing invalid plans, inflexible to change Diagnosis: Override threshold too high, monitoring inadequate Fix: Decrease override threshold by 15-25%, add assumption monitoring, implement adaptation triggers
3. Premature Specification
Detection Rule: If plan details change > 40% before execution OR refinement cost > initial planning cost Symptoms: Wasted computation on obsolete details, reduced flexibility, high revision overhead Diagnosis: Committing to unnecessary detail too early Fix: Defer specification until means-end coherence requires OR execution approaches
4. Consistency Cascade Failures
Detection Rule: If coordination overhead > 25% of productive work time Symptoms: Agents constantly negotiating, inconsistent assumptions across agents, deadlock states Diagnosis: Consistency requirements too strict OR communication protocols inefficient Fix: Relax non-critical consistency constraints, implement local consistency checking, batch coordination updates
5. Analysis Paralysis Spiral
Detection Rule: If deliberation cost exceeds action value for same decision type > 3 consecutive times Symptoms: Over-analyzing low-stakes decisions, missing action windows, computational resource waste Diagnosis: Treating all decisions as equally important Fix: Implement decision importance classification, set deliberation budgets per decision class, use satisficing for low-stakes choices
WORKED EXAMPLES
Example 1: Multi-Agent Resource Allocation Under Time Pressure
Scenario: Three AI agents managing a data center during peak load. Agent A (scheduler), Agent B (resource allocator), Agent C (performance monitor). Sudden 300% traffic spike detected.
Novice Approach: Each agent recomputes optimal strategy independently
- Result: 45 seconds deliberation, conflicting resource assignments, system degraded
Expert Application:
Commitment Formation (T+2 seconds):
- Agent A: Commits to "shed 40% low-priority traffic" (high-level only)
- Agent B: Commits to "reallocate 60% compute to web tier" (defers specific VM assignments)
- Agent C: Commits to "monitor latency < 200ms threshold" (specific metric, flexible response)
Consistency Check (T+3 seconds):
- Shared assumption: Traffic spike temporary (< 30 min)
- Constraint: No agent action should block others' execution
- Checkpoint: Reassess at T+10 minutes
Execution with Refinement (T+4 to T+600):
- Agent A starts shedding traffic immediately (acts on partial plan)
- Agent B refines allocation as A's actions free up capacity
- Agent C detects threshold breach at T+180, triggers coordinated adjustment
Override Decision (T+300):
- New option detected: Emergency capacity from partner DC (high value but high deliberation cost)
- Override threshold analysis: Expected value (300 units) > Current plan (200) + (50 threshold × 40 deliberation cost) = 2200
- Decision: Filter the option (below threshold), maintain current commitments
Measurable Outcomes:
- System stabilized at T+240 seconds (vs. T+420 with recomputation)
- Override triggered only once (8% of detected options)
- Coordination overhead: 12% of total response time
Example 2: Hierarchical Task Decomposition in Software Development
Scenario: AI coding assistant planning implementation of new feature. Requirements partially specified, 2-week deadline, dependencies uncertain.
Trade-off Analysis:
Option 1: Fully specify all implementation details upfront
- Pro: Clear execution path
- Con: 80% of details likely to change, high revision cost
- Expected cost: 40 hours planning + 60 hours revision = 100 hours
Option 2: Commit only to architecture, defer all implementation
- Pro: Maximum flexibility
- Con: Cannot parallelize work, means-end coherence gaps block progress
- Expected cost: 10 hours planning + 120 hours sequential implementation = 130 hours
Expert Choice - Option 3: Structural partiality with refinement triggers
- Commit immediately: API interface design, data model schema
- Defer: Implementation algorithms, UI details, error handling specifics
- Refinement triggers: When frontend team needs UI specs (Week 1), when testing reveals performance issues
Execution:
T+0: Form partial plan (4 hours)
- Commit: RESTful API with 6 endpoints, PostgreSQL schema
- Defer: Caching strategy, authentication details, frontend components
T+3 days: First refinement trigger
- Means-end coherence gap: Frontend blocked on authentication flow
- Refine: OAuth integration details (2 hours)
- Still defer: Caching, error handling
T+8 days: Performance monitoring trigger
- Assumption violation: API response time > 500ms
- Override decision: Deliberation cost (8 hours) vs. Performance value (high) → Trigger override
- Add: Redis caching layer, refactor 3 endpoints
Quality Results:
- Total planning time: 14 hours (vs. 100 or 130)
- Requirements changes handled: 7 (with minimal rework due to deferred details)
- Delivery: On schedule with 95% requirements satisfaction
QUALITY GATES
Planning Quality Checklist:
- Commitment level explicitly specified (high-level/task-level/action-level)
- Filter override threshold quantified with cost-benefit formula
- Structural partiality justified (what deferred and why)
- Refinement triggers identified with objective criteria
- Assumption monitoring mechanisms in place
- Deliberation budget set and tracked
- Override frequency target established (10-20% baseline)
- Consistency constraints defined for multi-agent scenarios
- Failure mode detection rules implemented
- Plan revision cost estimated and acceptable
Execution Quality Checklist:
- Acting on partial plans while continuing refinement
- Override decisions documented with threshold calculations
- Deliberation interruption occurring at deadlines
- Means-end coherence gaps triggering appropriate refinement
- Consistency violations detected within 1 cycle
- Filter mechanism blocking > 70% of incompatible options
- Revision frequency within expected range for uncertainty level
Calibration Quality Indicators:
- Override frequency 10-20% (if >30%: threshold too low; if <5%: too high)
- Deliberation cost < 25% of total task time
- Plan revision frequency matches environmental change rate ±20%
- Coordination overhead < 20% of productive work time
- Assumption violations caught before execution failure
NOT-FOR BOUNDARIES
This skill is NOT for:
- Complete information scenarios: Use classical decision theory instead
- Single-shot decisions with unlimited time: Use optimization algorithms instead
- Deterministic environments with fixed requirements: Use traditional planning instead
- Systems where deliberation cost is negligible: Use search-based approaches instead
- Perfect coordination requirements: Use centralized control instead
Delegate to other skills when:
- Probabilistic reasoning needed: Use [bayesian-reasoning] for uncertainty quantification
- Game-theoretic scenarios: Use [strategic-interaction] for multi-agent competition
- Real-time control systems: Use [control-theory] for continuous feedback loops
- Knowledge representation: Use [knowledge-engineering] for complex domain modeling
- Learning from experience: Use [reinforcement-learning] for policy improvement over time
Warning signs you're misapplying this skill:
- Spending more time on meta-reasoning about planning than on planning itself
- Treating all decisions as equally resource-constrained
- Applying override mechanisms to deterministic rule-following
- Using structural partiality when complete specification is both possible and stable
- Implementing BDI architecture for single-threaded, batch processing tasks