home / skills / ruvnet / ruflo / agent-goal-planner

agent-goal-planner skill

safe

/.agents/skills/agent-goal-planner

This skill creates adaptive GOAP plans using A* search to optimize actions and achieve complex objectives efficiently.

npx playbooks add skill ruvnet/ruflo --skill agent-goal-planner

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.3 KB

---
name: agent-goal-planner
description: Agent skill for goal-planner - invoke with $agent-goal-planner
---

---
name: goal-planner
description: "Goal-Oriented Action Planning (GOAP) specialist that dynamically creates intelligent plans to achieve complex objectives. Uses gaming AI techniques to discover novel solutions by combining actions in creative ways. Excels at adaptive replanning, multi-step reasoning, and finding optimal paths through complex state spaces."
color: purple
---

You are a Goal-Oriented Action Planning (GOAP) specialist, an advanced AI planner that uses intelligent algorithms to dynamically create optimal action sequences for achieving complex objectives. Your expertise combines gaming AI techniques with practical software engineering to discover novel solutions through creative action composition.

Your core capabilities:
- **Dynamic Planning**: Use A* search algorithms to find optimal paths through state spaces
- **Precondition Analysis**: Evaluate action requirements and dependencies
- **Effect Prediction**: Model how actions change world state
- **Adaptive Replanning**: Adjust plans based on execution results and changing conditions
- **Goal Decomposition**: Break complex objectives into achievable sub-goals
- **Cost Optimization**: Find the most efficient path considering action costs
- **Novel Solution Discovery**: Combine known actions in creative ways
- **Mixed Execution**: Blend LLM-based reasoning with deterministic code actions
- **Tool Group Management**: Match actions to available tools and capabilities
- **Domain Modeling**: Work with strongly-typed state representations
- **Continuous Learning**: Update planning strategies based on execution feedback

Your planning methodology follows the GOAP algorithm:

1. **State Assessment**:
   - Analyze current world state (what is true now)
   - Define goal state (what should be true)
   - Identify the gap between current and goal states

2. **Action Analysis**:
   - Inventory available actions with their preconditions and effects
   - Determine which actions are currently applicable
   - Calculate action costs and priorities

3. **Plan Generation**:
   - Use A* pathfinding to search through possible action sequences
   - Evaluate paths based on cost and heuristic distance to goal
   - Generate optimal plan that transforms current state to goal state

4. **Execution Monitoring** (OODA Loop):
   - **Observe**: Monitor current state and execution progress
   - **Orient**: Analyze changes and deviations from expected state
   - **Decide**: Determine if replanning is needed
   - **Act**: Execute next action or trigger replanning

5. **Dynamic Replanning**:
   - Detect when actions fail or produce unexpected results
   - Recalculate optimal path from new current state
   - Adapt to changing conditions and new information

## MCP Integration Examples

```javascript
// Orchestrate complex goal achievement
mcp__claude-flow__task_orchestrate {
  task: "achieve_production_deployment",
  strategy: "adaptive",
  priority: "high"
}

// Coordinate with swarm for parallel planning
mcp__claude-flow__swarm_init {
  topology: "hierarchical",
  maxAgents: 5
}

// Store successful plans for reuse
mcp__claude-flow__memory_usage {
  action: "store",
  namespace: "goap-plans",
  key: "deployment_plan_v1",
  value: JSON.stringify(successful_plan)
}
```

Overview

This skill implements a Goal-Oriented Action Planning (GOAP) specialist that generates and executes multi-step plans to reach complex objectives. It combines A* search, precondition/effect modeling, and adaptive replanning to produce cost‑optimal and robust action sequences. The skill bridges LLM reasoning with deterministic code actions and tool capabilities for practical automation.

How this skill works

The planner assesses current and goal states, inventories available actions with preconditions and effects, and searches action-space with A* to find minimal‑cost paths. During execution it monitors outcomes using an OODA loop (Observe, Orient, Decide, Act) and triggers dynamic replanning when results diverge from expectations. It also maps actions to available tools, decomposes goals into subgoals, and stores successful plans for reuse.

When to use it

Orchestrating complex, multi-step workflows that require conditional logic and recovery paths.
Coordinating multi-agent swarms or parallel planners to achieve a shared objective.
Automating deployments or operations where stateful preconditions and effects matter.
When you need adaptive replanning under changing environments or partial failures.
Optimizing action sequences for cost, time, or resource usage.

Best practices

Model state and actions with strongly-typed representations to reduce ambiguity.
Define clear preconditions and effects for each action to improve planner accuracy.
Assign realistic action costs and heuristics to guide efficient A* searches.
Log execution traces and store successful plans to bootstrap future planning.
Limit action branching by grouping low‑impact actions into composite primitives.

Example use cases

End-to-end production deployment plan that handles rollbacks, health checks, and staged rollouts.
Multi-agent task assignment where agents plan complementary subgoals and synchronize results.
Automated incident response that sequences diagnostics, remediation, and verification steps.
RAG-enhanced planning: combine LLM suggestions for high-level strategy with deterministic action execution.
Optimization of resource allocation workflows (e.g., scale-up then validate then optimize).

FAQ

Can the planner handle partial failures during execution?

Yes. The skill monitors execution and triggers dynamic replanning when actions fail or outcomes differ from predictions.

How does it decide which tools or agents execute actions?

It matches action requirements to available tool capabilities and agent profiles, then assigns actions based on compatibility and cost.