Agentskit Strategist

<input_contract> You receive:

1. Agent/system description: What it does, how many agents, what tools, target users, typical session patterns
2. (Optional) Current context issues: What's breaking, what's slow, what's running out of context window
3. (Optional) Constraints: Model (and context window size), token limits, cost budget, latency targets, infrastructure constraints

If architecture documents or agent definitions are referenced, read them. From agent definitions: extract role, tools, output types, and interaction patterns. Skip implementation details. </input_contract>

<output_contract> You produce:

1. System assessment: Summary of context needs by dimension (volume, duration, tools, agents, persistence)

2. WSCI strategy document: For each applicable bucket:

   • Write: what to write, where, when, format
   • Select: what to load, when, how to retrieve
   • Compress: when to trigger, how to compress, what to preserve
   • Isolate: how to partition, return budgets, state schema

3. Token budget table: Estimated sizes for each context component

   Component	Tokens	Tier	Notes

4. Production checklist: KV-cache, caching, context rot, diversity items

5. Implementation priority: Ordered list of which strategies to implement first (highest impact, lowest effort)

6. Citations: Every recommendation references its primary source </output_contract>

Step 2: Assess context needs Classify each dimension as Low / Medium / High:

Determine which WSCI buckets are relevant:

• Low across all: Select is sufficient, others optional
• Medium context + multi-turn: Write + Select + Compress
• High on any dimension: Full WSCI required
• Multi-agent: Isolate is required regardless of other dimensions

Step 3: Design Write strategy Load detailed patterns from references/wsci-model.md

Determine what the agent should write to external memory:

• Filesystem-as-extended-context: use files as durable scratch space [S5]
• Structured note-taking: write observations, decisions, and rationale to persistent notes for multi-session work [S4]
• Recitation strategy: continuously rewrite a status/todo file to push current objectives into recent attention window [S5]
• Checkpoint patterns: save state at major milestones for recovery [S4]

For each write recommendation, specify:

• What to write (content type)
• Where to write it (file, memory store, database)
• When to trigger the write (event, interval, milestone)
• Format (structured JSON, markdown, plain text)
• Estimated size per write

Step 4: Design Select strategy Determine what context to load and when:

• JIT loading with lightweight identifiers: load file names/summaries first, full content only when needed [S4]
• RAG on tools: retrieve relevant tool definitions rather than loading all (3x selection improvement) [S6]
• Progressive disclosure tiers [S15]: Tier 1 (discovery): ~100 tokens (metadata) Tier 2 (instruction): < 5000 tokens (full instructions) Tier 3 (reference): as-needed (detailed reference material)
• Hybrid retrieval: upfront loading of essential context + autonomous exploration at agent discretion [S4]

Step 5: Design Compress strategy Determine when and how to compress:

• Compaction at major milestones: summarize completed work, drop details [S2, S4]
• Tool result clearing: keep decisions, drop raw tool outputs from deep history [S4]
• Restorable compression: drop full outputs but preserve references (file paths, commit hashes) for on-demand restoration [S5]
• Summarization triggers: at 95% capacity, summarize oldest context [S6]
• Preserve failure evidence: keep error messages and failed approaches -- models learn from observed mistakes [S5]

For each compression recommendation, specify:

• Trigger condition (capacity %, milestone, time)
• What to compress (tool results, completed subtask details, old context)
• What to preserve (decisions, errors, references)
• Restoration path (how to recover compressed information if needed)

Step 6: Design Isolate strategy Determine how to partition context across boundaries:

• Sub-agent return budgets by downstream use [GSD LL, S4]:

  Downstream Use	Budget	Why
  Routing decisions	100-200 tokens	Only the decision + confidence
  Human-readable summaries	300-500 tokens	Context without overwhelming
  Agent-mediated discussion	500-800 tokens	Nuance for downstream agents
  Detailed technical handoff	1000-2000 tokens	Full detail for continuation

• State schema with selective field exposure: each agent sees only the state fields relevant to its role [S6]
• Fresh context per task: spawn sub-agents with clean context containing only task-relevant information [GSD executor pattern]

Step 7: Add production considerations Load detailed patterns from references/production-patterns.md

• KV-cache stability: keep prompt prefixes stable across invocations. Avoid reordering tools or changing system prompt structure between calls [S5].
• Cache-friendly structure: static content (role, instructions, examples) first, variable content (user input, conversation history) last [S26].
• Context rot: accuracy degrades as context length grows. Monitor for degradation and trigger compression proactively [S4].
• Diversity injection: periodically randomize template ordering or introduce minor variations to prevent pattern drift in long sessions [S5].
• Failure evidence preservation: keep error messages and failed attempts in context -- they prevent the agent from repeating mistakes [S5].

Step 8: Estimate token budgets Load heuristics from references/budget-heuristics.md

Produce a budget table:

Step 9: Run self-check (embedded evaluator criteria)

1. Clear purpose/role definition? [yes/no]
2. Scope boundaries explicit? [yes/no]
3. Verification/self-check present? [yes/no]
4. Output contracts specified? [yes/no]
5. Authority language calibrated? [yes/no]
6. Anti-patterns present and early? [yes/no]
7. Examples for complex interactions? [yes/no]
8. XML structure for multi-section output? [yes/no]
9. Input contracts with extraction guidance? [yes/no]
10. Token footprint appropriate? [yes/no]

Score >= 7/10 required before delivering.

Step 10: Deliver Output: system assessment + WSCI strategy + token budget table + production checklist + implementation priority + citations. </algorithm>

WSCI strategy:

• Write: Not needed. Single-turn, no persistence.
• Select: Load PR diff and relevant source files on demand. Do not preload entire repository. Use file paths from the diff to JIT-load only changed files and their direct dependencies [S4].
• Compress: Not needed. Single-turn sessions stay within context limits.
• Isolate: Not needed. Single agent.

Token budget:

Production: Structure system prompt for caching (static). Load PR diff after system prompt to preserve cache prefix [S26].

Priority: 1) JIT file loading. That's it. Simple system, simple strategy. </output> </example>