CommunityCodierung & Entwicklunggithub.com

Kontextoptimierung

Diese Verbesserung dient der Optimierung der Kontexteffizienz mittels Budgetierung, Beobachtungsmaskierung, Prefix-/KV-Cache-Strategien, Partitionierung, Kostenreduktion und Erweiterung der effektiven Kapazität bei gleichbleibender Antwortqualität.

Was ist Kontextoptimierung?

Die Kontextoptimierung erweitert die effektive Kapazität begrenzter Kontextfenster durch strategische Kompression, Maskierung, Caching und Partitionierung. Sie priorisiert vier Hauptstrategien: KV-Cache-Optimierung (günstigste Optimierung bei stabilen Prefixen), Beobachtungsmaskierung (größte Kapazitätsgewinne durch Ersetzen von Tool-Outputs durch Referenzen), Kompaktierung (Zusammenfassung bei >70% Auslastung) und Kontextpartitionierung (Aufteilung auf Sub-Agenten bei >60% Auslastung). Die Technik wird durch messbare Metriken gesteuert und vermeidet aggressive Optimierung, die die Antwortqualität beeinträchtigt. Sie ist für Claude Code, Cursor und ähnliche Plattformen konzipiert und wird bei Kosten- oder Kapazitätsengpässen aktiviert.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/context-optimization

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Kontextoptimierungstechniken

Kontextoptimierung erweitert die effektive Kapazität begrenzter Kontextfenster durch strategische Kompression, Maskierung, Caching und Partitionierung. Effektive Optimierung erhöht die nutzbare Kapazität, ohne dass größere Modelle oder längere Fenster erforderlich sind – jedoch nur, wenn sie mit Messdisziplin angewendet wird. Die folgenden Techniken sind nach Auswirkung und Risiko geordnet.

Wann zu aktivieren

Aktiviere diese Verbesserung, wenn:

  • Kontextbudgets oder Token-Kosten die Aufgabenkomplexität einschränken
  • Beobachtungsmaskierung ausführliche Tool-Ausgaben durch abrufbare Referenzen ersetzen kann
  • Die Prefix- oder KV-Cache-Trefferquote verbessert werden muss
  • Die Abrufeingrenzung die Menge irrelevanten geladenen Kontexts reduzieren kann
  • Kontextpartitionierung die effektive Kapazität über mehrere Agenten hinweg erweitern kann
  • Budgetauslöser für Maskierung, Kompaktierung oder Partitionierung benötigt werden

Aktiviere diese Verbesserung nicht für angrenzende Arbeiten, die anderen Verbesserungen unterliegen:

  • Erklärung, warum sich Aufmerksamkeit oder Kontextfenster so verhalten: context-fundamentals.
  • Diagnose aktiver „Lost-in-the-Middle“-, Vergiftungs-, Ablenkungs-, Verwirrungs- oder Kollisionsprobleme: context-degradation.
  • Entwurf einer strukturierten Übergabezusammenfassung für ein langes Gespräch: context-compression.
  • Speicherung großer Ausgaben, Pläne oder Protokolle als Dateien: filesystem-context.
  • Vom Modell initiierte Umschreibungen seines eigenen Kontexts und deren Neu-Prefill-Kosten: self-managed-context.

Kernkonzepte

Wende die vier primären Strategien in dieser Prioritätsreihenfolge an:

  1. KV-Cache-Optimierung – Ordne die Prompt-Struktur um und stabilisiere sie, sodass die Inferenz-Engine zwischengespeicherte Key/Value-Tensoren wiederverwenden kann. Dies ist die günstigste Optimierung, wenn die Laufzeitumgebung Prefix-Caching unterstützt: geringes Qualitätsrisiko, sofortige Kosten- und Latenzeinsparungen. Wende sie zuerst an, wenn stabile Prefixe existieren.

  2. Beobachtungsmaskierung – Ersetze ausführliche Tool-Ausgaben durch kompakte Referenzen, sobald ihr Zweck erfüllt ist. Tool-Ausgaben dominieren oft Agent-Trajektorien (beanspruche context-optimization-tool-output-dominance), daher liefert die Maskierung oft die größten Kapazitätsgewinne. Der ursprüngliche Inhalt bleibt bei Bedarf nachgelagert abrufbar.

  3. Kompaktierung – Fasse den angesammelten Kontext zusammen, wenn die Auslastung 70% überschreitet, und initialisiere dann mit der Zusammenfassung neu. Dadurch wird der Inhalt des Fensters destilliert, während der aufgabenkritische Zustand erhalten bleibt. Kompaktierung ist verlustbehaftet – wende sie erst an, nachdem die Maskierung bereits die masse der minderwertigen Inhalte entfernt hat.

  4. Kontextpartitionierung – Teile die Arbeit auf Sub-Agenten mit isolierten Kontexten auf, wenn ein einzelnes Fenster das gesamte Problem nicht fassen kann. Jeder Sub-Agent arbeitet in einem sauberen Kontext, der auf seine Teilaufgabe fokussiert ist. Hebe dies für Aufgaben auf, bei denen der geschätzte Kontext 60% des Fensterlimits überschreitet, da der Koordinationsaufwand real ist.

