TACO – Open-Source Self-Evolving Observation Compression for Terminal Agents

1. What Is TACO

TACO is an open-source self-evolving observation compression framework for terminal agents, developed jointly by the University of Manchester, Beihang University, HKUST, and the MAP team. It addresses context bloat from accumulated shell output noise in multi-turn CLI tasks—without training, plug-and-play. It automatically discovers and reuses compression rules from terminal interaction traces, preserving critical errors while filtering redundant logs, significantly reducing token use on long-horizon tasks. Integrated into Harbor's terminus-2 component, TACO delivers 1%–4% accuracy gains on TerminalBench for models such as DeepSeek-V3.2 and Qwen3.

Image source: Official article

Technical positioning and domain: TACO sits at the intersection of NLP and agent systems, focused on context management for terminal agents. Unlike generic text compression or summarization, it is a structured observation compression framework for multi-turn command-line interaction, using rule discovery and refinement for dynamic context control.

Development background: A cross-university team with depth in agents, NLP, and software engineering. The pain point: shell noise grows with turns, flooding the context window with low-value tokens, raising cost and losing critical error signals. Prior approaches relied on hand-written rules or long-context models—ill-suited to dynamic terminal environments.

Core value: TACO breaks the cycle of output inflation → context pollution → degraded performance. Self-evolving rule discovery identifies redundancy patterns and generates compression rules without manual work. A global rule pool enables cross-task transfer so agents accumulate compression experience over time—"smarter with use." That cuts token cost and improves accuracy, providing key infrastructure for scaling terminal agents.

Technical characteristics: Three modules—rule discoverer, rule refiner, global rule pool—evolve compression online. It embeds as a plugin in existing terminal agents with no model architecture changes or fine-tuning—truly plug-and-play. The innovation is turning compression from static rules into dynamic self-evolution that adapts to changing terminal output.

2. Key Features

• Self-evolving rule discovery: Scans raw shell output across multi-turn traces, detects redundancy patterns, and generates candidate compression rules. Unlike fixed prompts or heuristics, the discoverer dynamically targets system logs, progress bars, repeated status output, and similar noise—zero manual intervention.

• Online rule refinement: Iterates rule boundaries from live task feedback, fixing over-compression or missed critical signals. The refiner monitors whether compressed output harms execution and adjusts parameters when errors are dropped or noise remains.

• Global rule pool and cross-task transfer: A persistent global knowledge base lets new tasks load rules validated in prior sessions. Compression learned debugging one repo applies immediately to another—cross-task, cross-session accumulation for faster long-horizon startup.

• Plug-and-play, no training: Embeds in terminal agents (e.g., Harbor terminus-2) via CLI flags for compression and self-evolution. No architecture changes, fine-tuning, or training—enable with launch parameters.

• Token efficiency and performance: Filters low-value terminal noise while keeping critical environment feedback, keeping multi-turn token growth linear and controlled. On TerminalBench, TACO improves MiniMax-M2.5, DeepSeek-V3.2, Qwen3-Coder-480B by 1%–4%, with ~2%–3% more under the same token budget—cost and quality together.

• Dynamic evolution: Compression is not fixed. Each turn matches the global pool first; uncovered long output triggers new discovery; validated rules merge into the pool. An external planner LLM drives the flow—no training data or model fine-tuning required.

3. How to Use

1. Install: Clone the GitHub repo, run pip install -e . at the project root. TACO works via Harbor terminus-2—install Harbor too. Python 3.8+; Linux recommended; Windows via WSL.

2. Quick start: Run Harbor with terminus-2 agent and TACO parameters. Use scripts/run_taco_example.sh as a template—swap model API URL and key. Start with defaults, then tune.

3. Core parameters: Via --ak prefix: enable_compress=True, enable_self_evo=True. Set compress_base_url, compress_api_key, compress_model_name to any OpenAI-compatible planner LLM (DeepSeek-V3.2 or Qwen3-Coder-480B recommended).

4. Modes: Full experience needs compression + self-evolution + external LLM. freeze_rules=True for fixed-rule ablations; disable_global_evo=True for single-task local evolution without the global pool. Production should keep the global pool enabled.

