@bastani/atomic 0.7.17-1 → 0.8.0-0

package/dist/builtin/workflows/skills/workflow/references/context-engineering/evaluation.md

@@ -0,0 +1,253 @@
+---
+name: evaluation
+description: This skill should be used when the user asks to "evaluate agent performance", "build test framework", "measure agent quality", "create evaluation rubrics", or mentions LLM-as-judge, multi-dimensional evaluation, agent testing, or quality gates for agent pipelines. Part of the context engineering skill suite — also activates when the user mentions "context engineering" or "context-engineering" in the context of measuring agent effectiveness.
+metadata:
+  provider: atomic
+---
+
+# Evaluation Methods for Agent Systems
+
+Evaluate agent systems differently from traditional software because agents make dynamic decisions, are non-deterministic between runs, and often lack single correct answers. Build evaluation frameworks that account for these characteristics, provide actionable feedback, catch regressions, and validate that context engineering choices achieve intended effects.
+
+## When to Activate
+
+Activate this skill when:
+- Testing agent performance systematically
+- Validating context engineering choices
+- Measuring improvements over time
+- Catching regressions before deployment
+- Building quality gates for agent pipelines
+- Comparing different agent configurations
+- Evaluating production systems continuously
+
+## Core Concepts
+
+Focus evaluation on outcomes rather than execution paths, because agents may find alternative valid routes to goals. Judge whether the agent achieves the right outcome via a reasonable process, not whether it followed a specific sequence of steps.
+
+Use multi-dimensional rubrics instead of single scores because one number hides critical failures in specific dimensions. Capture factual accuracy, completeness, citation accuracy, source quality, and tool efficiency as separate dimensions, then weight them for the use case.
+
+Deploy LLM-as-judge for scalable evaluation across large test sets while supplementing with human review to catch edge cases, hallucinations, and subtle biases that automated evaluation misses.
+
+**Performance Drivers: The 95% Finding**
+
+Apply the BrowseComp research finding when designing evaluation budgets: three factors explain 95% of browsing agent performance variance.
+
+| Factor | Variance Explained | Implication |
+|--------|-------------------|-------------|
+| Token usage | 80% | More tokens = better performance |
+| Number of tool calls | ~10% | More exploration helps |
+| Model choice | ~5% | Better models multiply efficiency |
+
+Act on these implications when designing evaluations:
+- **Set realistic token budgets**: Evaluate agents with production-realistic token limits, not unlimited resources, because token usage drives 80% of variance.
+- **Prioritize model upgrades over token increases**: Upgrading model versions provides larger gains than doubling token budgets on previous versions because better models use tokens more efficiently.
+- **Validate multi-agent architectures**: The finding supports distributing work across agents with separate context windows, so evaluate multi-agent setups against single-agent baselines.
+
+## Detailed Topics
+
+### Evaluation Challenges
+
+**Handle Non-Determinism and Multiple Valid Paths**
+
+Design evaluations that tolerate path variation because agents may take completely different valid paths to reach goals. One agent might search three sources while another searches ten; both may produce correct answers. Avoid checking for specific steps. Instead, define outcome criteria (correctness, completeness, quality) and score against those, treating the execution path as informational rather than evaluative.
+
+**Test Context-Dependent Failures**
+
+Evaluate across a range of complexity levels and interaction lengths because agent failures often depend on context in subtle ways. An agent might succeed on simple queries but fail on complex ones, work well with one tool set but fail with another, or degrade after extended interaction as context accumulates. Include simple, medium, complex, and very complex test cases to surface these patterns.
+
+**Score Composite Quality Dimensions Separately**
+
+Break agent quality into separate dimensions (factual accuracy, completeness, coherence, tool efficiency, process quality) and score each independently because an agent might score high on accuracy but low on efficiency, or vice versa. Then compute weighted aggregates tuned to use-case priorities. This approach reveals which dimensions need improvement rather than averaging away the signal.
+
+### Evaluation Rubric Design
+
+**Build Multi-Dimensional Rubrics**
+
+Define rubrics covering key dimensions with descriptive levels from excellent to failed. Include these core dimensions and adapt weights per use case:
+
+- Factual accuracy: Claims match ground truth (weight heavily for knowledge tasks)
+- Completeness: Output covers requested aspects (weight heavily for research tasks)
+- Citation accuracy: Citations match claimed sources (weight for trust-sensitive contexts)
+- Source quality: Uses appropriate primary sources (weight for authoritative outputs)
+- Tool efficiency: Uses right tools a reasonable number of times (weight for cost-sensitive systems)
+
+**Convert Rubrics to Numeric Scores**
+
+Map dimension assessments to numeric scores (0.0 to 1.0), apply per-dimension weights, and calculate weighted overall scores. Set passing thresholds based on use-case requirements, typically 0.7 for general use and 0.9 for high-stakes applications. Store individual dimension scores alongside the aggregate because the breakdown drives targeted improvement.
+
+### Evaluation Methodologies
+
+**Use LLM-as-Judge for Scale**
+
+Build LLM-based evaluation prompts that include: clear task description, the agent output under test, ground truth when available, an evaluation scale with explicit level descriptions, and a request for structured judgment with reasoning. LLM judges provide consistent, scalable evaluation across large test sets. Use a different model family than the agent being evaluated to avoid self-enhancement bias.
+
+**Supplement with Human Evaluation**
+
+Route edge cases, unusual queries, and a random sample of production traffic to human reviewers because humans notice hallucinated answers, system failures, and subtle biases that automated evaluation misses. Track patterns across human reviews to identify systematic issues and feed findings back into automated evaluation criteria.
+
+**Apply End-State Evaluation for Stateful Agents**
+
+For agents that mutate persistent state (files, databases, configurations), evaluate whether the final state matches expectations rather than how the agent got there. Define expected end-state assertions and verify them programmatically after each test run.
+
+### Test Set Design
+
+**Select Representative Samples**
+
+Start with small samples (20-30 cases) during early development when changes have dramatic impacts and low-hanging fruit is abundant. Scale to 50+ cases for reliable signal as the system matures. Sample from real usage patterns, add known edge cases, and ensure coverage across complexity levels.
+
+**Stratify by Complexity**
+
+Structure test sets across complexity levels to prevent easy examples from inflating scores:
+- Simple: single tool call, factual lookup
+- Medium: multiple tool calls, comparison logic
+- Complex: many tool calls, significant ambiguity
+- Very complex: extended interaction, deep reasoning, synthesis
+
+Report scores per stratum alongside overall scores to reveal where the agent actually struggles.
+
+### Context Engineering Evaluation
+
+**Validate Context Strategies Systematically**
+
+Run agents with different context strategies on the same test set and compare quality scores, token usage, and efficiency metrics. This isolates the effect of context engineering from other variables and prevents anecdote-driven decisions.
+
+**Run Degradation Tests**
+
+Test how context degradation affects performance by running agents at different context sizes. Identify performance cliffs where context becomes problematic and establish safe operating limits. Feed these limits back into context management strategies.
+
+### Continuous Evaluation
+
+**Build Automated Evaluation Pipelines**
+
+Integrate evaluation into the development workflow so evaluations run automatically on agent changes. Track results over time, compare versions, and block deployments that regress on key metrics.
+
+**Monitor Production Quality**
+
+Sample production interactions and evaluate them continuously. Set alerts for quality drops below warning (0.85 pass rate) and critical (0.70 pass rate) thresholds. Maintain dashboards showing trend analysis over time windows to detect gradual degradation.
+
+## Practical Guidance
+
+### Building Evaluation Frameworks
+
+Follow this sequence to build an evaluation framework, because skipping early steps leads to measurements that do not reflect real quality:
+
+1. Define quality dimensions relevant to the use case before writing any evaluation code, because dimensions chosen later tend to reflect what is easy to measure rather than what matters.
+2. Create rubrics with clear, descriptive level definitions so evaluators (human or LLM) produce consistent scores.
+3. Build test sets from real usage patterns and edge cases, stratified by complexity, with at least 50 cases for reliable signal.
+4. Implement automated evaluation pipelines that run on every significant change.
+5. Establish baseline metrics before making changes so improvements can be measured against a known reference.
+6. Run evaluations on all significant changes and compare against the baseline.
+7. Track metrics over time for trend analysis because gradual degradation is harder to notice than sudden drops.
+8. Supplement automated evaluation with human review on a regular cadence.
+
+### Avoiding Evaluation Pitfalls
+
+Guard against these common failures that undermine evaluation reliability:
+
+- **Overfitting to specific paths**: Evaluate outcomes, not specific steps, because agents find novel valid paths.
+- **Ignoring edge cases**: Include diverse test scenarios covering the full complexity spectrum.
+- **Single-metric obsession**: Use multi-dimensional rubrics because a single score hides dimension-specific failures.
+- **Neglecting context effects**: Test with realistic context sizes and histories rather than clean-room conditions.
+- **Skipping human evaluation**: Automated evaluation misses subtle issues that humans catch reliably.
+
+## Examples
+
+**Example 1: Simple Evaluation**
+```python
+def evaluate_agent_response(response, expected):
+    rubric = load_rubric()
+    scores = {}
+    for dimension, config in rubric.items():
+        scores[dimension] = assess_dimension(response, expected, dimension)
+    overall = weighted_average(scores, config["weights"])
+    return {"passed": overall >= 0.7, "scores": scores}
+```
+
+**Example 2: Test Set Structure**
+
+Test sets should span multiple complexity levels to ensure comprehensive evaluation:
+
+```python
+test_set = [
+    {
+        "name": "simple_lookup",
+        "input": "What is the capital of France?",
+        "expected": {"type": "fact", "answer": "Paris"},
+        "complexity": "simple",
+        "description": "Single tool call, factual lookup"
+    },
+    {
+        "name": "medium_query",
+        "input": "Compare the revenue of Apple and Microsoft last quarter",
+        "complexity": "medium",
+        "description": "Multiple tool calls, comparison logic"
+    },
+    {
+        "name": "multi_step_reasoning",
+        "input": "Analyze sales data from Q1-Q4 and create a summary report with trends",
+        "complexity": "complex",
+        "description": "Many tool calls, aggregation, analysis"
+    },
+    {
+        "name": "research_synthesis",
+        "input": "Research emerging AI technologies, evaluate their potential impact, and recommend adoption strategy",
+        "complexity": "very_complex",
+        "description": "Extended interaction, deep reasoning, synthesis"
+    }
+]
+```
+
+## Guidelines
+
+1. Use multi-dimensional rubrics, not single metrics
+2. Evaluate outcomes, not specific execution paths
+3. Cover complexity levels from simple to complex
+4. Test with realistic context sizes and histories
+5. Run evaluations continuously, not just before release
+6. Supplement LLM evaluation with human review
+7. Track metrics over time for trend detection
+8. Set clear pass/fail thresholds based on use case
+
+## Gotchas
+
+1. **Overfitting evals to specific code paths**: Tests pass but the agent fails on slight input variations. Write eval criteria against outcomes and semantics, not surface patterns, and rotate test inputs periodically.
+2. **LLM-judge self-enhancement bias**: Models rate their own outputs higher than independent judges do. Use a different model family as the evaluation judge than the model being evaluated.
+3. **Test set contamination**: Eval examples leak into training data or prompt templates, inflating scores. Keep eval sets versioned and separate from any data used in prompts or fine-tuning.
+4. **Metric gaming**: Optimizing for the metric rather than actual quality produces agents that score well but disappoint users. Cross-validate automated metrics against human judgments regularly.
+5. **Single-dimension scoring**: One aggregate number hides critical failures in specific dimensions. Always report per-dimension scores alongside the overall score, and fail the eval if any single dimension falls below its minimum threshold.
+6. **Eval set too small**: Fewer than 50 examples produces unreliable signal with high variance between runs. Scale the eval set to at least 50 cases and report confidence intervals.
+7. **Not stratifying by difficulty**: Easy examples inflate overall scores, masking failures on hard cases. Report scores per complexity stratum and weight the overall score to prevent easy-case dominance.
+8. **Treating eval as one-time**: Evaluation must be continuous, not a launch gate. Agent quality drifts as models update, tools change, and usage patterns evolve. Run evals on every change and on a regular production cadence.
+
+## Integration
+
+This skill connects to all other skills as a cross-cutting concern:
+
+- context-fundamentals - Evaluating context usage
+- context-degradation - Detecting degradation
+- context-optimization - Measuring optimization effectiveness
+- multi-agent-patterns - Evaluating coordination
+- tool-design - Evaluating tool effectiveness
+- memory-systems - Evaluating memory quality
+
+## References
+
+Internal reference:
+- [Metrics Reference](./references/metrics.md) - Read when: designing specific evaluation metrics, choosing scoring scales, or implementing weighted rubric calculations
+
+Internal skills:
+- All other skills connect to evaluation for quality measurement
+
+External resources:
+- LLM evaluation benchmarks - Read when: selecting or building benchmark suites for agent comparison
+- Agent evaluation research papers - Read when: adopting new evaluation methodologies or validating current approach
+- Production monitoring practices - Read when: setting up alerting, dashboards, or sampling strategies for live systems
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2026-03-17
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.1.0