Das leitende Prinzip: Kontextqualität zählt mehr als Quantität. Jede Optimierung bewahrt das Signal und reduziert das Rauschen. Messe vor der Optimierung und messe dann die Wirkung der Optimierung.

Detaillierte Themen

Kompaktierungsstrategien

Löse die Kompaktierung aus, wenn die Kontextauslastung 70% überschreitet: fasse den aktuellen Kontext zusammen und initialisiere dann mit der Zusammenfassung neu. Dadurch wird der Inhalt des Fensters mit hoher Genauigkeit destilliert, sodass die Fortsetzung mit minimaler Leistungsverschlechterung möglich ist. Priorisiere die Komprimierung von Tool-Ausgaben (sie verbrauchen 80%+ der Token), dann alte Gesprächsrunden, dann abgerufene Dokumente. Komprimiere niemals den System-Prompt – er verankert das Modellverhalten, und seine Entfernung führt zu unvorhersehbaren Verschlechterungen.

Bewahre je nach Nachrichtentyp unterschiedliche Elemente:

  • Tool-Ausgaben: Extrahiere wichtige Erkenntnisse, Metriken, Fehlercodes und Schlussfolgerungen. Entferne ausführliche Rohausgaben, Stack-Traces (außer beim Debugging) und Standardkopfzeilen.
  • Gesprächsrunden: Behalte Entscheidungen, Zusagen, Benutzerpräferenzen und Kontextwechsel bei. Entferne Füllmaterial, Höflichkeitsfloskeln und exploratives Hin und Her, das zu einer bereits erfassten Schlussfolgerung geführt hat.
  • Abgerufene Dokumente: Behalte Behauptungen, Fakten und Datenpunkte, die für die aktuelle Aufgabe relevant sind. Entferne unterstützende Beweise und Ausführungen, die einem einmaligen Argumentationszweck dienten.

Ziele eine Token-Reduktion von 50-70% bei einer Qualitätsverschlechterung von weniger als 5% an. Wenn die Kompaktierung 70% Reduktion überschreitet, prüfe die Zusammenfassung auf kritischen Informationsverlust – überaggressive Kompaktierung ist der häufigste Fehlermodus.

Beobachtungsmaskierung

Maskiere Beobachtungen selektiv basierend auf Aktualität und anhaltender Relevanz – nicht einheitlich. Wende diese Regeln an:

  • Niemals maskieren: Für die aktuelle Aufgabe kritische Beobachtungen, Beobachtungen aus der aktuellsten Runde, Beobachtungen, die in aktiven Argumentationsketten verwendet werden, und Fehlerausgaben, wenn das Debugging läuft.
  • Nach 3+ Runden maskieren: Ausführliche Ausgaben, deren Kernpunkte bereits in den Gesprächsfluss extrahiert wurden. Ersetze durch eine kompakte Referenz: [Obs:{ref_id} ausgelassen. Schlüssel: {Zusammenfassung}. Vollständiger Inhalt abrufbar.]
  • Immer sofort maskieren: Wiederholte/doppelte Ausgaben, Standardkopf- und Fußzeilen, bereits früher im Gespräch zusammengefasste Ausgaben.

Die Maskierung sollte eine Reduktion von 60-80% bei maskierten Beobachtungen mit einer Qualitätsauswirkung von weniger als 2% erreichen. Der Schlüssel liegt in der Aufrechterhaltung der Abrufbarkeit – speichere den vollständigen Inhalt extern und behalte die Referenz-ID im Kontext, damit der Agent bei Bedarf das Original anfordern kann.

KV-Cache-Optimierung

Maximiere Prefix-Cache-Treffer, indem du Prompts so strukturierst, dass stabile Inhalte das Prefix belegen und dynamische Inhalte am Ende erscheinen. Der KV-Cache speichert Key- und Value-Tensoren, die während der Inferenz berechnet werden; wenn aufeinanderfolgende Anfragen ein identisches Prefix teilen, werden die zwischengespeicherten Tensoren wiederverwendet, was Kosten und Latenz spart.

