More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Context Window Manager

    1

    Your AI coding agent starts strong — remembers every architectural decision, every constraint, every file it touched.

    Free

    27 usesSecurity scanned
    context-window-manager

    context-window-manager

    Example session with this skill installed

    "I'm about to start a refactoring session across 12 files in src/auth/"

    • Read your context and instructions
    • Compiled the context-window-manager

    SCOPE: Refactoring src/auth/ module — 12 files, authentication flow
    OUT OF SCOPE: src/api/, tests/, config files
    Expected duration: ~90 minutes

    Pre-flight checks

    • CLAUDE.md exists (87 lines) ✓
    • Context usage: 8% ✓
    • Will compact at 60% with preservation rules

    Loading strategy

    1. Interface files first (auth/types.ts — 52 lines)
    2. Callers (auth/middleware.ts#L1-L40)
    3. Target files via line ranges only
    CLAUDE.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    ### The Problem Your AI coding agent starts strong — remembers every architectural decision, every constraint, every file it touched. Two hours in, it's asking questions it already answered, violating rules you stated at the start, and generating code that contradicts the patterns it established. The context window filled up, and the agent silently degraded. You don't notice until it pushes a commit that reverts a key decision from 45 minutes ago. ### What You Get - **Map your model's context budget** with a per-model table (Claude 200K, GPT-5 1M, Gemini 1M) and rough token-cost formulas so you know exactly when compaction is needed - **Apply the compaction decision tree** — at 50-70% use `/compact` with preservation rules, at 70-90% use targeted compaction, at 90%+ write a handoff doc and restart - **Write CLAUDE.md and AGENTS.md files** under 200 lines that encode project conventions, architecture decisions, and active work — loaded every session start - **Declare scope boundaries** before work begins — explicit SCOPE/OUT OF SCOPE blocks that prevent token waste on unrelated files - **Load files strategically** — line-range loading (`@file:src/module.py#L45-L80`) instead of full-file dumps, with a token-cost calculator to estimate before loading - **Recover from context death** with handoff documents that capture decisions, file changes, and next steps — so a fresh session picks up exactly where the last one left off ### Why This Beats Prompting It Yourself Without a system, you rely on the agent's "self-awareness" of its context usage — which doesn't exist. Agents don't monitor their own token consumption. They don't know they're about to lose constraints. This skill gives them a structured protocol: check the meter, compact at the right threshold, preserve what matters, discard what doesn't. The difference between a 2-hour session that stays coherent and one that falls apart at the 40-minute mark. ### Example Session You: "I'm about to start a refactoring session across 12 files in src/auth/" Agent: ``` SCOPE: Refactoring src/auth/ module — 12 files, authentication flow OUT OF SCOPE: src/api/, tests/, config files Expected duration: ~90 minutes Pre-flight checks: - CLAUDE.md exists (87 lines) ✓ - Context usage: 8% ✓ - Will compact at 60% with preservation rules Loading strategy: 1. Interface files first (auth/types.ts — 52 lines) 2. Callers (auth/middleware.ts#L1-L40) 3. Target files via line ranges only ``` ### Use Cases - Long refactor sessions spanning 10+ files across multiple directories - Multi-hour debugging sessions where constraint preservation is critical - Sessions switching between unrelated tasks — proper `/clear` between context blocks - Onboarding to an unfamiliar codebase where CLAUDE.md encodes tribal knowledge - Batch code generation that would exhaust context if all files loaded at once - Session handoff between team members using shared handoff documents ### Known Limitations This skill is a methodology, not a tool — it doesn't modify the agent's runtime or add context-window monitoring. You still need to manually track context usage or use agents that expose context meters. Some agents (older Cursor builds) don't support `/compact` with preservation instructions. ### Upgrade Path Free teaches compression and budget discipline in conversation. **Context Window Manager Pro ($9.99 one-time)** adds helper scripts for token budget tracking, window templates, and repeatable compression strategies. Upgrade for long sessions you run every day: https://www.agensi.io/skills/context-window-manager-pro

    This skill is a methodology, not a tool — it doesn't modify the agent's runtime or add context-window monitoring. You still need to manually track context usage or use agents that expose context meters. Some agents (older Cursor builds) don't support /compact with preservation instructions.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    27 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Listed5 months ago
    Updated18 days ago

    What's inside

    Frequently Asked Questions

    This skill prevents 'agent brain-drain' by implementing proactive compaction protocols and architectural maps, ensuring the AI maintains its reasoning quality and follows project rules even as conversation history grows.

    It is designed to work seamlessly with CLI-based agents like Claude Code and IDE-integrated agents like Cursor, making it ideal for developers working on complex, multi-file codebases.

    You will receive the complete Context Window Manager system, including the decision tree for token compaction, standardized session handoff protocols, and templates for lightweight project anchoring.

    No, the skill uses a 'selective loading' strategy that focuses on project maps and interface hierarchies, allowing the agent to understand your entire project structure without consuming your entire token budget.

    The framework is designed for rapid integration; you can implement the session anchoring and compaction rules in your current project in less than five minutes following the included setup guide.

    New in Agents & Orchestration