Limitations

Python features NOT supported by Monty

Monty is intentionally limited to support one specific use case: running code written by agents. This page documents what Python features are not available.

Monty is experimental and not ready for production use. The project is still in active development.

Major Language Limitations

These core Python features are currently not supported:

No Classes (Yet)

Monty does not currently support class definitions.

# ❌ This will NOT work
class MyClass:
    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

Class support is planned and should be added soon. Track progress on the Monty GitHub repository.

What works instead:

# ✅ Use dictionaries and functions
def create_object(value):
    return {'value': value}

def get_value(obj):
    return obj['value']

obj = create_object(42)
print(get_value(obj))

No Match Statements (Yet)

Pattern matching with match/case is not implemented.

# ❌ This will NOT work
match status:
    case 'success':
        return True
    case 'error':
        return False
    case _:
        return None

Match statement support is planned and should be added soon.

What works instead:

# ✅ Use if/elif/else chains
if status == 'success':
    return True
elif status == 'error':
    return False
else:
    return None

# ✅ Or use dictionaries for dispatch
handlers = {
    'success': lambda: True,
    'error': lambda: False,
}
return handlers.get(status, lambda: None)()

---

Standard Library Limitations

Limited Module Support

Only these stdlib modules are available:

• sys
• os
• typing
• asyncio
• re
• pathlib

Coming soon: datetime, dataclasses, json

# ❌ These imports will FAIL
import math
import random
import collections
import itertools
import functools
import pickle
import socket
import urllib

The rest of the Python standard library is not available and most modules will not be added. Monty is designed for agent code, not general-purpose Python execution.

What works instead:

# ✅ Use built-in functions and supported modules
import sys
import re
from typing import List, Dict

# Basic math operations work without imports
result = abs(-42)
maximum = max([1, 2, 3])
total = sum(range(10))

No Third-Party Libraries

Monty cannot use third-party packages like Pydantic, requests, numpy, etc.

# ❌ This will NEVER work
import pydantic
import requests
import numpy
import pandas

Support for third-party libraries is not a goal for Monty. The interpreter is designed exclusively for sandboxed agent code execution.

Design philosophy:

Monty is built for a specific use case where the code is:

• Written by an LLM/agent
• Executed in a sandboxed environment
• Using only built-in and stdlib features
• Making external calls via host-provided functions

---

Security Restrictions

These restrictions exist to ensure safe execution of untrusted agent code.

No Direct Filesystem Access

All filesystem operations are sandboxed and controlled by the host.

# ❌ Direct file I/O is blocked by default
with open('data.txt', 'r') as f:
    content = f.read()

# ❌ These also don't work without host permission
import os
os.listdir('.')
os.remove('file.txt')

How filesystem access works

The host environment must explicitly provide filesystem access through external functions:

# Agent code calls host-provided function
content = read_file('data.txt')  # External function

The host controls:

• Which files can be accessed
• What operations are allowed
• Path validation and sandboxing

No Environment Variables

Direct access to environment variables is blocked.

# ❌ This will not work
import os
api_key = os.environ.get('API_KEY')

What works instead:

# ✅ Host provides config through external functions
api_key = get_config('api_key')  # External function

No Network Access

Sockets, HTTP requests, and all network operations are blocked.

# ❌ These will fail (imports don't exist)
import socket
import urllib.request
import http.client

What works instead:

# ✅ Use host-provided external functions
response = await http_get('https://api.example.com/data')
data = await call_llm(prompt, messages)

No Subprocess Execution

Running external commands or spawning processes is blocked.

# ❌ These don't work (imports don't exist)
import subprocess
import os

os.system('ls')
subprocess.run(['python', 'script.py'])

---

Resource Limits

Monty enforces strict resource limits to prevent abuse:

Memory Limits

# Agent code that exceeds memory limits will be terminated
data = [0] * 10_000_000_000  # May trigger ResourceError

Execution Time Limits

# Infinite loops are caught by timeout
while True:
    pass  # Will be terminated after time limit

Allocation Limits

# Excessive allocations trigger limits
for i in range(1_000_000):
    data = [0] * 1000  # May trigger ResourceError

Resource limits are configurable by the host and are designed to prevent runaway agent code from consuming excessive resources.

---

Import System Limitations

No Dynamic Imports

The __import__() function and importlib are not available.

# ❌ Dynamic imports don't work
module = __import__('sys')

import importlib
mod = importlib.import_module('os')

No Import Hooks

Custom import hooks and meta path finders are not supported.

# ❌ These don't work
import sys
sys.meta_path.append(custom_finder)

---

Advanced Python Features

These advanced features are not supported:

No Metaclasses

Since classes aren’t supported yet, metaclasses are also unavailable.

No Decorators on Classes

Class decorators don’t work (no classes), but function decorators work fine:

# ✅ Function decorators work
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print('Before')
        result = func(*args, **kwargs)
        print('After')
        return result
    return wrapper

@my_decorator
def my_function():
    print('Function')

No Generators (Some Limitations)

Basic generators work, but some advanced features may not be fully supported:

# ✅ Simple generators work
def count(n):
    for i in range(n):
        yield i

for num in count(5):
    print(num)

No Context Managers (Limited)

The with statement has limited support. Custom context managers may not work fully.

# ⚠️ Limited support for context managers
# Simple cases may work, complex ones may not

---

What Monty IS Designed For

Despite these limitations, Monty excels at its intended use case:

Agent Code Execution

Perfect for running LLM-generated Python code:

async def agent(prompt: str, messages: list):
    while True:
        output = await call_llm(prompt, messages)
        if isinstance(output, str):
            return output
        messages.extend(output)

Tool Orchestration

Excellent for coordinating external function calls:

# Fetch data concurrently
import asyncio

user, prefs, history = await asyncio.gather(
    get_user(user_id),
    get_preferences(user_id),
    get_history(user_id)
)

return analyze(user, prefs, history)

Data Processing

Great for processing and transforming data:

def process_results(items: list) -> dict:
    filtered = [x for x in items if x['score'] > 0.8]
    grouped = {}
    for item in filtered:
        category = item['category']
        if category not in grouped:
            grouped[category] = []
        grouped[category].append(item)
    return grouped

Control Flow Logic

Ideal for agent decision-making logic:

def decide_action(state: dict) -> str:
    if state['confidence'] < 0.5:
        return 'ask_clarification'
    elif state['data_missing']:
        return 'fetch_more_data'
    else:
        return 'process_response'

---

Comparing to Alternatives

Why use Monty despite these limitations?

Feature	Monty	Docker	Pyodide	Full Python
Startup time	<1μs	~195ms	~2800ms	~30ms
Security	Strict sandbox	Good isolation	Poor	None
Stdlib	Limited	Full	Full	Full
Third-party libs	No	Yes	Most	Yes
Classes	Coming soon	Yes	Yes	Yes
Use case	Agent code	General	Browser	General

When to use Monty:

• Running LLM-generated code
• Need microsecond startup times
• Security is critical
• Stdlib subset is sufficient
• Building agentic systems

When NOT to use Monty:

• Need full Python compatibility
• Require third-party libraries
• Need classes today (coming soon)
• General-purpose scripting

---

Roadmap

Planned improvements:

1. Class support - Coming soon
2. Match statements - Coming soon
3. More stdlib modules - datetime, dataclasses, json
4. Enhanced async features - Better asyncio integration

Follow development on GitHub and join the Pydantic Slack for updates.

Next Steps

Python Subset

See what Python features ARE supported

Standard Library

Explore available stdlib modules