IBM ALTK-Evolve Cuts Agent Token Spend by 58% to 85%

IBM Research published a head-to-head comparison with ACE (Agentic Context Engineering), Stanford/SambaNova's framework for agent self-improvement. IBM's ALTK-Evolve beats ACE on task accuracy on AppWorld while using 58.5% fewer tokens per task on DeepSeek-V3.2, and matches ACE accuracy on gpt-oss-120b while consuming 85.1% fewer tokens. The open-source framework is available now on GitHub with MCP integration for Claude Code, Codex, and IBM Bob.

Both systems address the same problem: LLM agents fail not from lack of knowledge but from inability to use tools reliably. The fix is agentic memory — turning agent trajectory history into reusable guidelines injected at inference time without weight updates or human labels. ACE and ALTK-Evolve agree on one principle: never compress lessons into a short summary. Brevity bias erases hard-won detail. ACE tracks a helpful/harmful counter per playbook bullet; ALTK-Evolve tracks a support count per guideline. Same principle, two implementations.

The core difference is delivery. ACE injects its entire playbook on every inference step for every task and model. ALTK-Evolve treats delivery as a variable: a fixed core of high-support guidelines, extended per task with a small set selected by cosine similarity or LLM-guided priority weighting. On weaker models it sends only what the model can use; on stronger models it sends the full consolidated set. ACE always transmits all guidelines.

On AppWorld — multi-step tasks across an average of 9.5 APIs and 1.8 simulated apps — with the same ReAct base agent: DeepSeek-V3.2 with ACE hits 80.4 Task Goal Completion (TGC) and 73.2 Scenario Goal Completion (SGC) at 634K tokens per task. ALTK-Evolve with DeepSeek-V3.2 hits 89.3 TGC and 80.4 SGC at 263K tokens per task. On gpt-oss-120b, ACE runs 777K tokens per task for 54.8 TGC / 35.7 SGC; ALTK-Evolve runs 116K tokens for 56.0 TGC / 37.5 SGC. On the stronger model, ALTK-Evolve wins on both axes at 41% of ACE's inference spend. On the weaker model, it matches accuracy at 15% of ACE's token budget.

Difficulty-based breakdown explains why selective delivery wins. On gpt-oss-120b, ACE's full playbook has an edge on Easy and Medium tasks — comprehensive injection helps when tasks are solvable by generic instruction-following. On Hard tasks, where the model must pick the right lesson rather than wade through all options, curated retrieval wins, and Hard tasks decide the aggregate. On DeepSeek-V3.2 the pattern flips: the model is strong enough to use a full playbook, yet ALTK-Evolve's per-task selection still wins overall, losing only Medium. IBM frames delivery as a dial rather than a fixed policy because a blanket playbook dump is suboptimal in both directions.

Integration is MCP-native. Before each agent run, the `get_guidelines` MCP tool surfaces task-specific steering; after the run, `save_trajectory` ships structured execution traces back so the store learns. A one-line Claude Code plugin install adds ALTK-Evolve to any agent. The memory store merges near-duplicates with support-conserving consolidation — when lessons merge, the surviving guideline inherits the combined support count so the store shrinks without losing the evidence behind each guideline.

For production teams, the cost context is empirical. Stanford's Digital Economy Lab paper — "How Do AI Agents Spend Your Money?" (Brynjolfsson, Pentland, Pei et al.) — found agentic coding tasks consume up to 1,000x more tokens than standard code reasoning, driven almost entirely by re-read input context, not output generation. The same paper found token costs for an identical task can vary up to 30x between runs, because agent trajectories are stochastic and models cannot predict their own spend in advance. Stanford calls this the "pricey context snowball" — each step re-reads the full accumulated history, and the history only grows. A selective-delivery memory layer that cuts per-task tokens by 58–85% while holding or improving accuracy is the clearest inference cost lever available without changing the model or hardware.

One deployment constraint: ALTK-Evolve's consolidation assumes sufficient task volume to make support counts meaningful. On low-volume workloads, the per-task cost of learning-step inference reduces gains; IBM's guidance is to measure the learn-to-do cost ratio before scaling. When that ratio is favorable, token bills drop and accuracy on hard tasks rises. That is the combination platform teams have been waiting for.