Wende diese Reihenfolge in jedem Prompt an:

  1. System-Prompt (am stabilsten – ändert sich nie innerhalb einer Sitzung)
  2. Tool-Definitionen (stabil über Anfragen hinweg)
  3. Häufig wiederverwendete Vorlagen und Few-Shot-Beispiele
  4. Gesprächsverlauf (wächst, teilt aber das Prefix mit vorherigen Runden)
  5. Aktuelle Abfrage und dynamischer Inhalt (am wenigsten stabil – immer zuletzt)

Entwerfe Prompts für Cache-Stabilität: Entferne Zeitstempel, Sitzungszähler und Anfrage-IDs aus dem System-Prompt. Verschiebe dynamische Metadaten in eine separate Benutzernachricht oder ein Tool-Ergebnis, wo sie das Prefix nicht unterbrechen. Bereits eine einzelne Leerzeichenänderung im Prefix macht den gesamten zwischengespeicherten Block nach dieser Änderung ungültig. Dieselbe Regel gilt für jede Kompaktierungs- oder Maskierungsbearbeitung, die auf frühere Verläufe angewendet wird: Ihre Kosten sind der nachfolgende Text. Bündele solche Bearbeitungen und bevorzuge sie in der Nähe des Endes des Kontexts.

Ziele eine Cache-Trefferquote von 70%+ für stabile Arbeitslasten an. Im Maßstab führt dies zu einer Kostenreduktion von 50%+ und einer Latenzreduktion von 40%+ bei zwischengespeicherten Token.

Kontextpartitionierung

Teile die Arbeit auf Sub-Agenten auf, wenn ein einzelner Kontext das gesamte Problem nicht fassen kann, ohne aggressive Kompaktierung auszulösen. Jeder Sub-Agent arbeitet in einem sauberen, fokussierten Kontext für seine Teilaufgabe und gibt dann ein strukturiertes Ergebnis an einen Koordinator-Agenten zurück.

Plane die Partitionierung, wenn der geschätzte Aufgabenkontext 60% des Fensterlimits überschreitet. Zerlege die Aufgabe in unabhängige Teilaufgaben, weise jede einem Sub-Agenten zu und aggregiere die Ergebnisse. Validiere, dass alle Partitionen abgeschlossen sind, bevor du sie zusammenführst, führe kompatible Ergebnisse zusammen und wende eine Zusammenfassung an, wenn die aggregierte Ausgabe immer noch das Budget überschreitet.

Dieser Ansatz erreicht eine Trennung der Belange – der detaillierte Suchkontext bleibt innerhalb der Sub-Agenten isoliert, während der Koordinator sich auf die Synthese konzentriert. Der Koordinationsaufwand hat jedoch echte Token-Kosten: Der Koordinator-Prompt, die Ergebnisaggregation und die Fehlerbehandlung verbrauchen alle Token. Partitioniere nur, wenn die Einsparungen diesen Overhead übersteigen.

Budgetverwaltung

Weise vor Sitzungsbeginn explizite Token-Budgets für Kontextkategorien zu: System-Prompt, Tool-Definitionen, abgerufene Dokumente, Nachrichtenverlauf, Tool-Ausgaben und einen reservierten Puffer (5-10% der Gesamtmenge). Überwache die Nutzung kontinuierlich gegen das Budget und löse die Optimierung aus, wenn eine Kategorie ihre Zuteilung überschreitet oder die Gesamtauslastung 70% übersteigt.

Verwende auslöserbasierte Optimierung anstelle von periodischer Optimierung. Überwache diese Signale:

  • Token-Auslastung über 80% – löse Kompaktierung aus
  • Verschlechterungsindikatoren der Aufmerksamkeit (Wiederholungen, verpasste Anweisungen) – löse Maskierung + Kompaktierung aus
  • Qualitätsbewertung fällt unter die Basislinie – prüfe die Kontextzusammensetzung vor der Optimierung

Praktische Anleitung

Entscheidungsrahmen für die Optimierung

Wähle die Optimierungstechnik basierend darauf, was den Kontext dominiert:

KontextzusammensetzungErste AktionZweite Aktion
Tool-Ausgaben dominieren (>50%)BeobachtungsmaskierungKompaktierung der verbleibenden Runden
Abgerufene Dokumente dominierenZusammenfassungPartitionierung, wenn Dokumente unabhängig sind
Nachrichtenverlauf dominiertKompaktierung mit selektiver ErhaltungPartitionierung für neue Teilaufgaben
Mehrere Komponenten tragen beiZuerst KV-Cache-Optimierung, dann Maskierung + Kompaktierung schichten
Nahe am Limit mit aktivem DebuggingNur aufgelöste Tool-Ausgaben maskieren – Fehlerdetails erhalten

