Session Sandbox

from polos import (
    Agent, max_steps, MaxStepsConfig,
    sandbox_tools, SandboxToolsConfig, DockerEnvironmentConfig,
)

# Session-scoped sandbox tools — the container persists across agent runs
# that share the same sessionId. Workspace files survive between invocations.
tools = sandbox_tools(
    SandboxToolsConfig(
        scope="session",
        env="docker",
        docker=DockerEnvironmentConfig(
            image="node:20-slim",
        ),
    )
)

coding_agent = Agent(
    id="session_coding_agent",
    provider="anthropic",
    model="claude-sonnet-4-5",
    system_prompt=(
        "You are a coding agent with access to a persistent sandbox environment. "
        "You can create files, edit code, run shell commands, and search the codebase. "
        "Files from previous turns in this session are still present -- check what "
        "already exists before creating new files. "
        "Use the tools to complete the task, then summarize what you did and show the output. "
        "Always verify your work by running the code after writing it."
    ),
    tools=tools,
    stop_conditions=[max_steps(MaxStepsConfig(count=50))],
)

import asyncio
import uuid
from polos import Polos
from polos.features import events

from agents import coding_agent

async def stream_and_wait(polos, handle):
    """Stream agent activity until the workflow completes."""
    async for event in events.stream_workflow(polos, handle.root_workflow_id, handle.id):
        if event.event_type == "text_delta":
            content = event.data.get("content") if isinstance(event.data, dict) else None
            if isinstance(content, str):
                print(content, end="", flush=True)
        elif event.event_type == "tool_call":
            tool_call = event.data.get("tool_call", {}) if isinstance(event.data, dict) else {}
            tool_name = tool_call.get("function", {}).get("name", "unknown")
            print(f"\n  [Using {tool_name}...]")

async def main():
    async with Polos(log_file="polos.log") as polos:
        # A single session ID shared across both agent runs
        session_id = str(uuid.uuid4())

        # Run 1: Create a utility module
        handle1 = await polos.invoke(
            coding_agent.id,
            {"input": "Create math-utils.js with add() and multiply(). "
             "Create test-math.js that tests them. Run with node.",
             "streaming": True},
            session_id=session_id,
        )
        await stream_and_wait(polos, handle1)

        # Run 2: Build on top of what Run 1 created (same container)
        handle2 = await polos.invoke(
            coding_agent.id,
            {"input": "Add subtract() to math-utils.js. "
             "Update test-math.js to test subtract. Run tests.",
             "streaming": True},
            session_id=session_id,
        )
        await stream_and_wait(polos, handle2)

asyncio.run(main())

git clone https://github.com/polos-dev/polos.git
cd polos/python-examples/24-session-sandbox
cp .env.example .env  # Add your POLOS_PROJECT_ID and API key
uv sync
python main.py