mikeparcewski/wicked-garden-agentic-context-engineering
skills/agentic/context-engineering/SKILL.md
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).
$ install --global
skillsauthnpx skillsauth add mikeparcewski/wicked-garden wicked-garden-agentic-context-engineeringInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: Jul 12, 2026, 7:04 AM49.8s6 files scanned
SKILL.md
- name:
- wicked-garden-agentic-context-engineering
- description:
- |
- Use when:
- optimizing token usage in an agentic pipeline, designing memory
- portability:
- portable
- phase_relevance:
- ["design", "review"]
- archetype_relevance:
- ["*"]
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
- Compress old messages: Summarize history > 20 messages
- Use structured outputs: JSON instead of prose
- Lazy load details: Only when needed
- Set token budgets: Hard limits per agent/session
- Monitor token usage: Track and optimize high-cost agents
References
refs/compression-techniques.md- Conversation summarization, deduplication, entity compressionrefs/selective-loading.md- Relevance filtering, time decay, token-budgeted retrievalrefs/caching-and-optimization.md- Prompt caching, semantic caching, batching, cost-aware model selectionrefs/cost-calculation-budget.md- Token pricing, cost calculation, budget managementrefs/cost-optimization-reporting.md- Cost estimation, optimization strategies, reporting
Related Skills
mikeparcewski/wicked-garden-engineering-conformance-reviewer
development
VerifiedTrustedCommunity
Pattern-conformance agent-half: evaluates a produced artifact or diff against a set of architectural/design pattern rules from the conformance-rule store (wicked_governance schema). Returns structured findings with rule ID, severity, and rationale — the deterministic half (mechanical rule recall) is done by the guard pipeline; this is the semantic evaluation step. Triggered by: the guard_pipeline `outgov_pattern` check (session-close), or explicitly by an engineering review when WICKED_OUTGOV_RULES_DIR is populated. NOT a replacement for the full `engineering` review skill — focuses only on conformance to stored Pattern rules; architecture and code-quality checks live in the `engineering` skill. Semantic evaluation reuses `wicked-garden-qe-semantic-reviewer` as the designated agent-half evaluator (per garden#983 spec). This skill is the orchestrating wrapper that loads applicable Pattern rules and delegates the per-rule semantic judgment to qe-semantic-reviewer.
8SKILL.mdUpdated Jul 22, 2026
mikeparcewski/wicked-garden-domain
tools
VerifiedTrustedCommunity
The FOUNDATIONAL domain-model capability: extract a codebase's domain — testable business rules (with confidence + provenance), entities, requirements — as a schema-conformant model on the estate graph. The workers annotate the store; wicked-core reads it and builds the requirements graph, coverage-gating fail-closed. Steers three fork workers. A shared substrate, not a modernization tool. The `modernize` archetype DERIVES from it; build / migrate / review / specify / explore consume the SAME domain model — none OWN it. Understanding a codebase's domain is upstream of almost everything else garden does. Use when: "extract the business rules / domain model from this codebase", "build a requirements graph from the code", "what does this system actually require", "reverse-engineer the domain before we build/port/migrate". Works on ANY codebase (modern or legacy) — the value is the domain model, not the porting. NOT the code transform itself (that is the archetype consuming this model). This skill produces the DOMAIN MODEL, not new code.
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-modeler
development
VerifiedTrustedCommunity
Domain-graph fork worker for the modernize archetype. Groups the estate's Louvain communities into business domains, attaches each requirement to its cluster (advisory cluster_id provenance), and invokes wicked-core's domain-graph build (which reads the annotated estate store, recomputes coverage fail-closed, and builds the requirements graph) — then validates core's output against the vendored schema. Use when: dispatched by wicked-garden-domain after rule extraction to turn a flat rule set into cluster-keyed domains; "group these into domains", "build the requirements graph", "translate clusters into a domain model". NOT for mining the rules themselves (that is domain-extractor) or threat-modeling (that is domain-coverage).
8SKILL.mdUpdated Jul 15, 2026
mikeparcewski/wicked-garden-domain-extractor
tools
VerifiedTrustedCommunity
Rule-extraction fork worker for the FOUNDATIONAL domain-model capability. Mines testable business rules from a codebase — each with a numeric confidence and a provenance{source, ref, source_kinds} — and annotates them into the estate store so wicked-core can build the domain-model requirements graph (coverage-gated). This is a substrate, not a modernization tool: the `modernize` archetype DERIVES from it, and build / migrate / review / specify / explore can consume the same domain model — none OWN it. Use when: dispatched by wicked-garden-domain to mine the business_rules of a codebase (or a module); "extract the domain rules", "what does this system require", building the requirements half of a domain model. NOT for grouping into domains (that is domain-modeler) or judging coverage (that is domain-coverage — a seat-distinct evaluator).
8SKILL.mdUpdated Jul 15, 2026