Leistungsziele

Verfolge diese Metriken, um die Optimierungseffektivität zu validieren:

  • Kompaktierung: 50-70% Token-Reduktion, <5% Qualitätsverschlechterung, <10% Latenz-Overhead durch den Kompaktierungsschritt selbst
  • Maskierung: 60-80% Reduktion der maskierten Beobachtungen, <2% Qualitätsauswirkung, nahezu null Latenz-Overhead
  • Cache-Optimierung: 70%+ Trefferquote für stabile Arbeitslasten, 50%+ Kostenreduktion, 40%+ Latenzreduktion
  • Partitionierung: Netto-Token-Ersparnisse nach Berücksichtigung des Koordinator-Overheads; die Gewinnschwelle wird typischerweise bei 3+ Teilaufgaben erreicht

Iteriere über Strategien basierend auf gemessenen Ergebnissen. Wenn eine Optimierungstechnik die Zielmetrik nicht messbar verbessert, entferne sie – Optimierungsmechanismen selbst verbrauchen Token und erhöhen die Latenz.

Beispiele

Beispiel 1: Kompaktierungsauslöser

if context_tokens / context_limit > 0.8:
    context = compact_context(context)

Beispiel 2: Beobachtungsmaskierung

if len(observation) > max_length:
    ref_id = store_observation(observation)
    return f"[Obs:{ref_id} ausgelassen. Schlüssel: {extract_key(observation)}]"

Beispiel 3: Cache-freundliche Reihenfolge

# Stabile Inhalte zuerst
context = [system_prompt, tool_definitions]  # Cachebar
context += [reused_templates]  # Wiederverwendbar
context += [unique_content]  # Einzigartig

Beispiel 4: Budgetgesteuerte Optimierungsrichtlinie

budgets:
  tool_outputs: 35%
  message_history: 30%
  retrieved_documents: 20%
  reserved_buffer: 15%
triggers:
  tool_outputs_over_budget: mask resolved observations
  total_context_over_70_percent: compact message history
  repeated_irrelevant_retrievals: tighten retrieval scope

Richtlinien

  1. Messe vor der Optimierung – kenne deinen aktuellen Zustand
  2. Wende Maskierung vor Kompaktierung an – entferne zuerst die masse minderwertiger Inhalte, fasse dann zusammen, was übrig bleibt
  3. Entwerfe für Cache-Stabilität mit konsistenten Prompts
  4. Partitioniere, bevor der Kontext problematisch wird
  5. Überwache die Optimierungseffektivität im Laufe der Zeit
  6. Balanciere Token-Ersparnisse mit Qualitätserhaltung
  7. Teste Optimierungen in Produktionsgrößenordnung
  8. Implementiere Graceful Degradation für Randfälle

