ReasoningBank Intelligence
Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement. Use when building self-learning agents, optimizing workflows, or implementing meta-cognitive systems.
Install
npx skills add https://github.com/spencermarx/open-code-review/tree/main/.claude/skills/reasoningbank-intelligence
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install spencermarx-open-code-review@llmmart
git clone https://github.com/spencermarx/open-code-review.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole spencermarx/open-code-review collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
ReasoningBank Intelligence
What This Skill Does
Implements ReasoningBank's adaptive learning system for AI agents to learn from experience, recognize patterns, and optimize strategies over time. Enables meta-cognitive capabilities and continuous improvement.
Prerequisites
- agentic-flow v3.0.0-alpha.1+
- AgentDB v3.0.0-alpha.10+ (for persistence)
- Node.js 18+
Quick Start
import { ReasoningBank } from 'agentic-flow/reasoningbank';
// Initialize ReasoningBank
const rb = new ReasoningBank({
persist: true,
learningRate: 0.1,
adapter: 'agentdb' // Use AgentDB for storage
});
// Record task outcome
await rb.recordExperience({
task: 'code_review',
approach: 'static_analysis_first',
outcome: {
success: true,
metrics: {
bugs_found: 5,
time_taken: 120,
false_positives: 1
}
},
context: {
language: 'typescript',
complexity: 'medium'
}
});
// Get optimal strategy
const strategy = await rb.recommendStrategy('code_review', {
language: 'typescript',
complexity: 'high'
});
Core Features
1. Pattern Recognition
// Learn patterns from data
await rb.learnPattern({
pattern: 'api_errors_increase_after_deploy',
triggers: ['deployment', 'traffic_spike'],
actions: ['rollback', 'scale_up'],
confidence: 0.85
});
// Match patterns
const matches = await rb.matchPatterns(currentSituation);
2. Strategy Optimization
// Compare strategies
const comparison = await rb.compareStrategies('bug_fixing', [
'tdd_approach',
'debug_first',
'reproduce_then_fix'
]);
// Get best strategy
const best = comparison.strategies[0];
console.log(`Best: ${best.name} (score: ${best.score})`);
3. Continuous Learning
// Enable auto-learning from all tasks
await rb.enableAutoLearning({
threshold: 0.7, // Only learn from high-confidence outcomes
updateFrequency: 100 // Update models every 100 experiences
});
Advanced Usage
Meta-Learning
// Learn about learning
await rb.metaLearn({
observation: 'parallel_execution_faster_for_independent_tasks',
confidence: 0.95,
applicability: {
task_types: ['batch_processing', 'data_transformation'],
conditions: ['tasks_independent', 'io_bound']
}
});
Transfer Learning
// Apply knowledge from one domain to another
await rb.transferKnowledge({
from: 'code_review_javascript',
to: 'code_review_typescript',
similarity: 0.8
});
Adaptive Agents
// Create self-improving agent
class AdaptiveAgent {
async execute(task: Task) {
// Get optimal strategy
const strategy = await rb.recommendStrategy(task.type, task.context);
// Execute with strategy
const result = await this.executeWithStrategy(task, strategy);
// Learn from outcome
await rb.recordExperience({
task: task.type,
approach: strategy.name,
outcome: result,
context: task.context
});
return result;
}
}
Integration with AgentDB
// Persist ReasoningBank data
await rb.configure({
storage: {
type: 'agentdb',
options: {
database: './reasoning-bank.db',
enableVectorSearch: true
}
}
});
// Query learned patterns
const patterns = await rb.query({
category: 'optimization',
minConfidence: 0.8,
timeRange: { last: '30d' }
});
Performance Metrics
// Track learning effectiveness
const metrics = await rb.getMetrics();
console.log(`
Total Experiences: ${metrics.totalExperiences}
Patterns Learned: ${metrics.patternsLearned}
Strategy Success Rate: ${metrics.strategySuccessRate}
Improvement Over Time: ${metrics.improvement}
`);
Best Practices
- Record consistently: Log all task outcomes, not just successes
- Provide context: Rich context improves pattern matching
- Set thresholds: Filter low-confidence learnings
- Review periodically: Audit learned patterns for quality
- Use vector search: Enable semantic pattern matching
Troubleshooting
Issue: Poor recommendations
Solution: Ensure sufficient training data (100+ experiences per task type)
Issue: Slow pattern matching
Solution: Enable vector indexing in AgentDB
Issue: Memory growing large
Solution: Set TTL for old experiences or enable pruning
Learn More
- ReasoningBank Guide: agentic-flow/src/reasoningbank/README.md
- AgentDB Integration: packages/agentdb/docs/reasoningbank.md
- Pattern Learning: docs/reasoning/patterns.md
Files (open-code-review)
-
SKILL.md 4.7 KB
--- name: "ReasoningBank Intelligence" description: "Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement. Use when building self-learning agents, optimizing workflows, or implementing meta-cognitive systems." --- # ReasoningBank Intelligence ## What This Skill Does Implements ReasoningBank's adaptive learning system for AI agents to learn from experience, recognize patterns, and optimize strategies over time. Enables meta-cognitive capabilities and continuous improvement. ## Prerequisites - agentic-flow v3.0.0-alpha.1+ - AgentDB v3.0.0-alpha.10+ (for persistence) - Node.js 18+ ## Quick Start ```typescript import { ReasoningBank } from 'agentic-flow/reasoningbank'; // Initialize ReasoningBank const rb = new ReasoningBank({ persist: true, learningRate: 0.1, adapter: 'agentdb' // Use AgentDB for storage }); // Record task outcome await rb.recordExperience({ task: 'code_review', approach: 'static_analysis_first', outcome: { success: true, metrics: { bugs_found: 5, time_taken: 120, false_positives: 1 } }, context: { language: 'typescript', complexity: 'medium' } }); // Get optimal strategy const strategy = await rb.recommendStrategy('code_review', { language: 'typescript', complexity: 'high' }); ``` ## Core Features ### 1. Pattern Recognition ```typescript // Learn patterns from data await rb.learnPattern({ pattern: 'api_errors_increase_after_deploy', triggers: ['deployment', 'traffic_spike'], actions: ['rollback', 'scale_up'], confidence: 0.85 }); // Match patterns const matches = await rb.matchPatterns(currentSituation); ``` ### 2. Strategy Optimization ```typescript // Compare strategies const comparison = await rb.compareStrategies('bug_fixing', [ 'tdd_approach', 'debug_first', 'reproduce_then_fix' ]); // Get best strategy const best = comparison.strategies[0]; console.log(`Best: ${best.name} (score: ${best.score})`); ``` ### 3. Continuous Learning ```typescript // Enable auto-learning from all tasks await rb.enableAutoLearning({ threshold: 0.7, // Only learn from high-confidence outcomes updateFrequency: 100 // Update models every 100 experiences }); ``` ## Advanced Usage ### Meta-Learning ```typescript // Learn about learning await rb.metaLearn({ observation: 'parallel_execution_faster_for_independent_tasks', confidence: 0.95, applicability: { task_types: ['batch_processing', 'data_transformation'], conditions: ['tasks_independent', 'io_bound'] } }); ``` ### Transfer Learning ```typescript // Apply knowledge from one domain to another await rb.transferKnowledge({ from: 'code_review_javascript', to: 'code_review_typescript', similarity: 0.8 }); ``` ### Adaptive Agents ```typescript // Create self-improving agent class AdaptiveAgent { async execute(task: Task) { // Get optimal strategy const strategy = await rb.recommendStrategy(task.type, task.context); // Execute with strategy const result = await this.executeWithStrategy(task, strategy); // Learn from outcome await rb.recordExperience({ task: task.type, approach: strategy.name, outcome: result, context: task.context }); return result; } } ``` ## Integration with AgentDB ```typescript // Persist ReasoningBank data await rb.configure({ storage: { type: 'agentdb', options: { database: './reasoning-bank.db', enableVectorSearch: true } } }); // Query learned patterns const patterns = await rb.query({ category: 'optimization', minConfidence: 0.8, timeRange: { last: '30d' } }); ``` ## Performance Metrics ```typescript // Track learning effectiveness const metrics = await rb.getMetrics(); console.log(` Total Experiences: ${metrics.totalExperiences} Patterns Learned: ${metrics.patternsLearned} Strategy Success Rate: ${metrics.strategySuccessRate} Improvement Over Time: ${metrics.improvement} `); ``` ## Best Practices 1. **Record consistently**: Log all task outcomes, not just successes 2. **Provide context**: Rich context improves pattern matching 3. **Set thresholds**: Filter low-confidence learnings 4. **Review periodically**: Audit learned patterns for quality 5. **Use vector search**: Enable semantic pattern matching ## Troubleshooting ### Issue: Poor recommendations **Solution**: Ensure sufficient training data (100+ experiences per task type) ### Issue: Slow pattern matching **Solution**: Enable vector indexing in AgentDB ### Issue: Memory growing large **Solution**: Set TTL for old experiences or enable pruning ## Learn More - ReasoningBank Guide: agentic-flow/src/reasoningbank/README.md - AgentDB Integration: packages/agentdb/docs/reasoningbank.md - Pattern Learning: docs/reasoning/patterns.md
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.