# Debug Sandbox Execution

> Debug Python code execution failures by capturing partial traces, isolating failing functions, and incrementally verifying outputs

- **Type:** Skill
- **Install:** `agentstack add skill-hkuds-openspace-debug-sandbox-execution`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [HKUDS](https://agentstack.voostack.com/s/hkuds)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [HKUDS](https://github.com/HKUDS)
- **Source:** https://github.com/HKUDS/OpenSpace/tree/main/gdpval_bench/skills/debug-sandbox-execution

## Install

```sh
agentstack add skill-hkuds-openspace-debug-sandbox-execution
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Debug Sandbox Execution Failures

When `execute_code_sandbox` fails with unknown errors or incomplete output, use this debugging pattern to identify the root cause and recover incrementally.

## Problem

The `execute_code_sandbox` tool may fail silently, truncate output, or produce opaque errors. Complex scripts with multiple file outputs are especially prone to partial failures.

## Solution

Use a three-phase debugging approach:

### Phase 1: Capture Partial Execution Traces

When a sandbox execution fails, rerun the code using `run_shell` with output piping to capture whatever output is produced before the failure:

```bash
python your_script.py 2>&1 | head -100
```

This reveals:
- Which functions/steps executed successfully
- Where the failure occurred
- Any error messages that were suppressed

### Phase 2: Isolate Failing Functions

Break the script into smaller, testable units. Execute each function or code block independently:

```python
# Test individual components
if __name__ == "__main__":
    # Step 1: Test imports
    import numpy as np
    print("Imports OK")
    
    # Step 2: Test function A in isolation
    result_a = function_a()
    print(f"Function A: {result_a}")
    
    # Step 3: Test function B
    result_b = function_b(result_a)
    print(f"Function B: {result_b}")
```

Run each section with `execute_code_sandbox` separately to identify which component fails.

### Phase 3: Incremental Output Generation

Generate output files one at a time, verifying each before proceeding:

```python
import numpy as np
import soundfile as sf

# Generate and save file 1
audio1 = np.random.randn(48000 * 10).astype(np.float32)
sf.write('output_01.wav', audio1, 48000, subtype='FLOAT')

# Verify file 1 exists and has expected properties
import os
assert os.path.exists('output_01.wav'), "File 1 not created"

# Generate and save file 2
audio2 = np.random.randn(48000 * 10).astype(np.float32)
sf.write('output_02.wav', audio2, 48000, subtype='FLOAT')

# Verify file 2
assert os.path.exists('output_02.wav'), "File 2 not created"
```

## Example Workflow

1. **Initial attempt**: Run full script with `execute_code_sandbox`
2. **On failure**: Rerun with `run_shell` and `| head -100` to see partial output
3. **Identify breakpoint**: Find the last successful operation
4. **Split script**: Create separate scripts for each major section
5. **Test incrementally**: Run each section, verify outputs, proceed to next
6. **Combine successful sections**: Once all pieces work, combine into final script

## Best Practices

- **Always verify file creation** immediately after writing: `assert os.path.exists(path)`
- **Check file properties** (size, duration, format) before assuming success
- **Use print statements liberally** to mark progress through the script
- **Save intermediate outputs** so failures don't require restarting from scratch
- **Test audio/video generation** with short samples first (1-2 seconds) before full-length content

## When to Use

- Complex scripts with multiple file outputs
- Audio/video generation pipelines
- Scripts with external library dependencies
- Any `execute_code_sandbox` call that produces incomplete or no output

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [HKUDS](https://github.com/HKUDS)
- **Source:** [HKUDS/OpenSpace](https://github.com/HKUDS/OpenSpace)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-hkuds-openspace-debug-sandbox-execution
- Seller: https://agentstack.voostack.com/s/hkuds
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.