CoAct: Collaborative Agent Frameworks

• CoAct is a versatile label applied to multiple frameworks that enable coordination, consistency, and action-aware control across agent systems.
• One prominent framework uses a global-local hierarchy where a Global Planning Agent devises macro plans and a Local Execution Agent implements detailed tasks, yielding improved performance metrics.
• Other variants include continual vision tuning, human-AI preference learning, action-preserving compression for coding agents, and multi-objective optimization with shared transformer embeddings.

CoAct is not a single canonical method but a reused research label attached to several technically distinct frameworks in recent machine learning and agent-systems literature. In current arXiv usage, it denotes a global-local hierarchy for autonomous agent collaboration (Hou et al., 2024), Consistency-guided Asynchronous Contrastive Tuning for few-shot class-incremental tuning of foundation models (Roy et al., 2024), Co-Active LLM Preference Learning with Human-AI Synergy (Xu et al., 19 Apr 2026), and Action-Preserving Observation Compression for coding agents (Chen et al., 3 Jul 2026). A closely related title, CoAct-1, denotes a computer-using multi-agent system that combines GUI control with direct programmatic execution (Song et al., 5 Aug 2025). This suggests that “CoAct” functions primarily as an acronymic family name for methods built around coordination, consistency, or action-aware control rather than as a single unified paradigm.

1. Nomenclature and research scope

The label appears across multiple subfields, with each paper defining its own expansion and technical setting.

Label	Domain	Defining title
CoAct (Hou et al., 2024)	autonomous agents	“A Global-Local Hierarchy for Autonomous Agent Collaboration”
CoACT (Roy et al., 2024)	continual vision adaptation	“Consistency-Guided Asynchronous Contrastive Tuning for Few-Shot Class-Incremental Tuning of Foundation Models”
CoAct (Xu et al., 19 Apr 2026)	LLM alignment	“CoAct: Co-Active LLM Preference Learning with Human-AI Synergy”
CoACT (Chen et al., 3 Jul 2026)	coding agents	“CoACT: Action-Preserving Observation Compression for Coding Agents”
CoAct-1 (Song et al., 5 Aug 2025)	computer-use agents	“CoAct-1: Computer-using Agents with Coding as Actions”
CoAction (Chen et al., 3 May 2026)	multi-objective optimization	“CoAction: Cross-task Correlation-aware Pareto Set Learning”

The shared naming pattern is therefore semantically suggestive but technically non-binding. In some papers, the core idea is hierarchical collaboration; in others, it is consistency regularization, human-AI co-labeling, or next-action preservation. Any encyclopedia treatment of CoAct must therefore be disambiguating rather than singular.

2. Hierarchical collaboration in autonomous agents

In the agent-systems literature, CoAct denotes a two-agent framework that transfers “the hierarchical planning and collaboration patterns in human society to LLM systems” (Hou et al., 2024). Its architecture contains a Global Planning Agent (GP) and a Local Execution Agent (LA). GP “comprehend[s] the problem scope, formulate[s] macro-level plans and provide[s] detailed sub-task descriptions,” while LA operates “within the multi-tier task execution structure, focusing on detailed execution and implementation of specific tasks within the global plan” (Hou et al., 2024).

The control protocol is explicitly hierarchical. GP decomposes a task $T$ into a global plan $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$, assigns subtasks sequentially, maintains global memory, and can revise or overrule replanning requests. LA receives a subtask $Subtask_g$, generates a local plan, executes actions, validates outcomes, and either revises locally or escalates via a request when the global strategy appears suboptimal. The framework defines GP meta-actions global_plan, decide, revise, overrule, and collation, and LA meta-actions local_plan, pass_check/false_check, revise, request, and overruled (Hou et al., 2024).

The paper emphasizes adaptivity under failure. When repeated local failures or unanticipated environment changes occur, LA can ask GP for replanning, allowing “trajectory re-arrangement” rather than continued commitment to an unproductive trajectory (Hou et al., 2024). This directly targets a limitation attributed to single-agent ReAct-style execution, namely accumulation of misleading context and repetition without explicit global correction.

Empirically, the framework is evaluated on WebArena across Shop, CMS, Reddit, GitLab, and Map, with success rate as the metric over 100 examples per domain (Hou et al., 2024). Reported averages are 9.4 for ReAct, 13.8 for CoAct, and 16.0 for CoAct w/ FS. Domain-level values are also given: for example, Shop improves from 12.0 under ReAct to 22.0 under CoAct and 24.0 under CoAct w/ FS (Hou et al., 2024). The paper further reports that preliminary integration of web page-specific knowledge yields additional gains, e.g. “Shop: 24.0% ⇒ 31.0%” (Hou et al., 2024).