5. Run control: --ak max_turns=200 caps turns. Pass model_info JSON for LiteLLM input/output token limits, e.g. {"max_input_tokens": 32768, "max_output_tokens": 4096}. SWE-Bench-style tasks: 200–300 turns; simple ops: ~50.

6. Best practices: Validate on a small test set first. If critical errors are dropped, tune refiner sensitivity or planner context length. Back up the global rule pool when migrating environments.

4. Pros and Cons

5. Comparison with Similar Tools

Selection advice: For maximum token efficiency and cross-task knowledge, TACO is best—especially SWE-Bench-scale software engineering. Self-evolving rules improve with sustained use—ideal for long-running production. Simple terminal tasks or low complexity favor SWE-agent's mature ecosystem. OpenHands works if context cost is acceptable. CodeActAgent suits deep customization and fine-tuning at higher deploy cost.

6. Editor's Take

TACO's self-evolving rule discovery is a meaningful advance for terminal agents. Unlike fixed rules or raw long context, compression becomes a dynamic system that learns and adapts—meta-learning and online learning applied to CLI agents with real academic and practical value.

On utility, TACO tackles token cost runaway—the core blocker for scaling terminal agents. A 1%–4% gain on SWE-Bench sounds small but often means materially higher success on long tasks. Cutting tokens while preserving performance matters for DevOps agents handling thousands of long jobs daily—often 30%–50% token savings.

Best for: academic SWE-agent researchers; enterprises running automated ops and debugging; indie developers wanting easy integration.

Future potential: multimodal compression (images, log files), distributed rule sync, rule visualization, RL for discovery efficiency.

Innovation 5/5, utility 4.5/5, community 3.5/5, docs 4/5, deploy ease 5/5. Deductions for external LLM dependency and cold start—still among the most innovative open frameworks for terminal agents.

7. Use Cases

• Long-horizon SWE agents: On SWE-Bench-style multi-turn debug and compile tasks, TACO suppresses log explosions and keeps context focused on errors—hundreds of turns without pollution-driven mistakes. SWE-Bench Lite: ~40% lower average tokens, ~2% higher success.

• Automated ops and deploy: DevOps agents see redundant system status and process output; TACO discovers and compresses logs and monitors while keeping error codes and state changes—stable decisions under high-frequency polling (Kubernetes, CI/CD).

• Code review and test analysis: Filters compile warnings and pass noise; keeps failures and diffs. Regression suites with thousands of tests compress context to 10%–20% of raw size.

• Research and benchmarking: As a Harbor terminus-2 plugin for token-efficiency and long-horizon evaluation—compare models with/without compression, study cross-task rule transfer; open for extensions.

8. FAQ

Q: Do I need to modify or fine-tune my agent model?
A: No. TACO embeds as a plugin via CLI flags. An external planner LLM drives discovery and refinement; the backbone model is unchanged.

Q: Which planner LLMs are supported?
A: Any OpenAI-compatible API—DeepSeek-V3.2, Qwen3, GPT-4o, Claude 3.5, etc. DeepSeek-V3.2 or Qwen3-Coder-480B recommended. Configure compress_base_url, compress_api_key, compress_model_name.

Q: How is the global rule pool stored?
A: Persisted locally as files with trigger conditions, compression patterns, and validation status. Loaded on new tasks; backup/restore supported for migrations.

Q: How does TACO perform on 1000+ turn tasks?
A: Its strength is long horizons—explicit filtering keeps growth linear vs. exponential. At 1000 turns, context may shrink to 5%–10% of raw size while preserving key info. Set max_turns to avoid infinite loops; pool + history still need window space.

Q: How do I detect over-compression?
A: The refiner monitors task feedback and adjusts boundaries when critical errors are dropped. Use freeze_rules=True for ablations. Validate on a small test set before production.

Q: Does TACO support non-English terminals?
A: Design is language-agnostic. Rule discovery/refinement depends on the planner LLM—for Chinese Linux, use a multilingual planner (e.g., Qwen3). Compression quality is comparable to English in testing.

9. Project Links

• GitHub: https://github.com/multimodal-art-projection/TACO
• arXiv paper: http://arxiv.org/abs/2604.19572