Coding Agent Sandboxes: Engineering Automation for APAC Teams

1mkdir -p coding-agent-sandbox/{docker,workflows,agents,configs}
2cd coding-agent-sandbox
3git init

1# configs/sandbox-policy.yaml
2sandbox:
3  provider: "docker"  # or "e2b" or "freestyle"
4  region: "ap-southeast-1"  # Singapore
5  fallback_region: "ap-east-1"  # Hong Kong
6  resource_limits:
7    max_cpu: "2"
8    max_memory: "2048m"
9    max_disk: "5g"
10    max_execution_time: 300  # seconds
11  network:
12    allow_outbound: false
13    allowed_domains:
14      - "registry.npmjs.org"
15      - "pypi.org"
16      - "rubygems.org"
17  security:
18    read_only_root: true
19    no_new_privileges: true
20    drop_capabilities:
21      - "ALL"
22    seccomp_profile: "default"

1# docker/Dockerfile.sandbox
2FROM python:3.12-slim AS base
3
4# Create non-root user
5RUN groupadd -r sandbox && useradd -r -g sandbox -d /home/sandbox -s /bin/bash sandbox
6
7# Install language runtimes
8RUN apt-get update && apt-get install -y --no-install-recommends \
9    nodejs \
10    npm \
11    gcc \
12    g++ \
13    && rm -rf /var/lib/apt/lists/*
14
15# Install common packages the agent might need
16RUN pip install --no-cache-dir \
17    numpy==1.26.4 \
18    pandas==2.2.1 \
19    requests==2.31.0 \
20    pytest==8.1.1 \
21    black==24.3.0 \
22    ruff==0.3.4
23
24# Set up workspace
25WORKDIR /workspace
26RUN chown -R sandbox:sandbox /workspace
27
28# Security hardening
29RUN chmod 755 /workspace && \
30    find / -perm /6000 -type f -exec chmod a-s {} \; 2>/dev/null || true
31
32USER sandbox
33
34# Health check endpoint
35HEALTHCHECK --interval=30s --timeout=5s \
36  CMD python -c "print('healthy')" || exit 1
37
38ENTRYPOINT ["/bin/bash", "-c"]

1docker build -t coding-sandbox:latest -f docker/Dockerfile.sandbox .

1docker run --rm \
2  --read-only \
3  --tmpfs /tmp:rw,noexec,nosuid,size=100m \
4  --memory=2g \
5  --cpus=2 \
6  --network=none \
7  --security-opt=no-new-privileges \
8  coding-sandbox:latest \
9  "python -c 'print(2+2)'"

14

1# agents/sandbox_executor.py
2import subprocess
3import json
4import tempfile
5import os
6from pathlib import Path
7from datetime import datetime
8import hashlib
9
10class SandboxExecutor:
11    def __init__(self, config_path="configs/sandbox-policy.yaml"):
12        self.image = "coding-sandbox:latest"
13        self.max_execution_time = 300
14        self.execution_log = []
15
16    def execute(self, code: str, language: str = "python") -> dict:
17        """Execute code in an isolated sandbox and return results."""
18        execution_id = hashlib.sha256(
19            f"{datetime.utcnow().isoformat()}{code[:50]}".encode()
20        ).hexdigest()[:12]
21
22        # Write code to temp file
23        with tempfile.NamedTemporaryFile(
24            mode='w', suffix=f'.{self._ext(language)}',
25            delete=False, dir='/tmp'
26        ) as f:
27            f.write(code)
28            code_path = f.name
29
30        try:
31            result = subprocess.run(
32                [
33                    "docker", "run", "--rm",
34                    "--read-only",
35                    "--tmpfs", "/tmp:rw,noexec,nosuid,size=100m",
36                    "--memory=2g",
37                    "--cpus=2",
38                    "--network=none",
39                    "--security-opt=no-new-privileges",
40                    "-v", f"{code_path}:/workspace/task.{self._ext(language)}:ro",
41                    self.image,
42                    f"{self._runtime(language)} /workspace/task.{self._ext(language)}"
43                ],
44                capture_output=True,
45                text=True,
46                timeout=self.max_execution_time
47            )
48
49            output = {
50                "execution_id": execution_id,
51                "status": "success" if result.returncode == 0 else "error",
52                "stdout": result.stdout,
53                "stderr": result.stderr,
54                "exit_code": result.returncode,
55                "timestamp": datetime.utcnow().isoformat()
56            }
57        except subprocess.TimeoutExpired:
58            output = {
59                "execution_id": execution_id,
60                "status": "timeout",
61                "stdout": "",
62                "stderr": f"Execution exceeded {self.max_execution_time}s limit",
63                "exit_code": -1,
64                "timestamp": datetime.utcnow().isoformat()
65            }
66        finally:
67            os.unlink(code_path)
68
69        self.execution_log.append(output)
70        return output
71
72    def _ext(self, language: str) -> str:
73        return {"python": "py", "javascript": "js", "typescript": "ts"}.get(language, "py")
74
75    def _runtime(self, language: str) -> str:
76        return {"python": "python", "javascript": "node", "typescript": "npx ts-node"}.get(language, "python")
77
78
79if __name__ == "__main__":
80    executor = SandboxExecutor()
81    result = executor.execute("import sys; print(f'Python {sys.version}')")
82    print(json.dumps(result, indent=2))

1python agents/sandbox_executor.py

1{
2  "execution_id": "a3f9b2c1d4e5",
3  "status": "success",
4  "stdout": "Python 3.12.x (main, ...) [GCC ...]\n",
5  "stderr": "",
6  "exit_code": 0,
7  "timestamp": "2025-01-15T08:30:00.000000"
8}

1# agents/coding_agent.py
2import openai
3import json
4from sandbox_executor import SandboxExecutor
5
6class CodingAgent:
7    def __init__(self, model="gpt-4o", max_iterations=5):
8        self.client = openai.OpenAI()
9        self.model = model
10        self.max_iterations = max_iterations
11        self.executor = SandboxExecutor()
12
13    def solve(self, task: str) -> dict:
14        """Given a task description, generate and validate code."""
15        messages = [
16            {
17                "role": "system",
18                "content": (
19                    "You are a coding agent. Generate Python code to solve tasks. "
20                    "Return ONLY executable Python code, no markdown fences. "
21                    "Include assertions or print statements to verify correctness."
22                )
23            },
24            {"role": "user", "content": task}
25        ]
26
27        for iteration in range(self.max_iterations):
28            response = self.client.chat.completions.create(
29                model=self.model,
30                messages=messages,
31                temperature=0.2
32            )
33
34            code = response.choices[0].message.content.strip()
35            result = self.executor.execute(code)
36
37            if result["status"] == "success" and not result["stderr"]:
38                return {
39                    "task": task,
40                    "final_code": code,
41                    "output": result["stdout"],
42                    "iterations": iteration + 1,
43                    "execution_log": self.executor.execution_log
44                }
45
46            # Feed error back to the agent for self-correction
47            messages.append({"role": "assistant", "content": code})
48            messages.append({
49                "role": "user",
50                "content": f"Execution failed.\nStderr: {result['stderr']}\nStdout: {result['stdout']}\nFix the code."
51            })
52
53        return {
54            "task": task,
55            "status": "max_iterations_reached",
56            "iterations": self.max_iterations,
57            "execution_log": self.executor.execution_log
58        }
59
60
61if __name__ == "__main__":
62    agent = CodingAgent()
63    result = agent.solve(
64        "Write a function that finds the longest palindromic substring in a string. "
65        "Test it with 'babad' (expect 'bab' or 'aba') and 'cbbd' (expect 'bb')."
66    )
67    print(json.dumps(result, indent=2, default=str))

1{
2  "name": "Coding Agent Sandbox Pipeline",
3  "nodes": [
4    {
5      "parameters": {
6        "httpMethod": "POST",
7        "path": "agent-task",
8        "responseMode": "responseNode"
9      },
10      "name": "Webhook Trigger",
11      "type": "n8n-nodes-base.webhook",
12      "position": [250, 300]
13    },
14    {
15      "parameters": {
16        "command": "cd /opt/coding-agent-sandbox && python agents/coding_agent.py --task '{{ $json.body.task }}'"
17      },
18      "name": "Execute Agent",
19      "type": "n8n-nodes-base.executeCommand",
20      "position": [450, 300]
21    },
22    {
23      "parameters": {
24        "channel": "#engineering-agents",
25        "text": "Agent completed task: {{ $json.body.task }}\nResult: {{ $node['Execute Agent'].json.stdout }}"
26      },
27      "name": "Slack Notification",
28      "type": "n8n-nodes-base.slack",
29      "position": [650, 300]
30    }
31  ],
32  "connections": {
33    "Webhook Trigger": { "main": [[{ "node": "Execute Agent", "type": "main", "index": 0 }]] },
34    "Execute Agent": { "main": [[{ "node": "Slack Notification", "type": "main", "index": 0 }]] }
35  }
36}

1curl -X POST http://your-n8n-instance:5678/webhook/agent-task \
2  -H "Content-Type: application/json" \
3  -d '{"task": "Write a Python function to validate Hong Kong HKID numbers with checksum verification"}'

1Agent completed task: Write a Python function to validate Hong Kong HKID numbers...
2Result: All tests passed. HKID validation function working correctly.

1# agents/security_scanner.py
2import re
3from typing import Tuple
4
5BLOCKED_PATTERNS = [
6    (r'os\.system\s*\(', 'Direct OS command execution'),
7    (r'subprocess\.(run|Popen|call)', 'Subprocess spawning'),
8    (r'__import__\s*\(', 'Dynamic imports'),
9    (r'eval\s*\(', 'Eval execution'),
10    (r'exec\s*\(', 'Exec execution'),
11    (r'open\s*\([^)]*[\'\"/etc]', 'Sensitive file access'),
12    (r'socket\.', 'Network socket access'),
13    (r'shutil\.rmtree', 'Recursive deletion'),
14    (r'ctypes\.', 'C-level memory access'),
15]
16
17def scan_code(code: str) -> Tuple[bool, list]:
18    """Scan generated code for dangerous patterns.
19    Returns (is_safe, list_of_violations)."""
20    violations = []
21    for pattern, description in BLOCKED_PATTERNS:
22        if re.search(pattern, code):
23            violations.append({
24                "pattern": pattern,
25                "description": description,
26                "severity": "high"
27            })
28    return len(violations) == 0, violations
29
30
31if __name__ == "__main__":
32    test_code = "import os; os.system('whoami')"
33    is_safe, violations = scan_code(test_code)
34    print(f"Safe: {is_safe}")
35    for v in violations:
36        print(f"  BLOCKED: {v['description']}")

1Safe: False
2  BLOCKED: Direct OS command execution

1# agents/e2b_executor.py
2from e2b_code_interpreter import Sandbox
3
4def execute_in_e2b(code: str) -> dict:
5    """Execute code in E2B's managed sandbox."""
6    with Sandbox() as sandbox:
7        execution = sandbox.run_code(code)
8        return {
9            "stdout": execution.text,
10            "stderr": "\n".join([str(e) for e in execution.error]) if execution.error else "",
11            "status": "success" if not execution.error else "error"
12        }
13
14if __name__ == "__main__":
15    result = execute_in_e2b("print('Hello from E2B sandbox')")
16    print(result)

1pip install e2b-code-interpreter
2export E2B_API_KEY="your-api-key-here"
3python agents/e2b_executor.py

1{'stdout': 'Hello from E2B sandbox', 'stderr': '', 'status': 'success'}