> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/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.

## 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=your_api_key_here
        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=your_api_key_here
        ```
      </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>

## 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=your_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 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=your_api_key_here
        ```
      </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>

## 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>
</CardGroup>

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