Fallstricke

  1. Leerzeichen brechen den KV-Cache: Bereits eine einzelne Leerzeichen- oder Zeilenumbruchänderung im Prompt-Prefix macht den gesamten KV-Cache-Block nach diesem Punkt ungültig. Fixiere System-Prompts als unveränderliche Zeichenketten – interpoliere keine Zeitstempel, Versionsnummern oder Sitzungs-IDs hinein. Vergleiche Prompt-Vorlagen byteweise zwischen Bereitstellungen.

  2. Zeitstempel im System-Prompt zerstören Cache-Trefferquoten: Das Einfügen von Aktuelles Datum: {today} oder ähnlichem dynamischem Inhalt in den System-Prompt erzwingt bei jedem neuen Tag (oder bei jeder Anfrage, wenn die Tageszeit verwendet wird) einen vollständigen Cache-Fehler. Verschiebe dynamische Metadaten in eine Benutzernachricht oder ein separates Tool-Ergebnis, das nach dem stabilen Prefix angehängt wird.

  3. Kompaktierung unter Druck verliert kritischen Zustand: Wenn das Modell, das die Kompaktierung durchführt, selbst unter Kontextdruck (>85% Auslastung) steht, verschlechtert sich seine Zusammenfassungsqualität – es lässt Aufgabenziele weg, ignoriert Benutzereinschränkungen und nivelliert nuancierte Zustände. Löse die Kompaktierung bei 70-80% aus, nicht bei 90%+. Wenn die Kompaktierung spät erfolgen muss, verwende einen separaten Modellaufruf mit einem sauberen Kontext, der nur das zu summierende Material enthält.

  4. Maskierung von Fehlerausgaben unterbricht Debugging-Schleifen: Überaggressive Maskierung verbirgt Fehlermeldungen, Stack-Traces und Fehlerdetails, die der Agent in nachfolgenden Runden zur Diagnose und Behebung von Problemen benötigt. Während des aktiven Debuggings (Fehler in den letzten 3 Runden) setze die Maskierung für alle fehlerbezogenen Beobachtungen aus, bis das Problem behoben ist.

  5. Partitionierungs-Overhead kann Einsparungen übersteigen: Jeder Sub-Agent benötigt seinen eigenen System-Prompt, Tool-Definitionen und Koordinationsnachrichten. Bei Aufgaben mit weniger als 3 unabhängigen Teilaufgaben übersteigt der Koordinationsaufwand oft die Kontexteinsparungen. Schätze die Gesamt-Token (Koordinator + alle Sub-Agenten) ab, bevor du dich für die Partitionierung entscheidest.

  6. Cache-Fehler-Kostenspitzen nach Bereitstellungsänderungen: Das Neuanordnen von Tools, das Umformulieren des System-Prompts oder das Ändern von Few-Shot-Beispielen zwischen Bereitstellungen macht den gesamten Prefix-Cache ungültig, was eine vorübergehende Kostenspitze von 2-5x verursacht, bis sich der neue Cache aufgewärmt hat. Rolle Prompt-Änderungen schrittweise aus und überwache die Cache-Trefferquote während der Bereitstellungsfenster.

  7. Kompaktierung erzeugt falsches Vertrauen in veraltete Zusammenfassungen: Sobald der Kontext kompaktiert ist, sieht die Zusammenfassung autoritativ aus, spiegelt jedoch möglicherweise einen veralteten Zustand wider. Wenn sich die Aufgabe seit der Kompaktierung weiterentwickelt hat (neue Benutzeranforderungen, korrigierte Annahmen), trägt die Zusammenfassung stillschweigend veraltete Informationen weiter. Überprüfe nach der Kompaktierung die Zusammenfassung anhand des aktuellen Aufgabenziele, bevor du fortfährst.

Integration

Diese Verbesserung besitzt Token-Effizienz-Taktiken und die Budgetrichtlinie. Angrenzende Verbesserungen besitzen Diagnose-, Speicher- und Architektur:

  • context-fundamentals: mentale Modelle dafür, warum Kontextqualität und Aufmerksamkeitsplatzierung wichtig sind.
  • context-degradation: Diagnose, wenn die Ausgabequalität bereits gesunken ist.
  • context-compression: verlustbehaftete Zusammenfassungs- und Übergabestrategie.
  • filesystem-context: dateigestützte Auslagerung für vollständige Ausgaben und Protokolle.
  • multi-agent-patterns: Aufteilung der Arbeit auf isolierte Agentenkontexte.
  • latent-briefing: selektive KV-Aufbewahrung über das Orchester hinweg.

…

[für die Übersetzung gekürzt]

Individual skills in this repo

This repo contains 19 individual skills — each has its own dedicated page.

advanced-evaluation

This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.

bdi-mental-states

This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations, rational agency traces, cognitive agents, BDI ontologies, and neuro-symbolic AI integration.

book-sft-pipeline

This skill should be used for book-to-SFT pipelines: ePub extraction, literary segmentation, author-voice dataset construction, style-transfer training, LoRA workflows, and model evaluation for voice replication.

comprehensive-research-agent

Ensure thorough validation, error recovery, and transparent reasoning in research tasks with multiple tool calls

context-compression

This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.

context-degradation

This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.

context-fundamentals

This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.

evaluation

This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.

filesystem-context

This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.

harness-engineering

This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs, novelty gates, pruning, rollback, PR preparation, and human approval boundaries.

hosted-agents

This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.

latent-briefing

This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.

long-horizon-prompting

This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.

memory-systems

This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.

multi-agent-patterns

This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.

project-development

This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.

self-improvement-loops

This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.

self-managed-context

This skill should be used when a model gets read-write control over its own live context window instead of a harness-scheduled compaction policy: the context exposed as an editable file the model rewrites with code tools, model-driven eviction and in-place updates, the harness invariants that keep self-editing safe (pinned prefix, edit gate, edit receipts, budget readouts, rollback on overflow), the prefix-cache cost of mid-context edits, and steering or training the model's own context-editing strategy. Route note content and fixed-threshold summarization to context-compression, cache-stable layout under harness control to context-optimization, file offloading to filesystem-context, and loop governance to self-improvement-loops.

tool-design

This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.

Verwandte Skills