MCP Standards

This project provides an intelligent planning and goal execution agent system based on ReasoningBank closed-loop learning. It supports dynamic planning, adaptive replanning, and continuous learning and improvement, and is suitable for complex multi-step task deployment scenarios

Developer tools Knowledge management and memory #Intelligent planning #Goal execution #Continuous learning #Adaptive agent .Python

rating : 2 points

downloads : 7.0K

update time : 2025-10-23

Open Site

What is a Claude-Flow reasoning agent?

The Claude-Flow reasoning agent is an AI-based intelligent task planning and execution system that combines goal-oriented action planning (GOAP) technology from game AI with a closed-loop learning mechanism. It can autonomously formulate execution plans for complex tasks and continuously learn and improve during the execution process.

How to use the reasoning agent?

The reasoning agent can be invoked through a simple command-line tool. The system will automatically analyze task requirements, formulate the optimal execution plan, and continuously learn and optimize with the support of the ReasoningBank memory system.

Applicable scenarios

It is particularly suitable for automated tasks that require multi-step planning, have complex dependencies, and need adaptive adjustment, such as application deployment, system configuration, and complex testing scenarios.

Main features

Dynamic planning ability

Automatically find the optimal execution path using the A* search algorithm and adjust the plan in real-time according to the task status.

Precondition analysis

Intelligently analyze the preconditions required for each execution step to ensure the feasibility of the plan.

Adaptive replanning

Automatically re-formulate the plan when encountering obstacles during execution to ensure task completion.

Goal decomposition

Automatically split complex goals into an executable sequence of subtasks.

Closed-loop learning

Learn from each execution through the ReasoningBank system to continuously improve performance.

Memory integration

Optimize current decisions using past experience to avoid repeating mistakes.

Advantages

Intelligent planning: Automatically handle complex dependencies without manually specifying each step.

Continuous improvement: The more executions, the better the system performs.

High success rate: A 26% increase in success rate compared to traditional methods.

Cost optimization: A 25% reduction in resource consumption.

Fast learning: A 3.2-fold increase in learning speed.

Cross-domain migration: Patterns learned in one domain can be applied to similar scenarios.

Limitations

Requires an initial learning phase: New tasks need several executions to reach optimal performance.

Memory dependency: Performance depends on the accumulation of historical execution records.

Complex configuration: Advanced functions require an understanding of relevant concepts to be fully utilized.

Resource requirements: The memory system requires storage space to maintain execution history.

How to use

Environment initialization

First, initialize the reasoning agent environment, which will automatically set up the ReasoningBank memory system and learning capabilities.

Enable learning mode

Configure environment variables to enable the system's learning and memory functions.

Execute tasks

Use the goal planner to execute complex tasks. The system will automatically formulate and execute the optimal plan.

Monitoring and improvement

The system will automatically record execution results and learn from them. It will perform better in similar tasks next time.

Usage examples

Complex application deployment

Deploy a complete application stack that requires a database, cache, message queue, and front-end service.

Multi-environment migration

Migrate an application from a development environment to a production environment, including data migration and configuration updates.

System fault recovery

Automatically diagnose and repair complex system faults.

Frequently Asked Questions

What is the difference between a reasoning agent and a traditional script?

How many executions does the system need to reach optimal performance?

How to view the system's learning results?

Can I customize the planning algorithm?

How does the system handle execution failures?

Related resources

Technical documentation

Detailed technical implementation documentation and architecture description

Demo cases

Real-time demonstration comparing the effects of traditional methods and reasoning agents

Performance benchmarks

Detailed performance test data and benchmark comparison results

Problem feedback

Submit problems or feature suggestions encountered during use

🚀 Reasoning Agents for Claude-Flow

This project offers reasoning and goal - planning agents that utilize ReasoningBank's closed - loop learning to deliver intelligent, adaptive task execution with continuous improvement.

🚀 Quick Start

1. Initialize with Reasoning Agents

claude-flow init --agent reasoning

This command will:

Set up the ReasoningBank memory system.
Configure reasoning agents.
Initialize learning capabilities.

