> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# 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 theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Code Agent"
        In[📋 Task] --> Agent[🤖 Agent]
        Agent --> Sandbox[⚙️ Sandbox]
        Sandbox --> Out[✅ Result]
    end

    classDef input fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef agent fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef tool fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef output fill:#10B981,stroke:#7C90A0,color:#fff
    class In input
    class Agent agent
    class Sandbox tool
    class Out output
```

## Quick Start

<Tabs>
  <Tab title="Code">
    <Steps>
      <Step title="Install Package">
        First, install the required packages:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonaiagents e2b_code_interpreter
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key and E2B API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
        export E2B_API_KEY=your_e2b_api_key_here
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `app.py` with the basic setup:

        ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        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()
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        python app.py
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="No Code">
    <Steps>
      <Step title="Install Package">
        Install the PraisonAI package:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonai e2b_code_interpreter
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `agents.yaml` with the basic setup:

        ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        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.
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        praisonai agents.yaml
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Note>
  **Requirements**

  * Python 3.10 or higher
  * OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).
  * e2b\_code\_interpreter package installed
</Note>

## How It Works

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

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant Agent
    participant Sandbox

    User->>Agent: start("Plot a sine wave")
    Agent->>Agent: Generate Python code
    Agent->>Sandbox: run_code(code)
    Sandbox-->>Agent: stdout + results
    Agent-->>User: Answer
```

***

## Understanding Code Agents

<Card title="What are Code Agents?" icon="question">
  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)
</Card>

## Features

<CardGroup cols={2}>
  <Card title="Code Writer" icon="pencil">
    Writes Python code based on requirements.
  </Card>

  <Card title="Safe Execution" icon="shield">
    Executes code in a sandboxed environment.
  </Card>

  <Card title="Error Handling" icon="bug">
    Manages code execution errors and debugging.
  </Card>

  <Card title="Results Processing" icon="output">
    Processes and formats execution results.
  </Card>
</CardGroup>

## Multi-Agent Code Development

<Tabs>
  <Tab title="Code">
    <Steps>
      <Step title="Install Package">
        First, install the required packages:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonaiagents e2b_code_interpreter
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `app.py` with the basic setup:

        ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        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()
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        python app.py
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="No Code">
    <Steps>
      <Step title="Install Package">
        Install the PraisonAI package:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonai e2b_code_interpreter
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY="${OPENAI_API_KEY:?Set OPENAI_API_KEY in your shell}"
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `agents.yaml` with the basic setup:

        ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        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.
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        praisonai agents.yaml
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

### Configuration Options

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# 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

<CardGroup cols={2}>
  <Card title="Code Errors" icon="triangle-exclamation">
    If code execution fails:

    * Check syntax errors
    * Verify package imports
    * Enable verbose mode for debugging
  </Card>

  <Card title="Sandbox Issues" icon="box">
    If sandbox execution fails:

    * Check environment setup
    * Verify permissions
    * Review resource limits
  </Card>
</CardGroup>

## Best Practices

<AccordionGroup>
  <Accordion title="Run in sandbox first">
    Test generated code in the sandbox environment before enabling execution in production workflows.
  </Accordion>

  <Accordion title="Limit interpreter scope">
    Register only the tools and packages the agent needs — fewer imports reduce sandbox escape risk.
  </Accordion>

  <Accordion title="Use verbose mode when debugging">
    Enable verbose output to inspect code the model generates and stderr from failed runs.
  </Accordion>

  <Accordion title="Prefer safe execution mode">
    Keep `code_mode="safe"` unless you explicitly need direct host execution and accept the trade-offs.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="AutoAgents" icon="robot" href="./autoagents">
    Learn about automatically created and managed AI agents
  </Card>

  <Card title="Mini Agents" icon="microchip" href="./mini">
    Explore lightweight, focused AI agents
  </Card>

  <Card title="Code Execution with Tools" icon="code-branch" href="./code-execution-with-tools">
    Let model-generated code call your registered tools directly — collapse multi-step pipelines into a single turn.
  </Card>
</CardGroup>

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

## Related

<CardGroup cols={2}>
  <Card icon="calculator" href="/features/mathagent">
    Use a specialised agent for numerical and mathematical tasks.
  </Card>

  <Card icon="terminal" href="/features/code">
    Run the PraisonAI coding assistant from the command line.
  </Card>
</CardGroup>