filesystem-context

Offload large tool outputs to persistent scratch files and reload plans.

3|Updated Mar 22, 2026
One-click install
npx skills add https://github.com/0xharryriddle/codex-field-kit --skill filesystem-context-0xharryriddle
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: filesystem-context
Source: https://github.com/0xharryriddle/codex-field-kit/tree/main/archive/upstream/chasebuild-agent-skills/context-engineering/skills/filesystem-context
Command: npx skills add https://github.com/0xharryriddle/codex-field-kit --skill filesystem-context-0xharryriddle

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

The filesystem-based context engineering approach reduces prompt bloat by offloading large tool outputs, state data, and logs to persistent files, enabling dynamic loading of relevant context on demand.

Core Features & Use Cases

  • Scratch Pad Manager: write bulky outputs to scratch files and reference them to preserve token budgets.
  • Plan Persistence: store and reload long-horizon task plans to survive context refreshes.
  • Tool Output Handler: automatically offload oversized outputs and provide concise references for retrieval.
  • Dynamic Skill Loading: load and reveal only relevant skills content when needed, keeping the system prompt lean.
  • Terminal/Log Persistence: capture terminal outputs for search and replay without bloating context.
  • Sub-Agent Workspaces: coordinate information through filesystem-based spaces for isolation and fidelity.

Quick Start

Initialize the filesystem context harness and run demo_scratch_pad to offload a sample output and load a saved plan.

Frequently Asked Questions about filesystem-context

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

FAQPage Schema
How do I reduce context size when an agent generates large tool outputs?

Context engineering offloads large tool outputs to persistent filesystem scratch areas, reducing prompt bloat by storing state data and logs externally. It enables dynamic loading of relevant context on demand to preserve token budgets.

How do I persist task plans across context refreshes for long-horizon agents?

Persisting long-horizon task plans to the filesystem allows agents to survive context refreshes by reloading stored plans. This maintains task coordination and state continuity across sub-agents during extended operations.

What is the best way to coordinate sub-agents without exceeding token limits?

The best way to coordinate sub-agents within token limits is using filesystem-based workspaces for information exchange. This approach isolates sub-agent tasks through file directories, maintaining fidelity and traceability without bloating the main context.

Can I dynamically load agent skills only when needed to keep the system prompt lean?

Yes, dynamically loading skill content only when needed keeps the system prompt lean by revealing relevant skills on demand. This approach preserves token budgets for active tasks while maintaining access to the full skill library.

How do I capture and replay terminal outputs without bloating agent context?

Capturing terminal outputs without context bloat is achieved by persisting logs directly to the filesystem. Terminal outputs become searchable and replayable through file-based references, avoiding context bloat from full text loading.

What are the limitations of filesystem-based context engineering for agent memory?

Filesystem-based context engineering requires managing file paths and retrieval logic manually, adding operational overhead. It is less suitable for highly ephemeral data or environments lacking persistent storage access for scratch files.