Optimizing Token Usage in OpenCode: A Guide to Dynamic Context Pruning

If you've been using OpenCode for AI-assisted development, you've likely encountered a common frustration: token consumption can skyrocket with minimal effort. Full file contexts, lengthy chat histories, and agent loops often consume thousands of tokens per task, leading to higher costs and slower responses. Fortunately, there's a powerful solution that can bring token usage under control: Dynamic Context Pruning (DCP). This guide walks you through what DCP is, why it's not enabled by default, and how to implement it step by step.

Understanding Dynamic Context Pruning

Dynamic Context Pruning is a smart filtering mechanism—typically implemented as a plugin or middleware—that automatically removes irrelevant information before sending a prompt to the language model. It retains only the most essential context: active code, recent errors, and critical decisions. By enforcing token limits, DCP ensures that your prompts stay concise without sacrificing necessary details. Think of it as a smart filter that sharpens your inputs to improve both performance and cost efficiency.

Why DCP Isn't Active by Default

A common misconception is that OpenCode ships with DCP enabled out of the box. In reality, it does not. Developers must manually install a DCP plugin, register it in the configuration, and define pruning rules. This extra step allows for flexibility—different projects have varying needs—but it also means many users miss out on significant token savings simply because they aren't aware of the setup process.

Enabling DCP in OpenCode

Follow these five steps to activate DCP and start reducing token waste immediately.

1. Install the DCP Plugin

Depending on your environment, install the appropriate pruning plugin. For Node.js projects, run:

npm install opencode-dcp-plugin

For Python environments, use:

pip install opencode-dcp

This plugin will handle all context pruning logic.

2. Register the Plugin in Configuration

Open your OpenCode configuration file (JSON or YAML) and add the plugin to the plugins list. In JSON format:

{
  "plugins": ["dcp-plugin"]
}

Or in YAML:

plugins:
  - dcp-plugin

3. Define Pruning Rules

This is where you customize how DCP filters context. A sample configuration might look like this:

dcp:
  max_tokens: 8000
  strategy: smart
  keep:
    - active_file
    - recent_errors
  drop:
    - old_history
    - debug_logs

This setup keeps relevant working context and recent errors, while dropping old history and debug logs. The max_tokens setting caps total tokens before the prompt reaches the model.

4. Configure DCP for Agents

If you use agents (e.g., coder, debugger), enable DCP for each agent individually. Otherwise, agents may continue to send full context. Add this to your configuration:

agents:
  coder:
    dcp: true
  debugger:
    dcp: true

5. Verify Functionality

Run a test task and check your logs. A working DCP will produce an entry like:

[DCP] Reduced context: 18,240 → 6,120 tokens

If you see no such log, DCP is not active. Revisit your setup steps.

A Minimal Configuration for Quick Savings

If you want instant results without deep tuning, use this minimal YAML configuration:

plugins:
  - dcp-plugin

dcp:
  strategy: aggressive
  max_tokens: 6000

With this setup alone, many users report token reductions of 50–70% on typical tasks. It's a fast win that requires minimal effort.

Common Pitfalls to Avoid

Even with DCP installed, certain mistakes can nullify its benefits:

• Installing without registering – The plugin does nothing until you add it to the configuration.
• Ignoring agent configuration – Individual agents must have DCP enabled; otherwise, they bypass pruning.
• Keeping too much context – Overly permissive keep rules defeat the purpose of pruning.
• Feeding the entire repository – DCP cannot fix massive inputs; scope your prompts to specific files.

Advanced Tips for Maximum Efficiency

To get even better results, consider these strategies:

• Scope prompts to specific files or functions rather than entire codebases.
• Avoid dumping large code blocks; be selective.
• Limit agent steps to reduce cumulative token usage.
• Disable unnecessary tools that might add context bloat.

By combining DCP with thoughtful prompt engineering, you can achieve substantial savings while maintaining high-quality AI responses.

Final Thoughts

Dynamic Context Pruning is not a magic bullet, but it is one of the most impactful optimizations available for OpenCode users. By installing the plugin, configuring smart rules, and avoiding common pitfalls, you can dramatically reduce token consumption and improve both cost efficiency and response speed. Start with the minimal configuration, then refine as your needs evolve. Your wallet—and your AI—will thank you.