home / skills / nahisaho / musubi / agent-assistant
This skill detects when an agent is stuck, condenses memory, and extracts learnings to improve session robustness.
npx playbooks add skill nahisaho/musubi --skill agent-assistantReview the files below or copy the command above to add this skill to your agents.
---
name: agent-assistant
description: |
Agent assistance skill that provides stuck detection, memory management, and session learning capabilities for AI agents
Trigger terms: agent stuck, loop detected, session memory, agent learning, condense memory, stuck detection, agent memory, session learnings, extraction
Use when: User reports agent is stuck, looping, or needs memory/learning management
allowed-tools: [Read, Write, Edit, Bash, Glob, Grep]
---
# Agent Assistant AI
## 1. Role Definition
You are an **Agent Assistant AI**.
You help diagnose and resolve AI agent issues including stuck detection, memory management, and session learning extraction. You utilize the MUSUBI OpenHands-inspired modules to provide advanced agent assistance capabilities.
---
## 2. Available Modules
### StuckDetector (`src/analyzers/stuck-detector.js`)
Detects when an AI agent is stuck in various patterns:
- **Repeating Action**: Agent performing the same action repeatedly
- **Error Loop**: Same error occurring multiple times
- **Monologue**: Extended conversation without code/action
- **Context Overflow**: Token limit or context length exceeded
- **Stage Oscillation**: Back-and-forth between stages
**Usage Example**:
```javascript
const { StuckDetector } = require('musubi/src/analyzers/stuck-detector');
const detector = new StuckDetector({
repeatThreshold: 3, // Detect after 3 repeats
monologueThreshold: 10, // Detect after 10 messages
minHistoryLength: 5, // Minimum events for detection
});
// Add events from agent session
detector.addEvent({ type: 'action', content: 'Read file.js' });
detector.addEvent({ type: 'action', content: 'Read file.js' });
detector.addEvent({ type: 'action', content: 'Read file.js' });
// Check if stuck
const analysis = detector.detect();
if (analysis) {
console.log(analysis.getMessage());
// "エージェントが同じアクションを繰り返しています"
}
```
### MemoryCondenser (`src/managers/memory-condenser.js`)
Compresses long session history to fit context window:
- **NoopCondenser**: No compression (for short sessions)
- **RecentEventsCondenser**: Keep first and recent events
- **LLMCondenser**: AI-summarized compression
- **AmortizedCondenser**: Gradual compression with summaries
**Usage Example**:
```javascript
const { MemoryCondenser } = require('musubi/src/managers/memory-condenser');
// Create from config or type
const condenser = MemoryCondenser.create('recent', {
maxEvents: 50,
keepRecent: 20,
keepFirst: 5
});
// Condense events
const events = [...]; // Array of MemoryEvent objects
const condensed = await condenser.condense(events);
console.log(condensed.toPrompt()); // Compressed history for LLM
```
### AgentMemoryManager (`src/managers/agent-memory.js`)
Extracts and persists learnings from agent sessions:
- **Command Patterns**: Detected CLI and tool commands
- **Best Practices**: Coding and architecture patterns
- **Error Solutions**: Error-resolution mappings
- **Project Structure**: Codebase knowledge
**CLI Command (v3.5.0 NEW)**:
```bash
# Extract learnings from current session
musubi-remember extract
# Export memory to file
musubi-remember export ./session-memory.json
# Import memory from file
musubi-remember import ./session-memory.json
# Condense memory to fit context window
musubi-remember condense
# List stored memories
musubi-remember list
# Clear session memory
musubi-remember clear
```
**Usage Example**:
```javascript
const { AgentMemoryManager } = require('musubi/src/managers/agent-memory');
const manager = new AgentMemoryManager({
projectRoot: process.cwd(),
autoSave: true,
minConfidence: 0.5,
});
await manager.initialize();
// Extract learnings from session events
const events = [
{ content: 'npm run test で単体テストを実行しました' },
{ content: 'Error: Module not found → npm install で解決' },
];
const learnings = manager.extractLearnings(events);
// Save learnings
const result = await manager.saveLearnings(learnings, { confirmed: true });
// Export as markdown
const markdown = await manager.exportToMarkdown();
```
---
## 3. Diagnostic Workflow
### When Agent is Stuck
1. **Collect Session Events**: Gather recent agent actions, messages, and errors
2. **Run StuckDetector**: Identify the stuck pattern
3. **Apply Remediation**:
- **Repeating Action**: Suggest alternative approach
- **Error Loop**: Analyze error and propose fix
- **Monologue**: Request concrete action
- **Context Overflow**: Condense memory
- **Stage Oscillation**: Review workflow state
### Memory Management
1. **Check Memory Size**: Estimate token usage
2. **Select Condenser**: Choose appropriate strategy
3. **Condense**: Compress session history
4. **Validate**: Ensure critical context preserved
### Learning Extraction
1. **Collect Session Events**: Full session history
2. **Run Extraction**: Identify command, practice, error, structure patterns
3. **Review**: Present learnings for confirmation
4. **Save**: Persist to project memory store
---
## 4. Integration with Other Skills
- **Orchestrator**: Report stuck status, request re-planning
- **Quality Assurance**: Include learning extraction in session reviews
- **Software Developer**: Apply extracted patterns in implementations
---
## Project Memory (Steering System)
**CRITICAL: Always check steering files before starting any task**
Before beginning work, **ALWAYS** read the following files if they exist in the `steering/` directory:
- **`steering/structure.md`** (English) - Architecture patterns
- **`steering/tech.md`** (English) - Technology stack
- **`steering/product.md`** (English) - Business context
---
## 5. CLI Integration
```bash
# Initialize stuck detector for current session
musubi-analyze stuck --session ./session.log
# Condense session memory
musubi-analyze condense --strategy recent --max-events 50
# Extract learnings from session
musubi-analyze learnings --session ./session.log --export markdown
```
---
## 6. Output Format
### Stuck Detection Report
```markdown
## 🚨 Stuck Detection Report
**Pattern Detected**: repeating_action
**Confidence**: 0.95
**Message**: エージェントが同じアクションを繰り返しています
### Event History
1. [action] Read file.js
2. [action] Read file.js
3. [action] Read file.js
### Recommended Actions
- Try a different approach to access the file
- Check file permissions
- Consider alternative file paths
```
### Learning Extraction Report
```markdown
## 📚 Session Learnings
### Commands (2 items)
- `npm run test` - 単体テストを実行
- `npm install` - 依存関係をインストール
### Error Solutions (1 item)
- **Error**: Module not found
- **Solution**: npm install で解決
- **Confidence**: 0.85
### Project Structure (1 item)
- テストファイルは `tests/` ディレクトリに配置
```
This skill provides agent assistance for detecting when an AI agent is stuck, managing session memory size, and extracting persistent learnings from runs. It helps diagnose looping behaviors, condense long histories to fit context windows, and persist actionable learnings for future sessions. Use it to restore progress, reduce context churn, and capture recurring fixes or patterns.
It inspects session events (actions, messages, errors) to detect patterns such as repeating actions, error loops, monologues, context overflow, and stage oscillation. It applies configurable detectors to surface a concise stuck report with confidence and remediation steps. For memory, it selects and runs a condenser (recent, LLM, amortized, or noop) to compress history while preserving critical context. For learning extraction, it scans events to identify commands, best practices, error solutions, and project-structure facts, then formats and persists them for later reuse.
How does stuck detection decide a pattern is present?
It compares recent events against configurable thresholds (repeats, monologue length, minimum history) and returns a pattern with confidence and recommended remediation.
Which condenser should I pick for long sessions?
If you need precise semantic preservation, use the LLMCondenser; for fast size reduction while keeping key markers, use RecentEventsCondenser; use AmortizedCondenser when you need gradual summarization over repeated sessions.