Code Execution Fallback Workflow

When to Use

Use this skill when execute_code_sandbox fails repeatedly (2+ attempts) with unknown, persistent, or unexplained errors. This fallback approach uses write_file + run_shell to save Python scripts to disk and execute them via command line, which has proven more reliable in certain failure scenarios.

Step-by-Step Instructions

Step 1: Detect Repeated Failures

Monitor execute_code_sandbox attempts. After 2 consecutive failures with errors like:

• "Unknown error"
• Timeout errors
• Unexplained execution failures
• Sandbox environment issues

Switch to the fallback workflow immediately.

Step 2: Write the Python Script to File

Use write_file to save your Python code as a .py file in the working directory:

write_file(
    path="script.py",
    content="""
import sys
import json

# Your Python code here
def main():
    # Your logic
    result = {"status": "success", "data": "example"}
    print(json.dumps(result))

if __name__ == "__main__":
    main()
"""
)

Tips:

• Use clear, self-contained code that doesn't rely on sandbox-specific paths
• Include error handling and informative print statements
• Save output to files if needed for later retrieval

Step 3: Execute via Shell

Use run_shell to execute the Python script via command line:

run_shell(
    command="python3 script.py",
    timeout=60  # Adjust timeout as needed
)

Alternative commands:

• python script.py - if python3 alias isn't available
• python3 -u script.py - for unbuffered output
• python3 script.py arg1 arg2 - with arguments

Step 4: Verify Output and Results

Check the stdout/stderr from run_shell to:

• Confirm execution succeeded (exit code 0)
• Inspect printed output or results
• Identify any new errors (different from sandbox errors)

If the script writes output files, use read_file to retrieve results.

Step 5: Clean Up (Optional)

Remove temporary script files if they won't be reused:

run_shell(command="rm script.py")

Complete Example

Scenario: execute_code_sandbox failed twice while trying to process data.

Fallback execution:

# Step 1: Write the processing script
write_file(
    path="process_data.py",
    content="""
import pandas as pd
import json

def process():
    data = [1, 2, 3, 4, 5]
    result = {"sum": sum(data), "count": len(data)}
    print(json.dumps(result))
    
    # Also save to file for reliability
    with open("result.json", "w") as f:
        json.dump(result, f)

if __name__ == "__main__":
    process()
"""
)

# Step 2: Execute via shell
output = run_shell(command="python3 process_data.py")

# Step 3: Read results from file
results = read_file(file_path="result.json", filetype="json")

Troubleshooting

Best Practices

1. Always include error handling in scripts to capture failures gracefully
2. Write results to files in addition to printing, for reliable retrieval
3. Use descriptive filenames to avoid conflicts (e.g., task_specific_script.py)
4. Keep scripts self-contained - avoid dependencies on sandbox environment variables
5. Log execution details for debugging: print(f"Step X complete: {value}")

When NOT to Use This Fallback

• When sandbox isolation is required for security
• When the task explicitly requires execute_code_sandbox
• When execute_code_sandbox succeeds consistently (no need to add complexity)
• When working with sensitive data that shouldn't persist to disk