continuous-learning

継続的な学習

googleadsagent.ai™ による Agent Skills™ の一部です。

説明

継続的な学習により、エージェントは完了したセッションから成功パターンを自動的に抽出し、再利用可能なスキル、ルール、プロンプトの改善として体系化できます。手動でスキルを作成するのではなく、継続的な学習システムは、すべてのエージェントセッションを新たな能力の源として扱います。エージェントが効果的なアプローチを発見したり、未知の問題を解決したり、再現可能な方法でエラーから復旧したりすると、その振る舞いを捉えてエージェントのスキルレパートリーに取り込みます。

このスキルは、googleadsagent.ai の Buddy™ に組み込まれた学習のフライホイールを実現します。セッションをまたいだパターンマイニングによって、人間のエンジニアが明示的にプログラムしたものではない、Google Ads 分析の特化技術が数十件生み出されました。このシステムは、高品質な結果につながるツールのシーケンス、精度を高めるプロンプトの変更、成功するエラー復旧戦略を観察し、将来のセッションで活用できる構造化スキルとしてパッケージ化します。

学習パイプラインは、観察（結果の注釈を付けてセッションイベントを記録）、マイニング（セッション間の統計的に有意なパターンの特定）、検証（候補スキルを保留セッションでテスト）、統合（検証済みスキルをエージェントのアクティブなスキルセットに展開）の4段階で動作します。これは、エージェントの振る舞いに科学的方法を適用したものです。観察し、仮説を立て、テストし、展開します。

使用する場面

• 手動で介入せずに、エージェントの能力を時間の経過とともに自動的に向上させたい場合
• セッションをまたいでパターンが生まれる、反復的なドメイン固有のタスクをエージェントが実行する場合
• 新しいチームメンバーが、経験豊富なユーザーによって発見されたパターンを活用する必要がある場合
• 実際のベストプラクティスを反映した、常に更新されるナレッジベースを維持する必要がある場合
• さまざまなエージェントのアプローチを A/B テストし、優れたものを自動的に採用する場合
• スキルの導出を自動化して、手動でのプロンプトエンジニアリングへの依存を減らす場合

仕組み

graph TD
    A[Session Completion] --> B[Event Logger]
    B --> C[Outcome Annotation]
    C --> D[Pattern Mining Engine]
    D --> E{Significant Pattern?}
    E -->|Yes| F[Skill Template Generator]
    E -->|No| G[Archive for Future Mining]
    F --> H[Candidate Skill]
    H --> I[Validation Suite]
    I -->|Pass| J[Version + Deploy]
    I -->|Fail| K[Refine Hypothesis]
    K --> D
    J --> L[Active Skill Set]
    L --> M[A/B Test Monitor]
    M -->|Winner| N[Promote to Default]
    M -->|Loser| O[Deprecate]

学習ループは各セッションの完了後に始まります。イベントロガーは、結果の注釈（成功、一部成功、失敗、ユーザー満足度のシグナル）を含む完全な実行トレースを記録します。パターンマイニングエンジンは、蓄積されたセッションを対象に定期的に実行され、エージェントの振る舞いと肯定的な結果の間にある統計的に有意な相関関係を探します。候補パターンは、指示、例、制約を含む構造化された SKILL.md ファイルであるスキルテンプレートに変換されます。検証では、保留セッションに対して候補スキルを実行し、結果が改善されることを確認します。検証済みスキルにはバージョンが付与されて展開され、A/B テストで比較パフォーマンスが監視されます。

実装

結果の注釈付きイベントロガー：

@dataclass
class AnnotatedEvent:
    session_id: str
    event_type: str
    content: dict
    outcome_score: float  # 0.0 = failure, 1.0 = success
    user_feedback: str | None = None

class SessionLogger:
    def __init__(self, store):
        self.store = store
        self.buffer = []

    def log(self, event: AnnotatedEvent):
        self.buffer.append(event)

    async def flush(self, session_outcome: float):
        for event in self.buffer:
            if event.outcome_score == 0.0:
                event.outcome_score = session_outcome
            await self.store.append(event.session_id, asdict(event))
        self.buffer.clear()

パターンマイニングエンジン：

class PatternMiner:
    def __init__(self, min_occurrences=5, min_success_rate=0.8):
        self.min_occurrences = min_occurrences
        self.min_success_rate = min_success_rate

    async def mine(self, sessions: list[list[AnnotatedEvent]]) -> list[dict]:
        tool_sequences = self.extract_tool_sequences(sessions)
        prompt_patterns = self.extract_prompt_patterns(sessions)
        recovery_strategies = self.extract_recovery_patterns(sessions)

        candidates = []
        for pattern_set in [tool_sequences, prompt_patterns, recovery_strategies]:
            for pattern in pattern_set:
                if (pattern["occurrences"] >= self.min_occurrences
                        and pattern["success_rate"] >= self.min_success_rate):
                    candidates.append(pattern)

        return sorted(candidates, key=lambda p: p["success_rate"] * p["occurrences"], reverse=True)

    def extract_tool_sequences(self, sessions):
        sequences = {}
        for session in sessions:
            tools = [e for e in session if e.event_type == "tool_call"]
            for window in range(2, 5):
                for i in range(len(tools) - window + 1):
                    seq = tuple(t.content.get("name", "") for t in tools[i:i+window])
                    outcome = sum(t.outcome_score for t in tools[i:i+window]) / window
                    if seq not in sequences:
                        sequences[seq] = {"occurrences": 0, "success_sum": 0}
                    sequences[seq]["occurrences"] += 1
                    sequences[seq]["success_sum"] += outcome

        return [
            {"type": "tool_sequence", "pattern": seq, "occurrences": s["occurrences"],
             "success_rate": s["success_sum"] / s["occurrences"]}
            for seq, s in sequences.items()
        ]

