code-act

Consolidates all LLM agent actions into a single executable Python code representation rather than separate text/JSON/tool-calling modalities. The system uses a Python interpreter integrated with the LLM to generate, execute, and iteratively refine code actions based on execution results in multi-turn conversations. This unified approach eliminates action-space fragmentation and enables the LLM to reason about code semantics directly.

Provides sandboxed Python execution environments using Docker containers or Kubernetes pods, where each conversation session gets its own isolated runtime. The engine manages container lifecycle, handles code injection, captures stdout/stderr, and enforces resource limits to prevent runaway processes. This architecture ensures security, reproducibility, and clean state separation between concurrent agent conversations.

Captures stdout, stderr, return values, and exceptions from code execution and formats them as structured feedback that is fed back to the LLM for reasoning. The system distinguishes between successful execution (with output), runtime errors (with stack traces), and syntax errors (with line numbers). This feedback enables the LLM to understand why code failed and generate corrected versions.

Provides integration with agent evaluation benchmarks (e.g., M³ToolEval) to measure CodeAct performance on standardized task datasets. The system includes evaluation harnesses that run agents on benchmark tasks, collect results, and compute success metrics. This enables quantitative comparison of CodeAct against alternative agent architectures (text-based, JSON-based, tool-calling).

Manages conversation state across multi-turn interactions, including message history, code blocks, execution results, and LLM responses. The system implements context windowing strategies to fit conversation history within the LLM's context window, using techniques like summarization, truncation, or selective history retention. This enables long conversations while respecting model constraints.

Implements a feedback loop where the LLM generates code, the system executes it, captures results (success/failure/output), and feeds execution feedback back to the LLM for iterative refinement. The system maintains conversation history and execution context across turns, allowing the LLM to reason about why code failed and generate corrected versions. This pattern enables self-correction without human intervention.

Provides pre-trained and fine-tuned LLM variants (CodeActAgent-Mistral-7b-v0.1 with 32k context, CodeActAgent-Llama-7b with 4k context) optimized for generating executable Python code as agent actions. These models are instruction-tuned to produce syntactically correct, executable code that integrates with the CodeAct execution engine. The fine-tuning process aligns the model's output distribution toward valid Python code and away from natural language explanations.

Provides a full-featured web interface for interacting with CodeAct agents, with conversation history stored in MongoDB and rendered in a chat-like format. The UI handles message rendering, code syntax highlighting, execution result display, and conversation management. It communicates with the LLM service and code execution engine via backend APIs, abstracting the complexity of agent orchestration from end users.

Provides a lightweight Python API for programmatically invoking CodeAct agents without a web UI, enabling integration into automated workflows, batch processing, or custom applications. The interface abstracts the LLM service and code execution engine behind a simple function-call API, handling orchestration, state management, and result collection internally.

Packages CodeAct components (LLM service, code execution engine, optional web UI) into Docker containers with vLLM or llama.cpp for efficient LLM inference. The deployment includes container orchestration, volume mounting for model weights, and networking configuration to enable communication between components. This approach simplifies deployment on single machines or small clusters.

Deploys CodeAct components as Kubernetes pods with horizontal pod autoscaling, persistent volume claims for model weights and conversation data, and service discovery for inter-component communication. The deployment includes ConfigMaps for configuration management, Secrets for API keys, and resource limits to prevent resource exhaustion. This architecture enables production-grade multi-tenant deployments with automatic scaling based on load.

Enables deployment of CodeAct on high-performance computing clusters using SLURM job scheduling, allowing researchers to run large-scale agent experiments across multiple compute nodes. The deployment integrates with SLURM's job submission, resource allocation, and monitoring systems, enabling batch processing of agent tasks with fine-grained control over compute resources (CPU, GPU, memory, time limits).

Uses Jupyter kernels to maintain execution state across multiple code blocks within a single conversation, enabling variables, imports, and function definitions to persist between turns. The system manages kernel lifecycle (creation, execution, cleanup) and handles kernel communication via the Jupyter protocol. This enables stateful multi-turn code execution where later code can reference earlier definitions.