Praison AI

Code Execution AI Agent

Learn how to create AI agents that can write and execute Python code safely using e2b code interpreter.

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

python
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.

Diagram

Code Agent

📋 Task

🤖 Agent

⚙️ Sandbox

✅ Result

Quick Start

Code

  1. Install Package

    First, install the required packages:

    bash
    pip install praisonaiagents e2b_code_interpreter
  2. Set API Key

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

    bash
    export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
export E2B_API_KEY=your_e2b_api_key_here
  3. Create a file

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

    python
    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()
  4. Start Agents

    Type this in your terminal to run your agents:

    bash
    python app.py

No Code

  1. Install Package

    Install the PraisonAI package:

    bash
    pip install praisonai e2b_code_interpreter
  2. Set API Key

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

    bash
    export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
  3. Create a file

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

    yaml
    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.
  4. Start Agents

    Type this in your terminal to run your agents:

    bash
    praisonai agents.yaml

How It Works

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

Diagram
SandboxAgentUserSandboxAgentUserstart(“Plot a sine wave”)Generate Python coderun_code(code)stdout + resultsAnswer

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

  1. Install Package

    First, install the required packages:

    bash
    pip install praisonaiagents e2b_code_interpreter
  2. Set API Key

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

    bash
    export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
  3. Create a file

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

    python
    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()
  4. Start Agents

    Type this in your terminal to run your agents:

    bash
    python app.py

No Code

  1. Install Package

    Install the PraisonAI package:

    bash
    pip install praisonai e2b_code_interpreter
  2. Set API Key

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

    bash
    export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
  3. Create a file

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

    yaml
    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.
  4. Start Agents

    Type this in your terminal to run your agents:

    bash
    praisonai agents.yaml

Configuration Options

python
# 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

Register only the tools and packages the agent needs — fewer imports reduce sandbox escape risk.

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. Safe mode runs code in a subprocess and enforces ExecutionConfig(timeout=...) as a hard per-call limit; "unsafe" mode runs in-process and has no hard timeout — a runaway loop blocks the worker. Choose "safe" whenever the timeout must be a guarantee.

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.

Related

Card

Use a specialised agent for numerical and mathematical tasks.

 Card

Run the PraisonAI coding assistant from the command line.