CodeAct Framework Overview

• The CodeAct Framework is a unified methodology combining formal abstractions with code-driven agentic reasoning for efficient task execution.
• It employs contraction, refinement, and concretization operators from automata theory to bridge high-level actions with concrete execution sequences.
• The framework enhances multi-agent collaboration and software verification through memory augmentation, self-debugging loops, and unified Python-based execution.

The CodeAct Framework is a family of agent and abstraction methodologies that unify code-driven reasoning with advanced system modeling and agentic task execution. Initially rooted in automata theory—specifically, the notion of Action Codes (Vaandrager et al., 2022)—the framework has evolved to encompass practical agent architectures, memory-augmented reasoning, compute-efficient code model training, and hybrid execution environments in both multi-agent collaboration and software verification domains.

1. Formal Foundations: Action Codes, Operators, and Abstraction Layers

Action Codes (Vaandrager et al., 2022) provide the mathematical substrate for relating high-level abstract actions (from alphabet $B$) to concrete low-level action sequences (alphabet $A$) via prefix-free coding functions $f : B \rightarrow A^+$. This formalism underpins operators that relate models at different abstraction layers:

• Contraction Operator $\alpha$: Contracts runs in a low-level LTS $\mathcal{M}$ over $A$ into high-level actions over $B$, matching sequences $w = f(b)$ to introduce abstract transitions.
• Refinement Operator $\rho$: Expands a high-level LTS $\mathcal{N}$ by replacing each abstract transition with its encoded concrete sequence, possibly introducing intermediate states for progress tracking.
• Concretization Operator $\gamma$: Overapproximates by allowing intermediate arbitrary behavior through chaos states. $\gamma$ ensures conformance-checking does not underapproximate $\mathcal{M}$.

These operators establish Galois connections:

• $$\rho_\mathcal{R}(\mathcal{N}) \sqsubseteq \mathcal{M} \iff \mathcal{N} \sqsubseteq \alpha_\mathcal{R}(\mathcal{M})$$
• $$\alpha_\mathcal{R}(\mathcal{M}) \sqsubseteq \mathcal{N} \iff \mathcal{M} \sqsubseteq \gamma_\mathcal{R}(\mathcal{N})$$

Here, $\sqsubseteq$ is the simulation preorder, guaranteeing sound abstraction/refinement for conformance and black-box Mealy machine testing. Compositional abstraction via action code composition is also supported.

2. CodeAct in Agentic Reasoning and Collaboration

The CodeAct agent framework is extensively applied to multi-agent reasoning tasks (Shi et al., 2023). Agents leverage enhanced memory (global, leader-specific), code-driven reasoning (Python code synthesis), and self-debugging loops using a code interpreter (Python REPL) to convert partial, ambiguous natural language information into deterministic, actionable formal calculations:

• Memory Modules: Aggregate game or environment state for context continuity.
• Code-Driven Action Synthesis: Transform semantic constraints into executable logic (e.g., deducing possible teammates by running consistency checks and logical eliminations).
• Self-Debugging Mechanism: Error feedback drives iterative code refinement. Agents revise Python reasoning until correct, producing stable, verifiable actions.

This paradigm improves performance on benchmarks such as Avalon, achieving a team selection accuracy of $0.830$, outperforming Chain-of-Thought and ReAct agents.

3. Unified Executable Action Space for LLM Agents

Recognizing the limitations of RL agents constrained by pre-defined, static tool invocation schemas, CodeAct reframes agent actions as unified executable Python code (Wang et al., 1 Feb 2024):

• Multi-turn Agent-Environment Interaction: LLM agents generate Python actions, interpreters provide immediate runtime error feedback, agents self-correct across turns.
• Action Space Composition: Conditional logic, loops, and variable reuse empower agents to compose complex tool use within a single action block.
• Efficiency and Robustness: Experimental studies with 17 LLMs showed CodeAct achieved up to 20% higher success rate and reduced task turn count by 30% over non-code agent frameworks.

Data-driven improvements are achieved via instruction-tuning datasets (CodeActInstruct, 7k multi-turn episodes) that train agents for improved self-debug and multi-step planning.

4. Hierarchical, Hybrid, and Multi-Agent Extensions

