filesystem-context

Persist agent context to filesystem for memory beyond token limits.

Updated Apr 25, 2026
One-click install
npx skills add https://github.com/nshaikhs/claude-code-for-operators --skill filesystem-context-nshaikhs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: filesystem-context
Source: https://github.com/nshaikhs/claude-code-for-operators/tree/main/skills/context-engineering/skills/filesystem-context
Command: npx skills add https://github.com/nshaikhs/claude-code-for-operators --skill filesystem-context-nshaikhs

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Filesystem-based context engineering lets you offload large context pieces to disk and reuse them later, reducing token pressure and enabling persistent agent memory.

Core Features & Use Cases

  • Scratch Pad offloading: offload large tool outputs to files and return compact references for context.
  • Plan persistence: persist agent plans to disk so long-horizon tasks survive context window refreshes.
  • Sub-agent workspaces: per-agent file-based workspaces that isolate outputs and enable coordination.
  • Dynamic skill loading: load full skill content on-demand from indexed SKILL.md fronts when needed.
  • Terminal/log persistence: capture terminal output and logs to files for later search and audit.
  • Self-modification guard: guarded storage for learned preferences with validation to prevent drift.

Quick Start

Set up a ScratchPadManager, persist your current plan to disk, and offload large tool outputs to scratch files for later reference.

Frequently Asked Questions about filesystem-context

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

FAQPage Schema
How do I persist agent context to the filesystem to extend memory beyond token limits?

You can persist agent context to the filesystem by offloading large tool outputs to scratch files and storing long-horizon plans on disk. This extends agent memory beyond token limits by returning compact references instead of keeping full context in memory.

What is filesystem context engineering for AI agent memory?

Filesystem context engineering is the practice of offloading large context pieces to disk for later reuse. It reduces token pressure and enables persistent agent memory by using a stable filesystem layout for scratch pads, plan persistence, and per-agent workspaces.

How do I set up a scratch pad to offload large tool outputs for AI agents?

Set up a ScratchPadManager to write large tool outputs to scratch files on disk, returning compact file references for the agent context. This process offloads bulky data from the context window while keeping the information accessible for later reference.

Can I use filesystem workspaces to isolate outputs for multi-agent collaboration?

Yes, you can create per-agent file-based workspaces to isolate outputs and enable coordination in multi-agent collaboration. These isolated filesystem layouts allow multiple agents to operate independently while maintaining structured access to their respective persistent data.

What is the best way to persist long-horizon agent plans across context window refreshes?

The best way to persist long-horizon agent plans is writing them to disk using structured plan storage conventions. This ensures tasks survive context window refreshes by allowing the agent to reload the persisted plan from the filesystem when needed.

How does dynamic skill loading from indexed SKILL.md fronts work?

Dynamic skill loading retrieves full skill content on-demand from indexed SKILL.md files when needed. This approach minimizes token usage by keeping skill metadata lightweight until the complete skill instructions are explicitly required by the agent.