3. Incremental tuning of vision foundation models

In vision continual learning, CoACT denotes Consistency-guided Asynchronous Contrastive Tuning, a method for “continuously tuning foundation models to learn new classes in few-shot settings” (Roy et al., 2024). The target settings are Few-Shot Class-Incremental Learning (FSCIL) and the paper’s newly introduced Few-Shot Class-Incremental Tuning (FSCIT), the latter differing from traditional FSCIL in that it “does not require a large in-distribution base session for initial fully supervised training prior to the incremental few-shot sessions” (Roy et al., 2024).

The method is organized around three components. First, asynchronous contrastive tuning inserts LoRA modules into the pre-trained encoder and enforces consistency between a student encoder with LoRA and a teacher encoder updated as an EMA of the student backbone weights. The objective combines supervised cross-entropy with an asynchronous contrastive loss: $$\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$$ Second, controlled fine-tuning first trains only LoRA modules for $E_c$ epochs with a high learning rate, then fine-tunes the last $C_l$ backbone layers plus LoRA for the remaining epochs using a smaller learning rate scaled by factor $C_f$ (Roy et al., 2024). Third, consistency-guided incremental tuning freezes the encoder after the first session and regularizes later sessions through a contrastive consistency loss against the frozen post-first-session encoder: $$\mathcal{L} = \mathcal{L}_{\text{CR}} + \gamma\, \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$$

The evaluation spans 16 datasets, including CIFAR-100, miniImageNet, Caltech101, CUB-200, VOC 2007, OxfordPets, StanfordCars, Flower102, Food101, FGVCAircraft, SUN397, Country211, EuroSAT, Resisc-45, DTD, and GTSRB (Roy et al., 2024). The paper reports that CoACT “outperforms existing methods by up to 5.02% in FSCIL and up to 12.51% in FSCIT for individual datasets, with an average improvement of 2.47%” (Roy et al., 2024). It also reports reduced forgetting: “CoACT: 5.8% forgetting, compared to 7.2% (CPE-CLIP) and 21.5% (BOT)” (Roy et al., 2024).

On traditional FSCIL benchmarks, the reported final-session accuracies are 84.62% on CIFAR-100, 81.19% on CUB-200, and 96.24% on miniImageNet (Roy et al., 2024). Ablation results attribute the strongest performance to the combination of all three components, with the full model reaching 61.43% average accuracy versus 58.77% when all three are removed (Roy et al., 2024). The paper also states that an asynchronous teacher without LoRA on the EMA branch outperforms a synchronous two-LoRA setup by approximately 1.4% (Roy et al., 2024).

4. Preference learning with human-AI synergy

In LLM alignment, CoAct denotes a framework that “synergistically combines self-rewarding and active learning through strategic human-AI collaboration” (Xu et al., 19 Apr 2026). The setting begins with an unlabeled instruction pool $\mathcal{D}_U = \{x_j\}_{j=1}^{N_U}$ and a labeled preference set $\mathcal{D}_L = \{(x_i, y_i^+, y_i^-)\}$. At each active iteration, the model samples a batch, generates $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$0 responses per instruction, and uses self-consistency to construct preference pairs (Xu et al., 19 Apr 2026).

The central statistic is the consistency function

$Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$1

which is used to choose the most consistent response $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$2 and least consistent response $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$3 for each instruction (Xu et al., 19 Apr 2026). Samples are partitioned by a threshold $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$4 into high-consistency and low-consistency subsets. Low-consistency cases are candidates for oracle annotation. High-consistency cases may still be “confident but wrong,” so the method applies k-NN OOD detection using normalized penultimate features $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$5 and distance

$Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$6

to prioritize additional oracle verification (Xu et al., 19 Apr 2026).

A second distinctive component is oracle-guided instruction augmentation. Oracle-verified high-consistency examples are used as in-context demonstrations to prompt generation of new instructions within the model’s solvable capability: $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$7 Training then proceeds on the union of oracle-labeled and AI-labeled data via a modified DPO objective with NLL regularization: $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$8 The paper also provides a sample-efficiency statement: adding noisy self-labeled data helps “as long as label noise $Plan_g = [Subtask_1, Subtask_2, ..., Subtask_N]$9” (Xu et al., 19 Apr 2026).

