菜单
Enable LLM agents to improve continuously during deployment by constructing structured experience libraries through self-reflection on successes and failures—achieving 23% improvement on reasoning without gradient-based parameter updates or external training.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill flex-continuous-agent-evolution命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Convert arXiv papers into ready-to-use agent skills using category-aware extraction. First classifies the paper into one or more of 11 research categories, then applies a specialized extraction pipeline for each category — because different types of papers produce different types of usable knowledge. A single paper can yield multiple skills if it spans categories. Use this skill whenever the user wants to turn a paper into a skill, extract practical techniques from research, build a skill library from papers, convert arXiv papers into reusable agent instructions, or batch-process multiple papers into skills. Also trigger when someone asks about extracting actionable knowledge from papers, making research practical for LLM agents, or systematically converting academic contributions into structured agent capabilities.
Establish regret bounds for behavior cloning with discretized actions combining statistical error and quantization error terms. Prove smoothness requirements for safe quantizer design, show that learning-based quantizers fail these requirements, and propose model-based augmentation to reduce error dependence from H² to H.
Dynamically allocate LoRA ranks per-layer during fine-tuning instead of using fixed uniform ranks. Learn optimal rank for each layer and subject via variational framework with discretized exponential distribution, reducing memory footprint while maintaining fidelity and text-alignment.
基于 SOC 职业分类
正在显示 SKILL.md
| name | flex-continuous-agent-evolution |
| title | FLEX: Continuous Agent Evolution via Forward Learning from Experience |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2511.06449 |
| keywords | ["Reinforcement Learning","In-Context Learning","Experience Libraries","Agent Learning","Gradient-Free Optimization"] |
| description | Enable LLM agents to improve continuously during deployment by constructing structured experience libraries through self-reflection on successes and failures—achieving 23% improvement on reasoning without gradient-based parameter updates or external training. |
Deployed language model agents are typically static—once trained, they don't improve from real-world interactions. FLEX solves this through gradient-free continuous learning: agents maintain a structured experience library recording successes, failures, and their contexts. During subsequent interactions, the agent retrieves and reflects on relevant past experiences, incorporating these lessons into prompting without retraining.
The approach demonstrates substantial gains: 23% improvement on mathematical reasoning (AIME25), 10% on chemical synthesis, 14% on protein engineering—all from self-refinement during deployment, not additional training.
FLEX treats deployed agent improvement as a problem of structured experience management rather than parameter optimization. The system maintains three components:
This approach is particularly powerful because it requires no gradient computation, model retraining, or API calls to external LLMs during learning—only structured reflection during inference.
Step 1: Experience Data Structure
Define a structured format for recording and retrieving agent interactions.
from dataclasses import dataclass
from typing import List, Dict, Any
import json
datetime datetime
:
problem:
solution_attempt:
ground_truth:
is_correct:
domain:
difficulty:
timestamp:
techniques_used: []
failure_reason:
reflection:
metadata: [, ]
():
{
: .problem,
: .solution_attempt,
: .is_correct,
: .domain,
: .difficulty,
: .timestamp,
: .techniques_used,
: .failure_reason,
: .reflection,
: .metadata
}
:
():
.storage_path = storage_path
.experiences: [Experience] = []
.load_from_disk()
():
.experiences.append(exp)
(.storage_path, ) f:
f.write(json.dumps(exp.to_dict()) + )
() -> [Experience]:
sklearn.feature_extraction.text TfidfVectorizer
sklearn.metrics.pairwise cosine_similarity
domain_exps = [e e .experiences e.domain == domain]
(domain_exps) < k:
domain_exps
all_problems = [e.problem e domain_exps] + [problem]
vectorizer = TfidfVectorizer(max_features=)
tfidf = vectorizer.fit_transform(all_problems)
similarities = cosine_similarity(tfidf[-:], tfidf[:-])[]
top_indices = similarities.argsort()[-k:][::-]
[domain_exps[i] i top_indices]
():
:
(.storage_path, ) f:
line f:
exp_dict = json.loads(line)
.experiences.append(Experience(**exp_dict))
FileNotFoundError:
Step 2: Self-Reflection Engine
Generate structured reflections on why attempts succeeded or failed.
def generate_reflection(problem: str, solution: str, is_correct: bool,
ground_truth: str = None, llm_api=None) -> str:
"""
Generate agent's reflection on an attempt.
Args:
problem: Original problem
solution: Agent's attempted solution
is_correct: Whether solution was correct
ground_truth: Correct solution (if available)
llm_api: LLM API for generating reflection (e.g., GPT-4, Claude)
Returns:
reflection: Natural language analysis
"""
if is_correct:
prompt = f"""Analyze why this solution was correct:
Problem: {problem}
Solution: {solution}
Provide a brief reflection on what techniques made this solution work:"""
else:
prompt = f"""Analyze why this solution failed:
Problem: {problem}
Your solution: {solution}
Correct solution: {ground_truth}
Identify the key mistake or misconception:"""
# Call LLM to generate reflection
if llm_api:
reflection = llm_api.generate(prompt, max_tokens=200)
else:
# Fallback: simple pattern matching
if "ValueError" in solution or "TypeError" in solution:
reflection = "Code had syntax or type error"
elif is_correct:
reflection = "Solution approach was sound"
else:
reflection = "Solution logic was flawed"
return reflection
Step 3: Experience-Augmented Prompting
Incorporate retrieved experiences into prompts during inference.
def augment_prompt_with_experiences(
original_prompt: str,
relevant_experiences: List[Experience],
include_failures: bool = True) -> str:
"""
Create augmented prompt including relevant past experiences.
Args:
original_prompt: User's problem description
relevant_experiences: Retrieved past experiences
include_failures: Whether to include negative examples
Returns:
augmented_prompt: Enhanced prompt with examples
"""
augmented = "You have access to relevant past experiences. Use insights from successes:\n\n"
successful_exps = [e for e in relevant_experiences if e.is_correct]
for i, exp in enumerate(successful_exps):
augmented += f"Example {i+1} - Success:\n"
augmented += f"Problem: {exp.problem}\n"
augmented += f"Solution: {exp.solution_attempt}\n"
augmented += f"Key insight: {exp.reflection}\n\n"
if include_failures:
failed_exps = [e for e in relevant_experiences if not e.is_correct]
if failed_exps:
augmented += "Learn from past mistakes:\n\n"
for i, exp in enumerate(failed_exps):
augmented += f"Past Mistake {i+1}:\n"
augmented += f"Problem: {exp.problem}\n"
augmented += f"Failed attempt: {exp.solution_attempt}\n"
augmented += f"Why it failed: {exp.failure_reason}\n\n"
augmented += f"Now solve this new problem:\n{original_prompt}"
return augmented
Step 4: Agent Deployment Loop
Main loop integrating experience capture and retrieval during deployment.
class DeployedAgent:
"""LLM agent that learns from deployment experiences."""
def __init__(self, base_model, experience_library, domain='general'):
self.model = base_model
self.library = experience_library
self.domain = domain
self.success_count = 0
self.total_attempts = 0
def solve_problem(self, problem: str, ground_truth: str = None) -> Dict[str, Any]:
"""
Solve a problem, recording experience for future learning.
Args:
problem: Problem description
ground_truth: Correct answer (if available for offline validation)
Returns:
result: {solution, is_correct, experience_recorded}
"""
# Step 1: Retrieve relevant past experiences
relevant_exps = self.library.retrieve_relevant(problem, self.domain, k=3)
# Step 2: Augment prompt with relevant experiences
augmented_prompt = augment_prompt_with_experiences(
problem, relevant_exps, include_failures=True
)
# Step 3: Generate solution
solution = self.model.generate(augmented_prompt, max_tokens=2048)
# Step 4: Validate (if ground truth available)
is_correct = False
if ground_truth:
is_correct = self._validate_solution(solution, ground_truth)
self.total_attempts += 1
if is_correct:
self.success_count += 1
# Step 5: Generate reflection
reflection = generate_reflection(problem, solution, is_correct, ground_truth)
# Step 6: Record experience
failure_reason = None
if not is_correct:
failure_reason = self._analyze_failure(solution, ground_truth)
experience = Experience(
problem=problem,
solution_attempt=solution,
ground_truth=ground_truth or '',
is_correct=is_correct,
domain=self.domain,
difficulty=self._estimate_difficulty(problem),
timestamp=datetime.now().isoformat(),
techniques_used=self._extract_techniques(solution),
failure_reason=failure_reason,
reflection=reflection,
metadata={
'model': self.model.name,
'num_examples': len(relevant_exps),
'accuracy_rate': self.success_count / self.total_attempts
}
)
self.library.add_experience(experience)
return {
'solution': solution,
'is_correct': is_correct,
'experience_recorded': True
}
def _validate_solution(self, solution: str, ground_truth: str) -> bool:
"""Check if solution matches ground truth."""
# Simple string matching; extend for domain-specific validation
return solution.strip() == ground_truth.strip()
def _analyze_failure(self, solution: str, ground_truth: str) -> str:
"""Identify type of failure."""
if "ValueError" in solution or "TypeError" in solution:
return "Syntax/Type Error"
elif len(solution) == 0:
return "No Output Generated"
else:
return "Incorrect Logic"
def _estimate_difficulty(self, problem: str) -> str:
"""Estimate problem difficulty."""
word_count = len(problem.split())
if word_count < 50:
return "easy"
elif word_count < 200:
return "medium"
else:
return "hard"
def _extract_techniques(self, solution: str) -> List[str]:
"""Identify reasoning techniques used."""
techniques = []
if "divide" in solution.lower() or "split" in solution.lower():
techniques.append("divide-and-conquer")
if "recursion" in solution.lower():
techniques.append("recursion")
if "dynamic" in solution.lower():
techniques.append("dynamic-programming")
if "greedy" in solution.lower():
techniques.append("greedy")
return techniques
Step 5: Continuous Monitoring and Adaptation
Track learning over time and identify when improvements plateau.
def monitor_agent_learning(agent: DeployedAgent, window_size: int = 100):
"""
Monitor improvement trends in agent performance.
Args:
agent: Deployed agent instance
window_size: Number of recent attempts to analyze
Yields:
metrics: Performance statistics
"""
while True:
recent_exps = agent.library.experiences[-window_size:]
if len(recent_exps) > 0:
success_rate = sum(1 for e in recent_exps if e.is_correct) / len(recent_exps)
avg_reflection_length = sum(
len(e.reflection.split()) for e in recent_exps
) / len(recent_exps)
metrics = {
'success_rate': success_rate,
'sample_count': agent.total_attempts,
'improvement': success_rate, # Compare to baseline if available
'avg_reflection_length': avg_reflection_length,
'unique_domains': len(set(e.domain for e in recent_exps))
}
yield metrics
# If plateau detected, could trigger additional strategies
if success_rate > 0.9:
print("Agent has reached high performance; consider expanding domain")
import time
time.sleep(60) # Monitor every minute
When to Use FLEX:
When NOT to Use:
Hyperparameters and Configuration:
Pitfalls to Avoid:
Reference: https://arxiv.org/abs/2511.06449