スキルテンプレートジェネレーター：

SKILL_TEMPLATE = """# {name}

Part of [Agent Skills™](https://github.com/itallstartedwithaidea/agent-skills) by [googleadsagent.ai™](https://googleadsagent.ai)



## Description
{description}

## Use When
{use_when}

## Implementation
{implementation}

## Derived From
- Sessions analyzed: {sessions_analyzed}
- Pattern frequency: {frequency}
- Success rate: {success_rate:.0%}
- Generated: {generated_date}
"""

class SkillGenerator:
    def __init__(self, model):
        self.model = model

    async def generate_skill(self, pattern: dict, examples: list) -> str:
        prompt = f"""Generate a SKILL.md for the following discovered pattern:

Pattern type: {pattern['type']}
Pattern: {pattern['pattern']}
Success rate: {pattern['success_rate']:.0%}
Occurrences: {pattern['occurrences']}

Example sessions where this pattern succeeded:
{json.dumps(examples[:3], indent=2)}

Write a clear, actionable description, use-when conditions, and implementation guidance."""

        content = await self.model.generate(prompt)
        return SKILL_TEMPLATE.format(
            name=pattern.get("name", "Discovered Pattern"),
            version="1.0.0",
            confidence=pattern["success_rate"],
            description=content,
            use_when="(see description)",
            implementation="(see description)",
            sessions_analyzed=pattern.get("sessions_analyzed", "N/A"),
            frequency=pattern["occurrences"],
            success_rate=pattern["success_rate"],
            generated_date=datetime.utcnow().isoformat(),
        )

A/B テストフレームワーク：

interface SkillVariant {
  id: string;
  skillContent: string;
  version: string;
  metrics: { invocations: number; successes: number; avgScore: number };
}

class SkillABTest {
  constructor(
    private control: SkillVariant,
    private treatment: SkillVariant,
    private minSamples: number = 50,
  ) {}

  selectVariant(sessionId: string): SkillVariant {
    const hash = simpleHash(sessionId);
    return hash % 2 === 0 ? this.control : this.treatment;
  }

  recordOutcome(variant: SkillVariant, score: number): void {
    variant.metrics.invocations++;
    variant.metrics.successes += score >= 0.8 ? 1 : 0;
    variant.metrics.avgScore =
      (variant.metrics.avgScore * (variant.metrics.invocations - 1) + score) /
      variant.metrics.invocations;
  }

  getWinner(): SkillVariant | null {
    if (this.control.metrics.invocations < this.minSamples) return null;
    if (this.treatment.metrics.invocations < this.minSamples) return null;

    const controlRate = this.control.metrics.successes / this.control.metrics.invocations;
    const treatRate = this.treatment.metrics.successes / this.treatment.metrics.invocations;
    const diff = Math.abs(controlRate - treatRate);

    if (diff > 0.05) {
      return controlRate > treatRate ? this.control : this.treatment;
    }
    return null;
  }
}

ベストプラクティス

1. イベントだけでなく、結果も記録する — 成功／失敗のラベルがない生のイベントログは、マイニングに役立ちません。重要なイベントすべてに結果スコアを付けてください。
2. 統計的有意性を必須とする — 3 回観測されたパターンは単なる逸話です。候補スキルに昇格させる前に、一貫した成功率を示す少なくとも 5～10 回の出現を必須としてください。
3. 保留データで検証する — スキルの導出元となったセッションだけでスキルをテストしないでください。汎化を確認するため、保留セッションを使用してください。
4. 生成したすべてのスキルにバージョンを付ける — 新しいデータが届くと、自動生成されたスキルは進化します。改善を追跡し、ロールバックを可能にするため、バージョンを付けてください。
5. 全面展開の前に A/B テストを行う — 新しいスキルを、一部のセッションで現在のデフォルトと比較して実行してください。明確な改善が確認されてから昇格させてください。
6. 自動生成するスキルの数に上限を設ける — 重複するスキルが多すぎるとエージェントが混乱します。有効なスキルの数を制限し、成績の低いスキルは非推奨にしてください。
7. 影響の大きいスキルは人間がレビューする — 重要な領域の自動生成スキルは、展開前にその分野の専門家がレビューしてください。

プラットフォームの互換性

機能	Claude Code	Cursor	Codex	Gemini CLI
セッションのログ記録	✅ フック	✅ 拡張機能	✅ カスタム	✅ カスタム
パターンマイニング	✅ 外部スクリプト	✅ 外部スクリプト	✅ 外部スクリプト	✅ 外部スクリプト
スキルの生成	✅ SKILL.md 互換	✅ SKILL.md ネイティブ	✅ 指示	✅ システムプロンプト
A/B テスト	✅ カスタム	✅ カスタム	✅ カスタム	✅ カスタム
自動展開	✅ ファイル書き込みフック	✅ スキルディレクトリ	⚠️ 手動	⚠️ 手動

関連スキル

• メモリの永続化 - セッションデータの永続化により、セッションをまたいだパターンマイニングの元データを提供します
• ナレッジベースの注入 - マイニングされたパターンは、今後のエージェントセッションで注入できる知識として展開されます
• エンティティメモリの管理 - エンティティ抽出により、構造化された観測結果がパターンマイニングのパイプラインに供給されます
• PMax の最適化 - Performance Max キャンペーンデータから最適化パターンを自動検出します

キーワード

continuous-learning, pattern-mining, skill-generation, a-b-testing, feedback-loops, auto-improvement, session-analysis, knowledge-derivation, skill-versioning, agent-skills

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License