goal-seeking-agent-pattern

What this skill does

# Goal-Seeking Agent Pattern Skill

## 1. What Are Goal-Seeking Agents?

Goal-seeking agents are autonomous AI agents that execute multi-phase objectives by:

1. **Understanding High-Level Goals**: Accept natural language objectives without explicit step-by-step instructions
2. **Planning Execution**: Break goals into phases with dependencies and success criteria
3. **Autonomous Execution**: Make decisions and adapt behavior based on intermediate results
4. **Self-Assessment**: Evaluate progress against success criteria and adjust approach
5. **Resilient Operation**: Handle failures gracefully and explore alternative solutions

### Core Characteristics

**Autonomy**: Agents decide HOW to achieve goals, not just follow prescriptive steps

**Adaptability**: Adjust strategy based on runtime conditions and intermediate results

**Goal-Oriented**: Focus on outcomes (what to achieve) rather than procedures (how to achieve)

**Multi-Phase**: Complex objectives decomposed into manageable phases with dependencies

**Self-Monitoring**: Track progress, detect failures, and course-correct autonomously

### Distinction from Traditional Agents

| Traditional Agent             | Goal-Seeking Agent            |
| ----------------------------- | ----------------------------- |
| Follows fixed workflow        | Adapts workflow to context    |
| Prescriptive steps            | Outcome-oriented objectives   |
| Human intervention on failure | Autonomous recovery attempts  |
| Single-phase execution        | Multi-phase with dependencies |
| Rigid decision tree           | Dynamic strategy adjustment   |

### When Goal-Seeking Makes Sense

Goal-seeking agents excel when:

- **Problem space is large**: Many possible paths to success
- **Context varies**: Runtime conditions affect optimal approach
- **Failures are expected**: Need autonomous recovery without human intervention
- **Objectives are clear**: Success criteria well-defined but path is flexible
- **Multi-step complexity**: Requires coordination across phases with dependencies

### When to Avoid Goal-Seeking

Use traditional agents or scripts when:

- **Single deterministic path**: Only one way to achieve goal
- **Latency-critical**: Need fastest possible execution (no decision overhead)
- **Safety-critical**: Human verification required at each step
- **Simple workflow**: Complexity of goal-seeking exceeds benefit
- **Audit requirements**: Need deterministic, reproducible execution

## 2. When to Use This Pattern

### Problem Indicators

Use goal-seeking agents when you observe these patterns:

#### Pattern 1: Workflow Variability

**Indicators**:

- Same objective requires different approaches based on context
- Manual decisions needed at multiple points
- "It depends" answers when mapping workflow

**Example**: Release workflow that varies by:

- Environment (staging vs production)
- Change type (hotfix vs feature)
- Current system state (healthy vs degraded)

**Solution**: Goal-seeking agent evaluates context and adapts workflow

#### Pattern 2: Multi-Phase Complexity

**Indicators**:

- Objective requires 3-5+ distinct phases
- Phases have dependencies (output of phase N feeds phase N+1)
- Parallel execution opportunities exist
- Success criteria differ per phase

**Example**: Data pipeline with phases:

1. Data collection (multiple sources, parallel)
2. Transformation (depends on collection results)
3. Validation (depends on transformation output)
4. Publishing (conditional on validation pass)

**Solution**: Goal-seeking agent orchestrates phases, handles dependencies

#### Pattern 3: Autonomous Recovery Needed

**Indicators**:

- Failures are expected and recoverable
- Multiple retry/fallback strategies exist
- Human intervention is expensive or slow
- Can verify success programmatically

**Example**: CI diagnostic workflow:

- Test failures (retry with different approach)
- Environment issues (reconfigure and retry)
- Dependency conflicts (resolve and rerun)

**Solution**: Goal-seeking agent tries strategies until success or escalation

#### Pattern 4: Adaptive Decision Making

**Indicators**:

- Need to evaluate trade-offs at runtime
- Multiple valid solutions with different characteristics
- Optimization objectives (speed vs quality vs cost)
- Context-dependent best practices

**Example**: Fix agent pattern matching:

- QUICK mode for obvious issues
- DIAGNOSTIC mode for unclear problems
- COMPREHENSIVE mode for complex solutions

**Solution**: Goal-seeking agent selects strategy based on problem analysis

#### Pattern 5: Domain Expertise Required

**Indicators**:

- Requires specialized knowledge to execute
- Multiple domain-specific tools/approaches
- Best practices vary by domain
- Coordination of specialized sub-agents

**Example**: AKS SRE automation:

- Azure-specific operations (ARM, CLI)
- Kubernetes expertise (kubectl, YAML)
- Networking knowledge (CNI, ingress)
- Security practices (RBAC, Key Vault)

**Solution**: Goal-seeking agent with domain expertise coordinates specialized actions

### Decision Framework

Use this 5-question framework to evaluate goal-seeking applicability:

#### Question 1: Is the objective well-defined but path flexible?

**YES if**:

- Clear success criteria exist
- Multiple valid approaches
- Runtime context affects optimal path

**NO if**:

- Only one correct approach
- Path is deterministic
- Success criteria ambiguous

**Example YES**: "Ensure AKS cluster is production-ready" (many paths, clear criteria)
**Example NO**: "Run specific kubectl command" (one path, prescriptive)

#### Question 2: Are there multiple phases with dependencies?

**YES if**:

- Objective naturally decomposes into 3-5+ phases
- Phase outputs feed subsequent phases
- Some phases can execute in parallel
- Failures in one phase affect downstream phases

**NO if**:

- Single-phase execution sufficient
- No inter-phase dependencies
- Purely sequential with no branching

**Example YES**: Data pipeline (collect → transform → validate → publish)
**Example NO**: Format code with ruff (single atomic operation)

#### Question 3: Is autonomous recovery valuable?

**YES if**:

- Failures are common and expected
- Multiple recovery strategies exist
- Human intervention is expensive/slow
- Can verify success automatically

**NO if**:

- Failures are rare edge cases
- Manual investigation always required
- Safety-critical (human verification needed)
- Cannot verify success programmatically

**Example YES**: CI diagnostic workflow (try multiple fix strategies)
**Example NO**: Deploy to production (human approval required)

#### Question 4: Does context significantly affect approach?

**YES if**:

- Environment differences change strategy
- Current system state affects decisions
- Trade-offs vary by situation (speed vs quality vs cost)
- Domain-specific best practices apply

**NO if**:

- Same approach works for all contexts
- No environmental dependencies
- No trade-off decisions needed

**Example YES**: Fix agent (quick vs diagnostic vs comprehensive based on issue)
**Example NO**: Generate UUID (context-independent)

#### Question 5: Is the complexity justified?

**YES if**:

- Problem is repeated frequently (2+ times/week)
- Manual execution takes 30+ minutes
- High value from automation
- Maintenance cost is acceptable

**NO if**:

- One-off or rare problem
- Quick manual execution (< 5 minutes)
- Simple script suffices
- Maintenance cost exceeds benefit

**Example YES**: CI failure diagnosis (frequent, time-consuming, high value)
**Example NO**: One-time data migration (rare, script sufficient)

### Decision Matrix

| All 5 YES | Use Goal-Seeking Agent |
| 4 YES, 1 NO | Probably use Goal-Seeking Agent |
| 3 YES, 2 NO | Consider simpler agent or hybrid |
| 2 YES, 3 NO | Traditional agent likely better |
| 0-1 YES | Script or simple automation |

## 3. Architecture Pattern

### Component Architecture

Goal-seeking agents have four core components:

```python
# Component 1: Goal Definition
class GoalDefi