CodeAct also inspires hybrid and hierarchical frameworks such as CoAct (Hou et al., 19 Jun 2024) and CoAct-1 (Song et al., 5 Aug 2025):

• Hierarchical Planning (CoAct): Global planning agents decompose tasks into subphases, local execution agents validate and execute, communicating errors for replanning. On the WebArena benchmark, CoAct achieves 13.8% success (vs. 9.4% for ReAct), improved further to 16% when forced stop interventions are added.
• Hybrid GUI+Code Execution (CoAct-1): In environments such as OSWorld, Orchestrator agents delegate subtasks to GUI Operators (vision-language) or Programmer agents (Python/Bash script generation/execution). CoAct-1 achieves 60.76% success (vs. 53.1% for GUI-only agents) and reduces average actions per task from 15 to 10.15.

These extensions demonstrate that bridging symbolic GUI actions with programmatic code execution provides enhanced efficiency, scalability, and robustness, notably in spreadsheet, multi-application, and IDE scenarios.

5. Efficient Data Selection and Training for Code LLMs

The Code Adaptive Compute-efficient Tuning (CodeACT) framework (Lv et al., 5 Aug 2024) introduces methodology for training code LLMs more effectively:

• Complexity and Diversity Aware Sampling (CDAS): Selects data with high instruction-following difficulty (IFD) and diversity via perplexity-based scoring and K-Means clustering over embeddings.
• Dynamic Pack Padding: Minimizes resource usage by concatenating variable-length sequences and padding only to maximal length within packed batch.

Empirically, CodeACT-DeepSeek-Coder-6.7B trained on 40% of EVOL-Instruct data improves HumanEval scores by 8.6%, reduces train time by 78%, and peak GPU memory by 27%.

6. Applications in Benchmarking and Legal Reasoning

CodeAct has been deployed for tasks requiring rigorous deductive reasoning, such as in the ScienceAgentBench (Chen et al., 7 Oct 2024) and CHANCERY (Irwin et al., 5 Jun 2025) benchmarks:

• Flexible Tool Interaction: Agents invoke Python, shell, and browser tools to update or read files, handle multi-stage scientific workflows (ScienceAgentBench).
• Structured Legal Reasoning: In CHANCERY, natural legal queries are transformed into algorithmic code logic verifying compliance with corporate governance (e.g., pseudocode that parses charters, isolates principles, and checks proposals for compliance). CodeAct agents outperform ReAct-based agents and SOTA LLMs in accuracy ($78.1\%$ vs. $76.1\%$ for ReAct, $75.2\%$ GPT-4o).

CodeAct's explicit logic structure supports multi-hop deduction and modular reasoning, while limitations emerge in handling highly ambiguous or interpretatively nuanced queries not easily mapped to code.

7. Extensions: Self-Supervised, End-to-End, and Reinforcement Optimization

Recent innovations include tree-structured solution exploration (Tree-of-Code, ToC) (Ni et al., 18 Dec 2024, Ni et al., 19 Dec 2024) and reinforcement learning-based code tuning (ACECode) (Yang et al., 23 Dec 2024):

• Tree-of-Code (ToC): Overcomes CodeAct’s fragmentation by self-growing tree nodes representing complete code programs, leveraging breadth-first exploration and majority voting for stability. ToC boosts accuracy by 20% while using $<$\frac{1}{4}$ the turns compared to multi-step CodeAct.
• ACECode: Combines correctness and efficiency signals (test execution and runtime) in a reward function for RL optimization of CodeLLMs using PPO. Experimental results show pass@1 improvements up to 14.51% and runtime reductions in 65–72% of cases.

These extensions facilitate robust, self-supervised code generation and multi-objective optimization, broadening practical and theoretical applicability within CodeAct-derived frameworks.

---

In summary, CodeAct unifies abstraction theory, code-driven agent execution, and efficient training to improve reasoning, task execution, and verification across domains ranging from automata learning, agentic teamwork, and legal reasoning to open-domain software automation. Its operators (contraction, refinement, concretization), unified code action space, and advanced agent architectures underpin both theoretical guarantees (via Galois connections) and empirical performance gains. The framework continues to expand via hierarchical, hybrid, and reinforcement learning enhancements, supporting scalable, reliable, and interpretable agent actions for complex real-world systems.