Code Execution AI Agent

Code agents run model-generated Python in a sandboxed interpreter so numeric and data tasks execute safely.

from praisonaiagents import Agent

agent = Agent(name="code-runner", instructions="Write and execute Python to answer questions.")
agent.start("Plot a sine wave and return the peak value.")

The user submits a task; the agent writes Python, runs it in the sandbox, and returns the result.

CodeAgent(model="gpt-4o") is now accepted (canonical). llm= still works as a deprecated alias — see Model Parameter.

Quick Start

Code
No Code

Install Package

First, install the required packages:

pip install praisonaiagents e2b_code_interpreter

Set API Key

Set your OpenAI API key and E2B API key as an environment variable in your terminal:

export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
export E2B_API_KEY=your_e2b_api_key_here

Create a file

Create a new file app.py with the basic setup:

from praisonaiagents import Agent, Task, AgentTeam
from e2b_code_interpreter import Sandbox

def code_interpreter(code: str):
    print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
    exec_result = Sandbox().run_code(code)
    if exec_result.error:
        print("[Code Interpreter error]", exec_result.error)
        return {"error": str(exec_result.error)}
    else:
        results = []
        for result in exec_result.results:
            if hasattr(result, '__iter__'):
                results.extend(list(result))
            else:
                results.append(str(result))
        logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
        return json.dumps({"results": results, "logs": logs})

# Create code agent
code_agent = Agent(
    role="Code Developer",
    goal="Write and execute Python code",
    backstory="Expert Python developer with strong coding skills",
    tools=[code_interpreter]
)

# Create a task
task = Task(
    description="Write and execute a Python script to analyze data",
    expected_output="Working Python script with execution results",
    agent=code_agent
)

# Create and start the agents
agents = AgentTeam(
    agents=[code_agent],
    tasks=[task],
    process="sequential"
)

# Start execution
agents.start()

Start Agents

Type this in your terminal to run your agents:

python app.py

Install Package

Install the PraisonAI package:

pip install praisonai e2b_code_interpreter

Set API Key

Set your OpenAI API key as an environment variable in your terminal:

export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"

Create a file

Create a new file agents.yaml with the basic setup:

framework: praisonai
process: sequential
topic: write and execute Python code
agents:  # Canonical: use 'agents' instead of 'roles'
  developer:
    instructions:  # Canonical: use 'instructions' instead of 'backstory' Expert Python developer with strong coding skills.
    goal: Write and execute Python code safely
    role: Code Developer
    tools:
      - code_interpreter
    tasks:
      coding_task:
        description: Write and execute a Python script to analyze data.
        expected_output: Working Python script with execution results.

Start Agents

Type this in your terminal to run your agents:

praisonai agents.yaml

Requirements

Python 3.10 or higher
OpenAI API key. Generate OpenAI API key here. Use Other models using this guide.
e2b_code_interpreter package installed

How It Works

The user submits a task; the agent writes Python, runs it in the sandboxed interpreter, and returns the captured result.

Understanding Code Agents

What are Code Agents?

Code agents are specialized AI agents that can:

Write Python code based on requirements
Execute code safely in a sandboxed environment
Handle code execution results and errors
Work together in a pipeline (writer → executor)

Features

Code Writer

Writes Python code based on requirements.

Safe Execution

Executes code in a sandboxed environment.

Error Handling

Manages code execution errors and debugging.

Results Processing

Processes and formats execution results.

Multi-Agent Code Development

Code
No Code

Install Package

First, install the required packages:

pip install praisonaiagents e2b_code_interpreter

Set API Key

Set your OpenAI API key as an environment variable in your terminal:

export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"

Create a file

Create a new file app.py with the basic setup:

from praisonaiagents import Agent, Task, AgentTeam
from e2b_code_interpreter import Sandbox

def code_interpreter(code: str):
    print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
    exec_result = Sandbox().run_code(code)
    if exec_result.error:
        print("[Code Interpreter error]", exec_result.error)
        return {"error": str(exec_result.error)}
    else:
        results = []
        for result in exec_result.results:
            if hasattr(result, '__iter__'):
                results.extend(list(result))
            else:
                results.append(str(result))
        logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
        return json.dumps({"results": results, "logs": logs})