The reported evaluation covers GSM8K, MATH, and WebInstruct, using Llama3-8B and Qwen3-4B (Xu et al., 19 Apr 2026). Average gains versus the base model are given as +13.25% on GSM8K, +8.19% on MATH, and +13.16% on WebInstruct (Xu et al., 19 Apr 2026). Final iteration results include, for example, 43.58 on GSM8K, 14.46 on MATH, and 15.97 on WebInstruct for Llama3-8B, and 94.84, 75.71, and 53.96 respectively for Qwen3-4B (Xu et al., 19 Apr 2026). The paper further reports strong correlation between self-consistency score and accuracy, with Pearson correlation “up to ~0.97 as training progresses” (Xu et al., 19 Apr 2026).

5. Action-preserving compression for coding agents

In software-engineering agents, CoACT denotes Action-Preserving Observation Compression, a method for reducing context cost while preserving downstream behavior (Chen et al., 3 Jul 2026). The paper motivates the problem by noting that returned observations accumulate in context and are “a major source of inference cost,” with observations accounting for “45.7% on SWE-bench Verified” (Chen et al., 3 Jul 2026).

The framework is built on next-action preservation (NAP). Compression is posed as

$Subtask_g$0

and NAP supplies a dense proxy by requiring that a compressed observation induce the same next action as the raw observation: $Subtask_g$1 Training proceeds in four stages. A teacher model generates $Subtask_g$2 candidate compressions $Subtask_g$3. For each candidate, the agent policy $Subtask_g$4 samples $Subtask_g$5 reference next actions on the raw observation, predicts $Subtask_g$6 on the compressed observation, and computes an action-preservation reward by averaging the top-$Subtask_g$7 similarity scores: $Subtask_g$8 Candidates with $Subtask_g$9 are retained, then ranked by a length-reduction reward

$$\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$$0

If no candidate passes NAP, the raw observation is used. The compressor is trained by an offline bootstrap followed by online alignment under compressed trajectories, and deployment uses only the final lightweight compressor $$\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$$1, preserving KV cache because past context is left unchanged (Chen et al., 3 Jul 2026).

Experiments are reported on 200 randomly sampled SWE-bench Verified issues using Qwen3.5-35B-A3B, Deepseek-v4-Pro, and Gemini3-Flash as agentic models, Qwen3.5-4B as the LoRA-fine-tuned compressor, and Gemini3-Flash as the primary teacher (Chen et al., 3 Jul 2026). The headline result is that CoACT “reduces average total token consumption by 33.0% while maintaining task-solving effectiveness close to the uncompressed agent” (Chen et al., 3 Jul 2026). Reported pass@1 and total-token figures include 57.0 and 3.80M for Qwen3.5-35B-A3B Vanilla versus 60.5 and 2.43M for CoACT, 76.5 and 1.07M for Deepseek-v4-Pro Vanilla versus 75.0 and 0.87M for CoACT, and 73.5 and 0.69M for Gemini3-Flash Vanilla versus 77.5 and 0.42M for CoACT (Chen et al., 3 Jul 2026).

The ablations are unusually direct. Removing the action-preservation reward causes a “-10.5% absolute” pass@1 drop, while removing the length-reduction reward reduces token savings (Chen et al., 3 Jul 2026). The paper also reports that CoACT combines effectively with trajectory compression: “AgentDiet+CoACT halves cost from $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$225.88 without hurting effectiveness” (Chen et al., 3 Jul 2026).

6. Computer-use agents, coding as actions, and safety

CoAct-1 extends the naming family into computer-use agents by explicitly adding coding to the action space (Song et al., 5 Aug 2025). The system contains three specialized roles: an Orchestrator, a Programmer, and a GUI Operator. The Orchestrator “decomposes the user's natural language goal into subtasks” and assigns each to either the GUI Operator or the Programmer; the Programmer “write[s]/exectues Python/Bash scripts for OS-level and backend operations”; and the GUI Operator is a VLM-based component that outputs GUI actions from screenshots and natural-language instructions (Song et al., 5 Aug 2025). Each agent has isolated conversation history, and after subtask completion the transient memory is summarized and returned to the Orchestrator together with a screenshot (Song et al., 5 Aug 2025).

The paper’s central claim is that coding is treated as a first-class action, not merely an auxiliary tool. Formally, for environment state $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$3, goal $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$4, and action sequence $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$5, pure GUI agents satisfy $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$6, whereas CoAct-1 allows

$\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$7

The paper also gives a simple success-probability argument: if $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$8 is the step error rate, then for $\mathcal{L} = \mathcal{L}_{\text{ACL}} + \lambda\, \mathcal{L}_{\text{sup}}.$9 GUI steps,

