Skip to content

mikeparcewski/wicked-garden / skills/agentic/context-engineering

wicked-garden-agentic-context-engineering

Verified

Context window management, token optimization, and memory patterns for efficient multi-agent systems. Use when: optimizing token usage in an agentic pipeline, designing memory scope for short / long-term / episodic state, or applying a context-loading strategy (anticipatory / JIT / hybrid).

---
name: wicked-garden-agentic-context-engineering
description: |
  Context window management, token optimization, and memory patterns for efficient multi-agent systems.

  Use when: optimizing token usage in an agentic pipeline, designing memory
  scope for short / long-term / episodic state, or applying a context-loading
  strategy (anticipatory / JIT / hybrid).
metadata:
  role: module
  phases: "design,review"
  archetypes: "*"
---

# Context Engineering

Techniques for managing context windows, optimizing token usage, and designing efficient memory systems for agentic applications.

## Context Window Fundamentals

**Context Window:** Maximum tokens an LLM can process in a single request (input + output).

Limits vary by provider and model. Check the active model's documentation for
the exact value.

**Token Efficiency Matters:**
- Cost: Charged per token (input + output)
- Latency: More tokens = slower response
- Quality: Irrelevant context can confuse model

## State Management Patterns

| Pattern | Use when | Pros | Cons |
|---------|----------|------|------|
| **Shared** | Agents need synchronized view | Consistency, simple coordination | Contention, single point of failure |
| **Isolated** | Agents operate independently | No contention, parallel execution | Inconsistency possible, harder to coordinate |
| **Checkpointed** | Long-running processes, need recovery | Fault tolerance, replayability | Storage overhead, consistency complexity |

## Token Optimization Techniques

### 1. Aggressive Summarization
Compress old context into summaries to reduce token usage.

### 2. Selective Context Loading
Only load relevant context based on the current task.

### 3. Structured Compression
Use JSON/structured formats instead of prose to reduce tokens.

**Example:**
- Before: "The user's name is John Smith..." (verbose)
- After: `{"name": "John Smith", ...}` (compact)

### 4. Lazy Loading
Load details only when explicitly needed.

### 5. Reference Instead of Embedding
Reference external documents instead of embedding full text.

See `refs/selective-loading.md` and `refs/caching-and-optimization.md` for code examples and detailed strategies.

## Memory Patterns

| Memory | Scope | Size | Retention |
|--------|-------|------|-----------|
| **Short-term (working)** | Current session/task | 1K-10K tokens | Minutes to hours |
| **Long-term** | Cross-session, permanent | Unbounded (vector DB) | Days to forever |
| **Episodic** | Historical events | Summaries stored | Varies by importance |

See `refs/compression-techniques.md` for implementation patterns.

## Prompt Engineering for Agents

### Role Definition
Be specific about agent's role and boundaries.

**Example:**
```
You are a Python code reviewer specializing in security.
Your job is to identify security vulnerabilities.
You do NOT review style or performance.
```

### Task Specification
Clear, actionable instructions with explicit format.

**Bad:** "Review this code."
**Good:** "Review for security: 1) SQL injection 2) Input validation 3) Secrets. Output: JSON with vulnerabilities."

### Format Control
Specify exact output format to reduce tokens.

### Few-Shot Examples
Show examples for complex tasks.

See `refs/selective-loading.md` for detailed prompting patterns.

## Context Loading Strategies

| Strategy | Pros | Cons |
|----------|------|------|
| **Anticipatory** | Faster response time (load before needed) | May load unnecessary data |
| **Just-in-Time (JIT)** | Minimal token usage (load only when needed) | Latency on each request |
| **Hybrid** | Balanced (core context + JIT for task-specific) | More complex implementation |

## Cost Modeling

### Token Cost Calculation
Track input and output tokens separately. Rates vary by model (typically $0.003-0.075 per 1K tokens).

### Budget Enforcement
Set hard token limits per agent/session to prevent runaway costs.

### Multi-Agent Cost Attribution
Track costs per agent to identify expensive components.

See `refs/cost-calculation-budget.md` and `refs/cost-optimization-reporting.md` for detailed cost strategies.

## Context Window Strategies by Agent Pattern

**Sequential Pattern:** Pass only output of previous agent, not entire chain.

**Hierarchical Pattern:** Parent gets summaries from children, children get only relevant task context.

**Collaborative Pattern:** Shared context (compressed), each agent adds only delta.

**Autonomous Pattern:** Minimal shared context, isolated context per agent.

## Quick Wins

1. **Compress old messages:** Summarize history > 20 messages
2. **Use structured outputs:** JSON instead of prose
3. **Lazy load details:** Only when needed
4. **Set token budgets:** Hard limits per agent/session
5. **Monitor token usage:** Track and optimize high-cost agents

## References

- `refs/compression-techniques.md` - Conversation summarization, deduplication, entity compression
- `refs/selective-loading.md` - Relevance filtering, time decay, token-budgeted retrieval
- `refs/caching-and-optimization.md` - Prompt caching, semantic caching, batching, cost-aware model selection
- `refs/cost-calculation-budget.md` - Token pricing, cost calculation, budget management
- `refs/cost-optimization-reporting.md` - Cost estimation, optimization strategies, reporting
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall