Code Execution

​

How It Works

1. The agent writes a Python script using from mibyan_tools import ...
2. Mibyan generates a mibyan_tools.py stub module with RPC functions
3. Mibyan opens a Unix domain socket and starts an RPC listener thread
4. The script runs in a child process — tool calls travel over the socket back to Mibyan
5. Only the script’s print() output is returned to the LLM; intermediate tool results never enter the context window

# The agent can write scripts like:
from mibyan_tools import web_search, web_extract

results = web_search("Python 3.13 features", limit=5)
for r in results["data"]["web"]:
    content = web_extract([r["url"]])
    # ... filter and process ...
print(summary)

​

When the Agent Uses This

• 3+ tool calls with processing logic between them
• Bulk data filtering or conditional branching
• Loops over results

​

Practical Examples

​

Data Processing Pipeline

from mibyan_tools import search_files, read_file
import json

# Find all config files and extract database settings
matches = search_files("database", path=".", file_glob="*.yaml", limit=20)
configs = []
for match in matches.get("matches", []):
    content = read_file(match["path"])
    configs.append({"file": match["path"], "preview": content["content"][:200]})

print(json.dumps(configs, indent=2))

​

Multi-Step Web Research

from mibyan_tools import web_search, web_extract
import json

# Search, extract, and summarize in one turn
results = web_search("Rust async runtime comparison 2025", limit=5)
summaries = []
for r in results["data"]["web"]:
    page = web_extract([r["url"]])
    for p in page.get("results", []):
        if p.get("content"):
            summaries.append({
                "title": r["title"],
                "url": r["url"],
                "excerpt": p["content"][:500]
            })

print(json.dumps(summaries, indent=2))

​

Bulk File Refactoring

from mibyan_tools import search_files, read_file, patch

# Find all Python files using deprecated API and fix them
matches = search_files("old_api_call", path="src/", file_glob="*.py")
fixed = 0
for match in matches.get("matches", []):
    result = patch(
        path=match["path"],
        old_string="old_api_call(",
        new_string="new_api_call(",
        replace_all=True
    )
    if "error" not in str(result):
        fixed += 1

print(f"Fixed {fixed} files out of {len(matches.get('matches', []))} matches")

​

Build and Test Pipeline

from mibyan_tools import terminal, read_file
import json

# Run tests, parse results, and report
result = terminal("cd /project && python -m pytest --tb=short -q 2>&1", timeout=120)
output = result.get("output", "")

# Parse test output
passed = output.count(" passed")
failed = output.count(" failed")
errors = output.count(" error")

report = {
    "passed": passed,
    "failed": failed,
    "errors": errors,
    "exit_code": result.get("exit_code", -1),
    "summary": output[-500:] if len(output) > 500 else output
}

print(json.dumps(report, indent=2))

​

Execution Mode

# ~/.mibyan/config.yaml
code_execution:
  mode: project   # or "strict"

• environment scrubbing (API keys, tokens, credentials stripped)
• tool whitelist (scripts cannot call execute_code recursively, delegate_task, or MCP tools)
• resource limits (timeout, stdout cap, tool-call cap)

​

Persistent session kernel

​

Resource Limits

# In ~/.mibyan/config.yaml
code_execution:
  mode: project      # project (default) | strict
  timeout: 300       # Max seconds per script (default: 300)
  max_tool_calls: 50 # Max tool calls per execution (default: 50)

​

State Between Calls (the session kernel)

• Timeout or interrupt. A cell that hits the timeout (or is interrupted) kills the kernel process and its state is lost on purpose; the result says so and the next call starts a fresh kernel.
• reset=true. The agent can pass reset: true to discard the kernel’s state and start clean. This is also the way to pick up environment changes: a kernel’s environment is frozen when it spawns, so a newly allowlisted passthrough variable is invisible until the kernel is reset.
• Idle timeout and eviction. Kernels die with the session, after code_execution.kernel_idle_timeout idle seconds (default 1800), or when more than code_execution.max_session_kernels (default 4) top-level sessions’ kernels are alive and the oldest is evicted (running subagents’ kernels do not count against the cap).

# ~/.mibyan/config.yaml
code_execution:
  kernel_idle_timeout: 1800   # seconds a kernel may sit idle before it is reaped
  max_session_kernels: 4      # kernels kept alive at once; oldest is evicted past this

​

How Tool Calls Work Inside Scripts

1. The call is serialized to JSON and sent over a Unix domain socket to the parent process
2. The parent dispatches through the standard handle_function_call handler
3. The result is sent back over the socket
4. The function returns the parsed result

​

Error Handling

• Non-zero exit code: stderr is included in the output so the agent sees the full traceback
• Timeout: Script is killed and the agent sees "Script timed out after 300s and was killed."
• Interruption: If the user sends a new message during execution, the script is terminated and the agent sees [execution interrupted — user sent a new message]
• Tool call limit: When the 50-call limit is hit, subsequent tool calls return an error message

​

Security

​

Skill Environment Variable Passthrough

terminal:
  env_passthrough:
    - MY_CUSTOM_KEY
    - ANOTHER_TOKEN

​

mibyan_* variables in the child

• mibyan_HOME
• mibyan_PROFILE
• mibyan_CONFIG
• mibyan_ENV

1. Per-machine, in config.yaml — add the exact variable name to the passthrough allowlist:
   terminal:
     env_passthrough:
       - mibyan_KANBAN_DB
       - mibyan_BASE_URL
   
2. Per-skill, in the skill’s frontmatter — declare it so it is registered automatically whenever that skill is loaded:
   required_environment_variables:
     - mibyan_KANBAN_DB
   

​

execute_code vs terminal

​

Platform Support