filesystem-context

Offload agent context to filesystem files for dynamic retrieval and persistence.

Updated Jan 31, 2026
One-click install
npx skills add https://github.com/adrianasiam19/ATLAS --skill filesystem-context-adrianasiam19
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: filesystem-context
Source: https://github.com/adrianasiam19/ATLAS/tree/main/.agent/skills/filesystem-context
Command: npx skills add https://github.com/adrianasiam19/ATLAS --skill filesystem-context-adrianasiam19

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? LLM context windows are limited, and large tool outputs, long-running plans, and multi-agent communication quickly bloat or overflow the window, degrading agent performance. This Skill provides patterns for using the filesystem as an overflow layer so agents store, retrieve, and update context on demand instead of holding everything in the window. ## Core Features & Use Cases - Tool Output Offloading: Automatically write large tool outputs (over ~2000 tokens) to scratch files and return compact references with summaries. - Plan Persistence: Save structured multi-step plans to disk so agents can re-read objectives and progress after context refreshes or summarization. - Sub-Agent Workspaces & Dynamic Skill Loading: Route sub-agent findings through isolated file directories and load full skill instructions only when relevant. - Use Case: A web search returns 8000 tokens of results. Instead of flooding the conversation, the agent writes the output to a scratch file, keeps a 100-token summary in context, and greps the file later for specific details. ## Quick Start Ask the agent to offload large tool outputs to scratch files and persist the current task plan to disk so it can reload context on demand.

Frequently Asked Questions about filesystem-context

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I reduce LLM context window bloat from tool outputs?▼

Write tool outputs exceeding roughly 2000 tokens to scratch files and return a compact reference with a short summary instead. The agent can later grep the file or read specific line ranges to retrieve only what it needs.

How can an agent persist plans across context window refreshes?▼

Serialize the plan as structured JSON or YAML with step IDs, descriptions, and statuses, then save it to disk. The agent re-reads the file at the start of each turn or after summarization to restore awareness of the objective and progress.

When should I use filesystem-based context management?▼

Use it when tool outputs exceed about 2000 tokens, tasks span multiple turns, or multiple agents share state. Avoid it for single-turn tasks, when context fits comfortably in the window, or when file I/O latency is unacceptable.

How do sub-agents share information without message passing?▼

Give each sub-agent an isolated workspace directory where it writes findings and status files. The coordinator reads those files directly, avoiding the information degradation that occurs in multi-hop message chains.

What are the risks of agents writing their own memory files?▼

Self-modification can accumulate incorrect or contradictory instructions over time, and scratch directories can grow unbounded. Apply validation limits on stored entries, enforce retention-based cleanup, and review persisted preferences periodically.