# Create first agent for writing code
code_writer = Agent(
    role="Code Writer",
    goal="Write efficient Python code",
    backstory="Expert Python developer specializing in code writing"
)

# Create second agent for code execution
code_executor = Agent(
    role="Code Executor",
    goal="Execute and validate Python code",
    backstory="Expert in code execution and testing",
    tools=[code_interpreter]
)

# Create first task
writing_task = Task(
    description="Write a Python script for data analysis",
    expected_output="Complete Python script",
    agent=code_writer
)

# Create second task
execution_task = Task(
    description="Execute and validate the Python script",
    expected_output="Execution results and validation",
    agent=code_executor
)

# Create and start the agents
agents = AgentTeam(
    agents=[code_writer, code_executor],
    tasks=[writing_task, execution_task],
    process="sequential"
)

# Start execution
agents.start()

Start Agents

Type this in your terminal to run your agents:

python app.py

Install Package

Install the PraisonAI package:

pip install praisonai e2b_code_interpreter

Set API Key

Set your OpenAI API key as an environment variable in your terminal:

export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"

Create a file

Create a new file agents.yaml with the basic setup:

framework: praisonai
process: sequential
topic: develop and execute Python code
agents:  # Canonical: use 'agents' instead of 'roles'
  writer:
    instructions:  # Canonical: use 'instructions' instead of 'backstory' Expert Python developer specializing in code writing.
    goal: Write efficient Python code
    role: Code Writer
    tasks:
      writing_task:
        description: Write a Python script for data analysis.
        expected_output: Complete Python script.

  executor:
    instructions:  # Canonical: use 'instructions' instead of 'backstory' Expert in code execution and testing.
    goal: Execute and validate Python code
    role: Code Executor
    tools:
      - code_interpreter
    tasks:
      execution_task:
        description: Execute and validate the Python script.
        expected_output: Execution results and validation.

Start Agents

Type this in your terminal to run your agents:

praisonai agents.yaml

Configuration Options

# Create an agent with advanced code execution configuration
agent = Agent(
    role="Code Developer",
    goal="Write and execute Python code",
    backstory="Expert in Python development",
    tools=[code_interpreter],
    llm="gpt-4o"  # Language model to use
)

Troubleshooting

Code Errors

If code execution fails:

Check syntax errors
Verify package imports
Enable verbose mode for debugging

Sandbox Issues

If sandbox execution fails:

Check environment setup
Verify permissions
Review resource limits

Best Practices

Run in sandbox first

Test generated code in the sandbox environment before enabling execution in production workflows.

Limit interpreter scope

Use verbose mode when debugging

Enable verbose output to inspect code the model generates and stderr from failed runs.

Prefer safe execution mode

Keep code_mode="safe" unless you explicitly need direct host execution and accept the trade-offs.

Next Steps

AutoAgents

Learn about automatically created and managed AI agents

Mini Agents

Explore lightweight, focused AI agents

Code Execution with Tools

Let model-generated code call your registered tools directly — collapse multi-step pipelines into a single turn.

For optimal results, ensure code is properly formatted and tested in the sandbox environment before production use.

Use a specialised agent for numerical and mathematical tasks.

Run the PraisonAI coding assistant from the command line.

Getting Started

Install

Core Concepts

Guides

Features

Models

Databases

Observability

Memory

Telemetry & Analytics

Knowledge

RAG

Persistence

Tools

Other Features

Developers

Configuration

Best Practices

Getting Started (No Code)

Code Execution AI Agent

Quick Start

How It Works

Understanding Code Agents

What are Code Agents?

Features

Code Writer

Safe Execution

Error Handling

Results Processing

Multi-Agent Code Development

Configuration Options

Troubleshooting

Code Errors

Sandbox Issues

Best Practices

Next Steps

AutoAgents

Mini Agents

Code Execution with Tools

​Quick Start

​How It Works

​Understanding Code Agents

What are Code Agents?

​Features

Code Writer

Safe Execution

Error Handling

Results Processing

​Multi-Agent Code Development

​Configuration Options

​Troubleshooting

Code Errors

Sandbox Issues

​Best Practices

​Next Steps

AutoAgents

Mini Agents

Code Execution with Tools

​Related

Quick Start

How It Works

Understanding Code Agents

Features

Multi-Agent Code Development

Configuration Options

Troubleshooting

Best Practices

Next Steps

Related