If your team runs LLM Agents in CI (scheduled automation tasks), token costs can quietly pile up to staggering numbers. GitHub's engineering team shared a closed-loop "audit-optimize" method that cut the equivalent token cost of Agent workflows by as much as 62%. The tooling is integrated into the gh-aw CLI, and you can borrow this playbook directly.

Equivalent Tokens (ET): A Metric for Cross-Model Cost Comparison

Model prices vary widely, so comparing raw token counts means nothing. GitHub designed an "Equivalent Token (ET)" metric:

• Output tokens are weighted at 4x (output is far more expensive than input)
• Cache-read tokens are weighted at 0.1x
• Coefficients are applied by model type: Haiku 0.25x, Sonnet 1.0x, Opus 5.0x

This way, no matter which model you use, a 10% drop in ET corresponds to roughly a 10% drop in cost.

The Audit-Optimize Loop: Two Agents Running Automatically

Step 1: The Daily Token Usage Auditor

This Agent runs automatically every day and does three things:

1. Aggregates resource consumption by workflow: all Agent calls are funneled through an API proxy, and each run generates a token-usage.jsonl file
2. Flags anomalous runs: spots tasks whose consumption suddenly spikes
3. Finds the costliest tasks: ranked by priority, marking the workflows that need optimizing

Step 2: The Daily Token Optimizer

When the auditor finds a workflow worth attention, the optimizer kicks in automatically:

1. Reads the relevant source code and recent logs
2. Analyzes the sources of inefficiency
3. Automatically creates a GitHub Issue with concrete optimization suggestions

The two Agents' own token consumption is also counted in the same daily report.

The Biggest Source of Savings: Pruning MCP Tools

The most common source of inefficiency the optimizer finds is unused MCP tools.

The reason: the LLM API is fundamentally stateless, so every request has to carry the tool schemas. A GitHub MCP Server containing 40 tools can add an extra 10KB-15KB of schema content to every turn of interaction.

Concrete optimization moves:

• Delete unused tool definitions: in the smoke-test workflow, this alone reduced context per call by about 8KB-12KB
• Replace MCP calls with the gh CLI: PR diffs and file contents are instead fetched directly from the command line, with the data pre-downloaded into the working directory before the Agent starts
• Avoid exposing auth tokens: data is fetched at runtime through a transparent HTTP proxy

Measured Results

Optimization results across a dozen-plus production workflows:

Caveats

MCP pruning strategies have their limits. GitHub's own "Daily Community Attribution" workflow removed 8 unused tools, yet ET didn't drop meaningfully. The reason: in that workflow, the tool inventory made up only a small share of the overall context. Profile first to confirm the bottleneck, then make your move.

Tools You Can Use Right Away

Auditor and Optimiser ship as part of the gh-aw CLI. You can:

1. Deploy a similar token-usage.jsonl logging mechanism in your own CI
2. Take advantage of Anthropic's and OpenAI's prompt caching features
3. Use LangChain's Callback mechanism to track Agent token usage

The core idea: the cheapest LLM call is the one that never happens.

Source reference: GitHub Slashes Agent Workflow Token Spend up to 62% with Daily Audits and MCP Pruning - InfoQ