Agent Cognitive Compressor (ACC)

• ACC is a framework that compresses multi-turn agent interactions into a bounded, schema-governed state for effective long-horizon decision-making.
• It selectively retains operationally critical information by merging tool responses, observations, and strategic cues while discarding redundant data.
• ACC enables enhanced supervised fine-tuning and memory control, reducing hallucinations and drift compared to traditional transcript replay methods.

Agent Cognitive Compressor (ACC) is a term used in recent agent-systems literature for mechanisms that transform growing raw interaction history into bounded, decision-relevant context for reasoning and action. In one explicit formulation, ACC is a “bio-inspired memory controller” that replaces transcript replay with a bounded internal state called the Compressed Cognitive State (CCS) (Bousetouane, 15 Jan 2026). In another, ACC denotes “Agent Context Compilation,” a data-compilation strategy that converts multi-turn agent trajectories into long-context supervised fine-tuning examples by compiling scattered tool responses and environment observations into a single long input context paired with the original question and final answer (Su et al., 21 May 2026). In adjacent work on autonomous IT operations, prompt compression, and long-horizon planning, ACC-like modules likewise preserve fault signatures, constraints, action syntax, plan dependencies, and other task-critical signals while discarding redundant telemetry or structurally unsafe context (Bai et al., 15 Dec 2025).

1. Terminology, scope, and common structure

In current arXiv usage, “Agent Cognitive Compressor” does not denote a single canonical architecture. It refers to a cluster of related ideas: bounded memory control, trajectory compilation for long-context training, and context-management modules embedded inside agent systems. The common structure is selective preservation of operationally meaningful state rather than indiscriminate retention of raw text.

Formulation	Compressed object	Resulting representation
ACC / Compressed Cognitive State	Multi-turn interaction, recalled artifacts, prior commitments	Bounded schema-governed internal state
Agent Context Compilation	Tool responses and environment observations from trajectories	Long-context QA pair $(q, C)$ with final answer
AOI Context Compressor	Logs, probe outputs, execution results	Compressed strategic context cache
AGORA	Action–observation steps in agent prompts	Step-level retained prompt with elisions
ACON	Interaction histories and raw environment observations	Concise but decision-useful condensations
PAACE	Evolving working state of a planned workflow	Compressed state $\check{C}_t$ for next-$k$ tasks

Across these variants, the compressed representation is action-facing. It is consumed by a reasoner, scheduler, or downstream decoder, rather than stored as a passive summary. This suggests that ACC is best understood as a control primitive for long-horizon agents: it shapes what may persist, what may be recalled, and what receives direct supervision during training.

A recurring source of confusion is acronym overload. In birational geometry, “ACC” ordinarily means “ascending chain condition,” as in ACC for $a$-log canonical thresholds or local volumes; that usage is unrelated to agent memory, prompt compression, or long-context training (Liu, 2018).

2. ACC as bounded internal memory control

The most explicit agent-memory formulation defines ACC as a replacement for transcript replay and retrieval-based memory in long multi-turn workflows (Bousetouane, 15 Jan 2026). The core claim is that the reliability problem is not merely insufficient context length, but lack of memory control: transcript replay produces unbounded context growth and repeatedly reintroduces early mistakes, while retrieval-based memory can surface stale, noisy, or poisoned artifacts.

ACC addresses this by maintaining a single persistent internal state, the Compressed Cognitive State. CCS is described as bounded, schema-governed, updated online each turn, and the only persistent internal state carried forward. The update process separates artifact recall from state commitment. At turn $t$, ACC recalls a bounded candidate set

$$A_t = \mathcal{R}_{\mathrm{ACC}}(x_t, \mathrm{CCS}_{t-1}; \mathcal{M}),$$

filters it through a qualification gate

$$A_t^{+} = \left\{ a \in A_t \mid \mathcal{Q}(a, \mathrm{CCS}_{t-1}, x_t)=1 \right\},$$

and commits the next state under a schema constraint

