Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Token-Plus

    3

    Reduce API costs and context bloat by enforcing targeted file reading and quiet command execution.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Token-Plus

    Token-Plus

    Example session with this skill installed

    The session is getting expensive. Audit my current context for waste and give me a brief on this project so I don't have to keep re-reading the source files.

    • Read your context and instructions
    • Compiled the token-plus

    I have audited the current session context and identified several sources of token waste, including a heavily populated node_modules listing and redundant reads of the main configuration file. I have also prepared a compact project brief to minimize future file scans.

    Context Audit & Project Brief

    CategoryFindingOptimization Action
    Waste Foundpackage-lock.json fully loaded in context (8,000+ lines).Ignored in future turns; use npm list --depth=0 instead.
    Redundancysrc/config.ts read 3 times in the last 10 turns.Cached key definitions in session notes.
    NoiseFull git log output (200 lines) occupies active context.Switched to git log --oneline -n 10.

    Project Onboarding Notes

    • Core Purpose: TypeScript-based CLI tool for repository token optimization.
    • Key Entry Point: src/index.ts:1-50 handles command routing.
    • Main Logic: src/core/optimizer.ts contains the logic for log triaging and search filtering.
    • Dependencies: Uses ripgrep for fast searching and sed for line-range extraction.
    • Exclusions: Ignore dist/, build/, and any .map files during exploration.

    Next steps

    • I will clear the package-lock.json from the current buffer to save ~24,000 tokens per turn.
    • I will use grep -E "FAIL|Error" for the next test run to avoid loading the full log.
    • Refer to these onboarding notes instead of re-reading src/index.ts.

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

    About this skill

    Long coding sessions and large codebases quickly bloat context windows, leading to high latency and soaring API costs. This skill provides a systematic framework for navigating, reading, and auditing repositories without wasting tokens on irrelevant data.

    What it does

    • Targeted Reading Locates specific definitions using narrow patterns before reading minimal line ranges in large files.
    • Output Triage Filters massive logs and test outputs to extract only failures, errors, and summaries.
    • Command Optimization Uses quiet flags and filtered listings for git, builds, and package managers to prevent terminal noise.
    • Context Hygiene Tracks findings with compact notes to prevent redundant file reads and unnecessary re-scanning.
    • Token Auditing Analyzes session history and loaded files to identify sources of waste and optimize future turns.

    How it works

    1. Locate Execute a filename or match-count search to pinpoint the target without reading file contents.
    2. Read Range Access only 40 to 120 lines around a match instead of loading the entire file.
    3. Filter Output Use POSIX tools like grep, sed, head, and tail to prune command results.
    4. Audit Review the current session context to find and remove "always-loaded" waste like lockfiles or minified assets.

    Frameworks & tools

    This skill is compatible with any AI agent that supports SKILL.md instructions, including Claude Code, Cursor, and GitHub Copilot. It relies on standard POSIX shell utilities like git, grep, rg, sed, head, and tail.

    Why this beats prompting it yourself

    Standard prompts often cause agents to ingest full files or massive log outputs by default, which can triple session costs. This skill enforces a "locate-first" behavior and provides specific command flags that agents do not typically use, ensuring context remains lean without manual intervention.

    Use cases

    • Onboarding to a massive codebase without hitting context limits immediately.
    • Debugging failing CI/CD logs that exceed thousands of lines of output.
    • Running performance-intensive tasks like deep git history searches or bulk installs.
    • Managing long-running agent sessions where cost and latency are primary concerns.

    Known limitations

    Does not optimize destructive commands, git status during active merges, or searches intended to prove non-existence. Secrets and .env files are always excluded from lean reading for safety.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Does not optimize destructive commands, git status during merges, or exhaustive searches proving non-existence. Shell tips require a POSIX environment with git and grep/rg.

    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 buying a skill.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 11 days ago

    Software
    jestNode.jsGit

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    *.md

    No external accounts or services needed. This skill only gives Claude instructions for using fewer tokens.

    Listed11 days ago

    What's inside

    Frequently Asked Questions

    Token Plus is a systematic framework designed to reduce API costs and latency by preventing AI agents from reading entire files or processing excessive terminal output. It enforces "locate-first" strategies and filtered command execution to keep your context window lean.

    This skill is compatible with any AI agent that supports custom instruction sets (SKILL.md), including Claude Code, Cursor, and GitHub Copilot. It utilizes standard POSIX shell utilities, making it functional across most modern development environments.

    You will receive the complete SKILL.md configuration file containing the optimized logic, a set of recommended shell aliases for token-efficient commands, and a guide on how to integrate these into your agent's workflow.

    Unlike generic prompts, Token Plus provides a structured protocol that forces the agent to use specific narrow-reading patterns and quiet command flags that are not part of their default behavior. This prevents "context bloat" automatically, saving you from manually pruning logs or repeatedly telling the agent to be concise.

    Setup is straightforward: you simply import the provided skill instructions into your agent's configuration or project root. The agent will immediately begin using the optimized search and read patterns defined in the framework.

    Yes, the skill is designed to exclude sensitive files like .env and secrets from its lean reading protocols to ensure security. It also avoids optimizing destructive commands or git operations during active merges to maintain data integrity.

    New in LLM Ops