2. Use Reasoning Agents

# Via claude-flow (when integrated)
claude-flow agent run goal-planner "Complex deployment task"

# Via agentic-flow directly
npx agentic-flow --agent goal-planner --task "Multi-step task"

3. Enable Learning Mode

export REASONINGBANK_ENABLED=true
export AGENTIC_FLOW_TRAINING=true

✨ Features

🎯 goal-planner

Goal-Oriented Action Planning (GOAP) specialist

It uses gaming AI techniques to dynamically create intelligent plans to achieve complex objectives. It excels at adaptive replanning, multi - step reasoning, and finding optimal paths through complex state spaces.

Key Features:

Dynamic Planning: A* search algorithms for optimal paths.
Precondition Analysis: Evaluate action requirements.
Effect Prediction: Model state changes.
Adaptive Replanning: Adjust based on execution results.
Goal Decomposition: Break complex objectives into sub - goals.

Best for:

Complex multi - step deployments.
Tasks with many dependencies.
High - level goals needing decomposition.
Adaptive planning scenarios.

Usage:

claude-flow init --agent reasoning
# Or directly with agentic-flow:
npx agentic-flow --agent goal-planner --task "Deploy application with prerequisites"

🎯 sublinear-goal-planner

Sub - linear complexity goal planning

It is a specialized version optimized for large - scale state spaces with sub - linear time complexity.

Best for:

Large - scale systems.
Performance - critical planning.
Massive state spaces.

📦 Integration with ReasoningBank

All reasoning agents integrate with ReasoningBank for:

RETRIEVE: Pull relevant memories from past executions.
JUDGE: Evaluate success/failure of trajectories.
DISTILL: Extract learnable patterns.
CONSOLIDATE: Merge and optimize memory.

📊 Performance Benefits

Based on ReasoningBank benchmarks:

+26% success rate (70% → 88%).
-25% token usage (cost savings).
3.2x learning velocity (faster improvement).
0% → 95% success over 5 iterations.

🔧 Technical Details

Architecture

User Task
    ↓
[goal-planner analyzes]
    ↓
ReasoningBank.retrieve() → Get relevant memories
    ↓
Plan generation (A* search)
    ↓
Execute with monitoring (OODA loop)
    ↓
ReasoningBank.judge() → Evaluate success
    ↓
ReasoningBank.distill() → Extract learnings
    ↓
Store for future use

Configuration

Memory Database

Default location: .swarm/memory.db

Configure via:

export REASONINGBANK_DB_PATH="/custom/path/memory.db"

Retrieval Settings

export REASONINGBANK_K=3              # Top-k memories to retrieve
export REASONINGBANK_MIN_CONFIDENCE=0.5  # Minimum confidence threshold

💻 Usage Examples

1. Multi - Step Planning

npx agentic-flow --agent goal-planner \
  --task "Deploy application" \
  --enable-memory \
  --memory-domain "deployment"

2. Learning from Failures

The system automatically learns from both successes and failures:

Failed attempts store "what went wrong".
Successful attempts store "what worked".
Future tasks benefit from both.

3. Cross - Domain Transfer

Patterns learned in one domain can transfer to similar tasks:

Authentication patterns → Authorization patterns.
Deployment patterns → Migration patterns.
Testing strategies → Debugging strategies.

📚 Documentation

REASONING - AGENTS.md: Detailed technical documentation.
REASONINGBANK - DEMO.md: Live demo comparison.
REASONINGBANK - CLI - INTEGRATION.md: CLI integration guide.
REASONINGBANK - BENCHMARK.md: Performance benchmarks.

🚧 Future Agents (Coming Soon)

The following reasoning agents are planned for future releases:

adaptive - learner: Learn from experience and improve over time.
pattern - matcher: Recognize patterns and transfer proven solutions.
memory - optimizer: Maintain memory system health and performance.
context - synthesizer: Build rich situational awareness from multiple sources.
experience - curator: Ensure high - quality learnings through rigorous curation.
reasoning - optimized: Meta - reasoning orchestrator coordinating all reasoning agents.