$$\mathrm{CCS}_t = \mathcal{C}_{\theta}(x_t, \mathrm{CCS}_{t-1}, A_t^{+}; \mathcal{S}_{\mathrm{CCS}}).$$

The CCS schema contains typed fields including episodic trace, semantic gist, focal entities, relational map, goal orientation, constraints, predictive cue, uncertainty signal, and retrieved artifact references. The paper is explicit that CCS is not a summary and not a cache; it is a control-oriented state that encodes what the agent needs to remain coherent over time. This architecture turns the agent into a state transition machine rather than a transcript accumulator.

The distinction between artifact recall and state commitment is central. Retrieval can propose information, but only the compressor can commit it, and only under the schema. This prevents unverified or stale text from becoming persistent memory. In that sense, ACC governs memory persistence rather than merely memory access. The reasoner then acts conditioned on $(x_t, \mathrm{CCS}_t)$, while raw interactions and outcomes may still be stored externally for future recall.

The same work evaluates ACC in 50-turn live episodes across IT operations, cybersecurity response, and healthcare workflows, and also mentions finance workflows in the broader evaluation description. The comparison among transcript replay, retrieval-based memory, and ACC uses response metrics, hallucination audits, drift audits, and memory-footprint tracking. The reported qualitative pattern is that transcript replay grows near-linearly in memory size, retrieval remains bounded only because retrieval is tightly capped, and ACC remains bounded by design while exhibiting lower hallucination and lower drift (Bousetouane, 15 Jan 2026).

3. ACC as trajectory compilation for long-context training

A second major meaning of ACC is “Agent Context Compilation,” also described as an “Agent Cognitive Compressor,” in which successful multi-turn agent trajectories are transformed into long-context supervised examples for direct long-range evidence integration (Su et al., 21 May 2026). The paper’s motivation is the “supervision blind spot” of standard agent supervised fine-tuning. A trajectory is formalized as

$$\tau = (q,(r_1,a_1,o_1), \dots, (r_{k-1},a_{k-1},o_{k-1}),(r_k,y)),$$

where $\check{C}_t$0 is the original question, $\check{C}_t$1 reasoning, $\check{C}_t$2 the action, $\check{C}_t$3 the tool response or observation, and $\check{C}_t$4 the final reasoning-answer pair.

Under standard agent SFT, tool responses $\check{C}_t$5 are masked, so evidence inside observations is not directly supervised. ACC replaces that objective with direct conditioning on the original question and compiled context: $\check{C}_t$6 The compiled dataset is

$\check{C}_t$7

where $\check{C}_t$8 is assembled from evidence actually gathered by the agent.

The compilation policy is agent-specific but structurally consistent. For search agents, ACC extracts full text of visited web pages and also includes unvisited candidate results as distractors. For SWE agents, it extracts contents of opened files and adds inspected-but-unopened files as distractors. For SQL agents, it extracts complete contents of relevant queried tables. These evidence pieces are concatenated, randomly permuted, and truncated to a token budget: $\check{C}_t$9 Random shuffling prevents reliance on original temporal order and forces semantic localization of evidence.

The main experiments compile 10,802 trajectories from Search, SWE, and SQL agents, with compiled context lengths ranging from 2K to 128K tokens, and train Qwen3-30B-A3B-Thinking at a 131,072-token sequence length. On MRCR, the baseline reaches 50.19 overall and the ACC-trained model reaches 68.28; on GraphWalks, the baseline reaches 69.92 overall and the ACC-trained model reaches 77.51. The paper further reports little evidence of general-capability regression on GPQA-Diamond, MMLU-Pro, AIME’24, AIME’25, and IFEval, and attributes some of the gains to task-adaptive attention restructuring and task-dependent MoE expert specialization (Su et al., 21 May 2026).

This formulation reframes compression as supervision design. What is compressed is not the model weights or the raw context window alone, but the trajectory into a training target where distant evidence segments become directly predictive of the final answer.

4. Operational and prompt-level ACC variants in agent systems