package/dist/builtin/workflows/skills/workflow/references/context-engineering/filesystem-context.md

@@ -0,0 +1,289 @@
+---
+name: filesystem-context
+description: This skill should be used when the user asks to "offload context to files", "implement dynamic context discovery", "use filesystem for agent memory", "reduce context window bloat", or mentions file-based context management, tool output persistence, agent scratch pads, or just-in-time context loading. A core context engineering skill — also activates when the user mentions "context engineering" or "context-engineering" in the context of extending context beyond the window via filesystem strategies.
+metadata:
+  provider: atomic
+---
+
+# Filesystem-Based Context Engineering
+
+Use the filesystem as the primary overflow layer for agent context because context windows are limited while tasks often require more information than fits in a single window. Files let agents store, retrieve, and update an effectively unlimited amount of context through a single interface.
+
+Prefer dynamic context discovery -- pulling relevant context on demand -- over static inclusion, because static context consumes tokens regardless of relevance and crowds out space for task-specific information.
+
+## When to Activate
+
+Activate this skill when:
+- Tool outputs are bloating the context window
+- Agents need to persist state across long trajectories
+- Sub-agents must share information without direct message passing
+- Tasks require more context than fits in the window
+- Building agents that learn and update their own instructions
+- Implementing scratch pads for intermediate results
+- Terminal outputs or logs need to be accessible to agents
+
+## Core Concepts
+
+Diagnose context failures against these four modes, because each requires a different filesystem remedy:
+
+1. **Missing context** -- needed information is absent from the total available context. Fix by persisting tool outputs and intermediate results to files so nothing is lost.
+2. **Under-retrieved context** -- retrieved content fails to encapsulate what the agent needs. Fix by structuring files for targeted retrieval (grep-friendly formats, clear section headers).
+3. **Over-retrieved context** -- retrieved content far exceeds what is needed, wasting tokens and degrading attention. Fix by offloading bulk content to files and returning compact references.
+4. **Buried context** -- niche information is hidden across many files. Fix by combining glob and grep for structural search alongside semantic search for conceptual queries.
+
+Use the filesystem as the persistent layer that addresses all four: write once, store durably, retrieve selectively.
+
+## Detailed Topics
+
+### The Static vs Dynamic Context Trade-off
+
+Treat static context (system instructions, tool definitions, critical rules) as expensive real estate -- it consumes tokens on every turn regardless of relevance. As agents accumulate capabilities, static context grows and crowds out dynamic information.
+
+Use dynamic context discovery instead: include only minimal static pointers (names, one-line descriptions, file paths) and load full content with search tools when relevant. This is more token-efficient and often improves response quality by reducing contradictory or irrelevant information in the window.
+
+Accept the trade-off: dynamic discovery requires the model to recognize when it needs more context. Current frontier models handle this well, but less capable models may fail to trigger loads. When in doubt, err toward including critical safety or correctness constraints statically.
+
+### Pattern 1: Filesystem as Scratch Pad
+
+Redirect large tool outputs to files instead of returning them directly to context, because a single web search or database query can dump thousands of tokens into message history where they persist for the entire conversation.
+
+Write the output to a scratch file, extract a compact summary, and return a file reference. The agent then uses targeted retrieval (grep for patterns, read with line ranges) to access only what it needs.
+
+```python
+def handle_tool_output(output: str, threshold: int = 2000) -> str:
+    if len(output) < threshold:
+        return output
+
+    file_path = f"scratch/{tool_name}_{timestamp}.txt"
+    write_file(file_path, output)
+
+    key_summary = extract_summary(output, max_tokens=200)
+    return f"[Output written to {file_path}. Summary: {key_summary}]"
+```
+
+Use grep to search the offloaded file and read_file with line ranges to retrieve targeted sections, because this preserves full output for later reference while keeping only ~100 tokens in the active context.
+
+### Pattern 2: Plan Persistence
+
+Write plans to the filesystem because long-horizon tasks lose coherence when plans fall out of attention or get summarized away. The agent re-reads its plan at any point, restoring awareness of the objective and progress.
+
+Store plans in structured format so they are both human-readable and machine-parseable:
+```yaml
+# scratch/current_plan.yaml
+objective: "Refactor authentication module"
+status: in_progress
+steps:
+  - id: 1
+    description: "Audit current auth endpoints"
+    status: completed
+  - id: 2
+    description: "Design new token validation flow"
+    status: in_progress
+  - id: 3
+    description: "Implement and test changes"
+    status: pending
+```
+
+Re-read the plan at the start of each turn or after any context refresh to re-orient, because this acts as "manipulating attention through recitation."
+
+### Pattern 3: Sub-Agent Communication via Filesystem
+
+Route sub-agent findings through the filesystem instead of message passing, because multi-hop message chains degrade information through summarization at each hop ("game of telephone").
+
+Have each sub-agent write directly to its own workspace directory. The coordinator reads these files directly, preserving full fidelity:
+```
+workspace/
+  agents/
+    research_agent/
+      findings.md
+      sources.jsonl
+    code_agent/
+      changes.md
+      test_results.txt
+  coordinator/
+    synthesis.md
+```
+
+Enforce per-agent directory isolation to prevent write conflicts and maintain clear ownership of each output artifact.
+
+### Pattern 4: Dynamic Skill Loading
+
+Store skills as files and include only skill names with brief descriptions in static context, because stuffing all instructions into the system prompt wastes tokens and can confuse the model with contradictory guidance.
+
+```
+Available skills (load with read_file when relevant):
+- database-optimization: Query tuning and indexing strategies
+- api-design: REST/GraphQL best practices
+- testing-strategies: Unit, integration, and e2e testing patterns
+```
+
+Load the full skill file (e.g., `skills/database-optimization/SKILL.md`) only when the current task requires it. This converts O(n) static token cost into O(1) per task.
+
+### Pattern 5: Terminal and Log Persistence
+
+Persist terminal output to files automatically and use grep for selective retrieval, because terminal output from long-running processes accumulates rapidly and manual copy-paste is error-prone.
+
+```
+terminals/
+  1.txt    # Terminal session 1 output
+  2.txt    # Terminal session 2 output
+```
+
+Query with targeted grep (`grep -A 5 "error" terminals/1.txt`) instead of loading entire terminal histories into context.
+
+### Pattern 6: Learning Through Self-Modification
+
+Have agents write learned preferences and patterns to their own instruction files so subsequent sessions load this context automatically, instead of requiring manual system prompt updates.
+
+```python
+def remember_preference(key: str, value: str):
+    preferences_file = "agent/user_preferences.yaml"
+    prefs = load_yaml(preferences_file)
+    prefs[key] = value
+    write_yaml(preferences_file, prefs)
+```
+
+Guard this pattern with validation because self-modification can accumulate incorrect or contradictory instructions over time. Treat it as experimental -- review persisted preferences periodically.
+
+### Filesystem Search Techniques
+
+Combine `ls`/`list_dir`, `glob`, `grep`, and `read_file` with line ranges for context discovery, because models are specifically trained on filesystem traversal and this combination often outperforms semantic search for technical content where structural patterns are clear.
+
+- `ls` / `list_dir`: Discover directory structure
+- `glob`: Find files matching patterns (e.g., `**/*.py`)
+- `grep`: Search file contents, returns matching lines with context
+- `read_file` with ranges: Read specific sections without loading entire files
+
+Use filesystem search for structural and exact-match queries, and semantic search for conceptual queries. Combine both for comprehensive discovery.
+
+## Practical Guidance
+
+### When to Use Filesystem Context
+
+Apply filesystem patterns when the situation matches these criteria, because they add I/O overhead that is only justified by token savings or persistence needs:
+
+**Use when:**
+- Tool outputs exceed ~2000 tokens
+- Tasks span multiple conversation turns
+- Multiple agents need shared state
+- Skills or instructions exceed comfortable system prompt size
+- Logs or terminal output need selective querying
+
+**Avoid when:**
+- Tasks complete in single turns (overhead not justified)
+- Context fits comfortably in window (no problem to solve)
+- Latency is critical (file I/O adds measurable delay)
+- Model lacks filesystem tool capabilities
+
+### File Organization
+
+Structure files for agent discoverability, because agents navigate by listing and reading directory names:
+```
+project/
+  scratch/           # Temporary working files
+    tool_outputs/    # Large tool results
+    plans/           # Active plans and checklists
+  memory/            # Persistent learned information
+    preferences.yaml # User preferences
+    patterns.md      # Learned patterns
+  skills/            # Loadable skill definitions
+  agents/            # Sub-agent workspaces
+```
+
+Use consistent naming conventions and include timestamps or IDs in scratch files for disambiguation.
+
+### Token Accounting
+
+Measure where tokens originate before and after applying filesystem patterns, because optimizing without measurement leads to wasted effort:
+- Track static vs dynamic context ratio
+- Monitor tool output sizes before and after offloading
+- Measure how often dynamically-loaded context is actually used
+
+## Examples
+
+**Example 1: Tool Output Offloading**
+```
+Input: Web search returns 8000 tokens
+Before: 8000 tokens added to message history
+After:
+  - Write to scratch/search_results_001.txt
+  - Return: "[Results in scratch/search_results_001.txt. Key finding: API rate limit is 1000 req/min]"
+  - Agent greps file when needing specific details
+Result: ~100 tokens in context, 8000 tokens accessible on demand
+```
+
+**Example 2: Dynamic Skill Loading**
+```
+Input: User asks about database indexing
+Static context: "database-optimization: Query tuning and indexing"
+Agent action: read_file("skills/database-optimization/SKILL.md")
+Result: Full skill loaded only when relevant
+```
+
+**Example 3: Chat History as File Reference**
+```
+Trigger: Context window limit reached, summarization required
+Action:
+  1. Write full history to history/session_001.txt
+  2. Generate summary for new context window
+  3. Include reference: "Full history in history/session_001.txt"
+Result: Agent can search history file to recover details lost in summarization
+```
+
+## Guidelines
+
+1. Write large outputs to files; return summaries and references to context
+2. Store plans and state in structured files for re-reading
+3. Use sub-agent file workspaces instead of message chains
+4. Load skills dynamically rather than stuffing all into system prompt
+5. Persist terminal and log output as searchable files
+6. Combine grep/glob with semantic search for comprehensive discovery
+7. Organize files for agent discoverability with clear naming
+8. Measure token savings to validate filesystem patterns are effective
+9. Implement cleanup for scratch files to prevent unbounded growth
+10. Guard self-modification patterns with validation
+
+## Gotchas
+
+1. **Scratch directory unbounded growth**: Agents create temp files without cleanup, eventually consuming disk and making directory listings noisy. Implement a retention policy (age-based or count-based) and run cleanup at session boundaries.
+2. **Race conditions in multi-agent file access**: Concurrent writes to the same file corrupt state silently. Enforce per-agent directory isolation or use append-only files with agent-prefixed entries.
+3. **Stale file references after moves/renames**: Agents hold paths from prior turns that no longer exist after refactors or file reorganization. Always verify file existence before reading a cached path; re-discover with glob if the check fails.
+4. **Glob pattern false matches**: Overly broad patterns (e.g., `**/*`) pull irrelevant files into context, wasting tokens and confusing the model. Scope globs to specific directories and extensions.
+5. **File size assumptions**: Reading a file without checking size can dump 100K+ tokens into context in a single tool call. Check file size before reading; use line-range reads for large files.
+6. **Missing file existence checks**: Agents assume files exist from prior turns, but they may have been deleted or moved. Always guard reads with existence checks and handle missing-file errors gracefully.
+7. **Scratch pad format drift**: Unstructured scratch pads become unparseable after many writes because format conventions erode over successive appends. Define and enforce a schema (YAML, JSON, or structured markdown) from the first write.
+8. **Hardcoded absolute paths**: Break when repositories are checked out at different locations or when running in containers. Use relative paths from the project root or resolve paths dynamically.
+
+## Integration
+
+This skill connects to:
+
+- context-optimization - Filesystem offloading is a form of observation masking
+- memory-systems - Filesystem-as-memory is a simple memory layer
+- multi-agent-patterns - Sub-agent file workspaces enable isolation
+- context-compression - File references enable lossless "compression"
+- tool-design - Tools should return file references for large outputs
+
+## References
+
+Internal reference:
+- [Implementation Patterns](./references/implementation-patterns.md) - Read when: implementing scratch pad, plan persistence, or tool output offloading and need concrete code beyond the inline examples
+
+Related skills in this collection:
+- context-optimization - Read when: applying token reduction techniques alongside filesystem offloading
+- memory-systems - Read when: building persistent storage that outlasts a single session
+- multi-agent-patterns - Read when: designing agent coordination with shared file workspaces
+
+External resources:
+- LangChain Deep Agents — Read when: implementing filesystem-based context patterns in LangChain/LangGraph pipelines
+- Cursor context discovery — Read when: studying how production IDEs implement dynamic context loading
+- Anthropic Agent Skills specification — Read when: building skills that leverage filesystem progressive disclosure
+
+---
+
+## Skill Metadata
+
+**Created**: 2026-01-07
+**Last Updated**: 2026-03-17
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.1.0