--- name: filesystem-context-4bec1a167478 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. --- # 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 --- Source attribution: pinkpixel-dev Original project: https://github.com/pinkpixel-dev/skills-collection-1/blob/dc709653773653302e333a45d3b6f3b70fdff8f8/SKILLS/filesystem-context/SKILL.md License: Apache-2.0 License information: https://www.apache.org/licenses/LICENSE-2.0 Original upstream instructions; downloaded from Mega AI Hub. ## Upstream license notice Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2026 Pink Pixel Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. # Mega AI Hub resource metadata Creator / publisher: pinkpixel-dev Original project: https://github.com/pinkpixel-dev/skills-collection-1/blob/dc709653773653302e333a45d3b6f3b70fdff8f8/SKILLS/filesystem-context/SKILL.md Attribution basis: Source repository record Fields of work: Development & Engineering, Product Management Roles: Backend Developer, Data Engineer, DevOps / SRE, ML / AI Engineer, Product Manager Specialties: API, Backend Tools: Filesystem Country applicability: Country not specified Classification basis: Source catalog labels Instruction SHA-256: 13ad56b8c8e7484f4d51cf2dfee0d0b3cc1acf88b94edfb8e51b0e5044b65643