Several contemporaneous systems instantiate ACC-like behavior inside broader agent architectures. In AOI, a multi-agent framework for autonomous IT operations, the LLM-based Context Compressor sits between the Probe and Executor agents and a three-layer memory design consisting of Raw Context Storage, Task Queue Management, and a Compressed Context Cache (Bai et al., 15 Dec 2025). Raw outputs are retained for 24 hours, compressed strategic summaries for 7 days. Compression is domain-aware and sliding-window based: raw context $k$0 is split into overlapping windows with 50% overlap, the LLM extracts fault signatures, error codes, performance anomalies, and causal relationships, overlapping summaries are merged, and a secondary compression step is applied if the target compression ratio is exceeded. The Observer agent then plans over compressed strategic memory rather than replaying raw logs. The scheduler explicitly conditions on compressed context,

$k$1

so compression actively shapes probing and execution rather than merely reducing storage.

AGORA addresses a different failure mode: token-level extractive compression for agent prompts. It argues that such methods are structurally inappropriate because the low-self-information tokens that carry action semantics—brackets, identifiers, action verbs, delimiters, and syntax such as search[...] or click[...]—are precisely the ones general-purpose compressors remove (Zhang et al., 26 May 2026). AGORA therefore compresses at step granularity. A structural parser segments the prompt into system block, task instruction, past action–observation steps, current observation, and pending assistant block. An always-keep floor preserves the system prompt, task instruction, current observation, pending assistant block, the last $k$2 steps, and any earlier steps with $k$3. A 125M-parameter RoBERTa-base scorer then ranks remaining steps for greedy budget fill under a fixed keep ratio $k$4. The result is an inference-free, grammar-preserving compressor that keeps steps verbatim and replaces dropped spans with an elision marker.

ACON, or Agent Context Optimization, compresses both interaction histories and raw environment observations for long-horizon LLM agents (Kang et al., 1 Oct 2025). Its distinctive feature is optimization of a natural-language compression guideline $k$5 rather than direct weight updates. Given paired trajectories where full context succeeds and compressed context fails, a strong LLM analyzes what information was lost and updates the guideline: $k$6 A second stage then seeks shorter successful compressions. The resulting teacher compressor can be distilled into smaller models such as Qwen3-14B, Qwen3-8B, and Phi-4.

PAACE generalizes the idea to plan-aware context engineering (Yuksel, 18 Dec 2025). The evolving state is represented as

$k$7

and the teacher compressor produces

$k$8

conditioning on the next $k$9 tasks in the plan. PAACE-Syn generates approximately 1.2M synthetic workflows and about 9.5B tokens before compression, while PAACE-FT distills teacher behavior from GPT-OSS-120B into Qwen3-4B-Instruct using a standard causal-language-model loss over the compressed output. This formulation emphasizes that agent compression can be conditioned on future plan structure rather than only current-query relevance.

5. Empirical behavior, mechanisms, and evaluation lenses

Across these systems, empirical results consistently distinguish between mere token reduction and preservation of decision-critical structure. AOI reports a 72.4% context compression ratio while preserving 92.8% of critical information, a 94.2% task success rate, a 22.1 minutes MTTR, a 3.1% false positive rate, and a 96.7% safety score; relative to the best baseline, MTTR is reduced by 34.4%, and the context compressor ablation reduces TSR to 88.5% while raising MTTR to 29.8 minutes (Bai et al., 15 Dec 2025). AGORA, at a nominal 4× compression target, reports mean reward $a$0, about 92% retention versus No-Comp, and realized end-to-end compression ranging from $a$1 to $a$2 from a single fixed keep ratio (Zhang et al., 26 May 2026). ACON reports peak-token reductions of 26–54%, preservation of over 95% of the teacher compressor’s accuracy after distillation, and up to 46% performance improvement for smaller agents (Kang et al., 1 Oct 2025). PAACE reports 59.00 accuracy on AppWorld versus 56.50 for the best listed baseline, 78.10 accuracy on OfficeBench, and 0.402 EM / 0.512 F1 on 8-Objective QA, while reducing Peak and Dependency (Yuksel, 18 Dec 2025).