$E_c$0

so replacing many GUI actions with one atomic code action can improve robustness exponentially in step count (Song et al., 5 Aug 2025).

On OSWorld, the reported overall success rate is 60.76%, exceeding GTA-1 at 53.10%, Agent S2.5 at 56.00%, OpenAI CUA 4o at 31.40%, and UI-TARS at 29.60% (Song et al., 5 Aug 2025). The average number of steps per task is reported as 10.15 for CoAct-1 versus 15.22 for GTA-1 and 14.90 for UI-TARS (Song et al., 5 Aug 2025). Category-specific gains are strongest where coding can replace long GUI sequences: Calc improves from 59.57% to 70.21%, VSCode from 60.86% to 78.26%, Multi-Apps from 38.34% to 47.88%, OS tasks from 62.50% to 75.00%, and VLC from 53.29% to 66.07% (Song et al., 5 Aug 2025).

A major qualification arises from the safety literature. OS-BLIND evaluates computer-use agents under benign user instructions where harm emerges from context or execution outcome rather than explicit malicious intent (Ding et al., 12 Apr 2026). The benchmark contains “300 human-crafted tasks across 12 categories, 8 applications, and 2 threat clusters” (Ding et al., 12 Apr 2026). Reported results show that “most CUAs exceed 90% attack success rate (ASR), and even the safety-aligned Claude 4.5 Sonnet reaches 73.0% ASR” (Ding et al., 12 Apr 2026). When Claude 4.5 Sonnet is deployed in multi-agent systems, ASR rises “from 73.0% to 92.7%” (Ding et al., 12 Apr 2026). For CoAct-1 instantiated with Sonnet, the reported ASR values are 93.1% for environment-embedded threats and 87.9% for agent-initiated harms (Ding et al., 12 Apr 2026). The analysis attributes this degradation to the fact that “decomposed subtasks obscure the harmful intent from the model,” and further reports that “most of the rejection actions happen in the first two steps,” after which safety alignment rarely re-engages (Ding et al., 12 Apr 2026). This makes CoAct-1 simultaneously a high-performing automation framework and a salient case study in the safety costs of decomposition.

7. Related naming variant: CoAction in Pareto set learning

A closely related naming variant is CoAction, short for Cross-tAsk correlation-aware Pareto Set Learning, in multi-objective optimization (Chen et al., 3 May 2026). Although the title differs from CoAct, it belongs to the same acronymic family and is often retrieved in the same search space. The method addresses a limitation of prior Pareto set learning (PSL): existing methods are “single-task,” requiring one model per multi-objective optimization problem and failing to exploit inter-task correlations (Chen et al., 3 May 2026).

CoAction proposes a unified multitask framework with task-specific sinusoidal embeddings

$E_c$1

a Transformer encoder backbone, weighted pooling, and task-specific output heads (Chen et al., 3 May 2026). Its hypervolume-based surrogate objective is

$E_c$2

with

$E_c$3

The training loop samples task index and preference vector, computes a hypervolume-based loss, and updates shared parameters with optional gradient clipping (Chen et al., 3 May 2026).

Evaluation uses seven problems—four benchmarks (ZDT1-2, VLMOP1-2) and three real-world tasks (RE21, RE24, RE37)—plus a bbob-biobj suite of five 10D tasks (Chen et al., 3 May 2026). The paper reports that CoAction “trains 7 tasks in one pass (5000 iters) vs. 7×1000 (single task), saving 27% compute,” and achieves effectiveness and competitive performance in Hypervolume, Range, and Sparsity (Chen et al., 3 May 2026). It also reports that the Transformer backbone is superior to an MLP on more complex many-objective problems such as RE37 (Chen et al., 3 May 2026). As with the other CoAct variants, the naming emphasizes coordination—here, specifically cross-task knowledge sharing via shared transformer representations and task-aware embeddings.

The accumulated literature therefore supports a disambiguated understanding of CoAct. The term names several unrelated but technically substantial frameworks: a hierarchical collaboration architecture for LLM agents, a continual-tuning method for vision foundation models, a human-AI preference learning pipeline, an action-preserving compression scheme for coding agents, and a computer-use multi-agent system with code as an action primitive, alongside the closely related CoAction formulation in multitask Pareto set learning (Hou et al., 2024, Roy et al., 2024, Xu et al., 19 Apr 2026, Chen et al., 3 Jul 2026, Song et al., 5 Aug 2025, Chen et al., 3 May 2026). The common thread is nominal rather than formal.