A compact comparison makes the empirical landscape clearer.

System	Headline result	Setting
AOI	72.4% CCR, 92.8% IPS, 94.2% TSR	Autonomous IT operations
ACC training	68.28 MRCR, 77.51 GraphWalks	Long-context SFT from trajectories
AGORA	$a$3, about 92% retention	Step-level prompt compression
ACON	26–54% peak-token reduction	History and observation compression
PAACE	59.00 AppWorld accuracy	Plan-aware context engineering

Compression quality is not uniform across agentic workloads. ACBench, which studies quantization and pruning rather than context engineering, reports that 4-bit quantization preserves workflow generation and tool use with a 1%–3% drop but degrades real-world application accuracy by 10%–15% (2505.19433). This result is not itself an ACC design, but it is relevant to the broader question of whether compressed agent systems still retain acting ability under tool use, long-context dependence, and environment interaction.

A more abstract evaluation lens is provided by the view that an agentic system itself can be treated as a compressor (Qin et al., 24 Jun 2026). In that formulation, an agentic system is $a$4, success is defined relative to an observer family $a$5, and average codelength

$a$6

measures “system intelligence in bits.” Component value is quantified by marginal bit savings,

$a$7

In controlled experiments, deterministic tools, legal-move environments, template priors, verifiers, and retrieval all reduce codelength. This suggests that ACC can be understood not only as memory management but also as residual-uncertainty reduction under a fixed protocol.

6. Limitations, misconceptions, and unresolved issues

A persistent misconception is that ACC is equivalent to generic summarization. The literature repeatedly rejects that equivalence. The bounded-memory ACC states that CCS is not a summary and not a cache (Bousetouane, 15 Jan 2026). AOI states that its compressor is not generic summarization and explicitly preserves fault signatures, error codes, performance anomalies, and causal relationships for later diagnosis and remediation (Bai et al., 15 Dec 2025). AGORA shows that token-level extractive compressors can collapse to $a$8 across 17 $a$9 cells because they destroy the action grammar needed for the environment to accept the rollout (Zhang et al., 26 May 2026). The shared implication is that actionability, not brevity alone, is the relevant target.

Limitations are likewise explicit. The bounded-memory ACC depends on schema quality and compressor quality; if the CCS schema omits an important variable, the system can compress away useful information, and the evaluation is judge-based (Bousetouane, 15 Jan 2026). AOI depends on external LLM services, reports about 2.3 seconds per compression operation on average, struggles with extremely rapid failure propagation under 2 seconds, and has difficulty with unseen hybrid fault types and extreme-load cases where GPT-based compression latency causes delays (Bai et al., 15 Dec 2025). Agent Context Compilation has been tested on only three agent types and one base model, has not been shown at million-token scale, depends on DeepSeek-V3.2-Thinking for reasoning synthesis, and raises privacy and IP risks because raw trajectories may contain sensitive or proprietary content (Su et al., 21 May 2026). ACON can increase total cost because the compressor itself adds work and may break transformer KV-cache reuse, and observation compression is generally more favorable than history compression in API cost (Kang et al., 1 Oct 2025). PAACE does not provide formal semantic-equivalence or correctness guarantees, inherits possible teacher and evaluator bias, and is not presented as a safety mechanism (Yuksel, 18 Dec 2025).

The acronym also remains overloaded beyond agent systems. In algebraic geometry, ACC denotes the ascending chain condition, as in “Toward the equivalence of the ACC for $t$0-log canonical thresholds and the ACC for minimal log discrepancies” and “ACC for local volumes,” both of which are unrelated to agent memory or prompt compression (Liu, 2018, Han et al., 2024). For agentic AI, the more precise reading is therefore contextual: ACC may refer to bounded internal-state control, compiled long-context supervision, or a context-management module embedded in a larger agent architecture.