Mervin Praison

PraisonAI Native Managed Agents run the agent loop locally, but the tool layer can be sandboxed in any compute environment — a Docker container, an E2B cloud sandbox, a Modal function, a Daytona workspace, or a Fly.io Machine — via a single compute= argument. Same API, swappable infrastructure.

Architecture

%%{init: {"theme": "base", "themeVariables": {"background": "transparent", "lineColor": "#000000"}}}%%
graph TD
    A[PraisonAI Agent] --> B[LocalManagedAgent]
    B --> C{compute=}
    C -->|local| D[Host subprocess]
    C -->|docker| E[Docker container]
    C -->|e2b| F[E2B sandbox]
    C -->|modal| G[Modal function]
    C -->|daytona| H[Daytona workspace]
    C -->|flyio| I[Fly Machine]
    D --> J[Tool execution + results]
    E --> J
    F --> J
    G --> J
    H --> J
    I --> J
    J --> A
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
    classDef decision fill:#444,color:#fff
    class A,J agent
    class D,E,F,G,H,I tool
    class B,C decision

Providers at a Glance

Install

pip install praisonai
export OPENAI_API_KEY=your-api-key  # or any other LLM provider key

Local (no infra)

No compute provider attached — tools run on the host. Ideal for quick prototyping.

"""Local provider — basic managed agent with gpt-4o-mini.

No external infrastructure needed. Runs the agent loop locally.
"""
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# Create a local managed agent (auto-detects local when no ANTHROPIC_API_KEY)
managed = ManagedAgent(
    provider="local",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful assistant. Be concise.",
        name="LocalAgent",
    ),
)

agent = Agent(name="local-basic", backend=managed)

# 1. Basic execution
print("[1] Basic execution...")
result = agent.start("What is the capital of France? One word.")
print(f"    Result: {result}")

# 2. Agent metadata
print(f"\n[2] Agent ID: {managed.agent_id}")
print(f"    Version: {managed.agent_version}")
print(f"    Env ID:  {managed.environment_id}")
print(f"    Session: {managed.session_id}")

# 3. Multi-turn (same session keeps context)
print("\n[3] Multi-turn...")
result = agent.start("What country is that city in?")
print(f"    Result: {result}")

# 4. Usage tracking
info = managed.retrieve_session()
print(f"\n[4] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# 5. List sessions
sessions = managed.list_sessions()
print(f"\n[5] Sessions: {len(sessions)}")
for s in sessions:
    print(f"    {s['id']} | {s['status']}")

print("\nDone!")

Docker

Each tool call executes inside a Docker container. provision_compute() creates the container, execute_in_compute() runs commands inside it, shutdown_compute() tears it down.

"""Docker compute provider — run agent tools inside a Docker container.

Requires: Docker running locally.
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# ── 1. Basic agent with Docker compute ──
managed = ManagedAgent(
    provider="local",
    compute="docker",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
        name="DockerAgent",
    ),
)

agent = Agent(name="docker-agent", backend=managed)

print("[1] Agent created with Docker compute")
print(f"    Agent ID: {managed.agent_id or '(lazy — created on first call)'}")
print(f"    Compute:  {managed.compute_provider.provider_name}")

# ── 2. Provision Docker container ──
print("\n[2] Provisioning Docker container...")
info = asyncio.run(managed.provision_compute(image="python:3.12-slim"))
print(f"    Instance: {info.instance_id}")
print(f"    Status:   {info.status}")

# ── 3. Execute commands inside the container ──
print("\n[3] Executing commands in Docker...")
result = asyncio.run(managed.execute_in_compute("python3 -c 'import sys; print(sys.version)'"))
print(f"    Python version: {result['stdout'].strip()}")
print(f"    Exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("echo 'Hello from Docker!'"))
print(f"    Echo: {result['stdout'].strip()}")

# ── 4. Install packages in the container ──
print("\n[4] Installing packages...")
result = asyncio.run(managed.execute_in_compute("pip install requests -q"))
print(f"    pip exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("python3 -c 'import requests; print(requests.__version__)'"))
print(f"    requests version: {result['stdout'].strip()}")

# ── 5. Use agent with LLM (runs locally, compute is for tool sandboxing) ──
print("\n[5] Agent LLM execution...")
result = agent.start("What is 15 * 23? Just the number.")
print(f"    Result: {result}")

# ── 6. Multi-turn ──
print("\n[6] Multi-turn...")
result = agent.start("Double that number.")
print(f"    Result: {result}")

# ── 7. Usage tracking ──
info = managed.retrieve_session()
print(f"\n[7] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# ── 8. Shutdown Docker container ──
print("\n[8] Shutting down Docker container...")
asyncio.run(managed.shutdown_compute())
print("    Shutdown complete.")

print("\nDone!")

E2B (cloud sandbox)

E2B provisions a secure cloud sandbox in under a second. Set E2B_API_KEY first.

"""E2B compute provider — run agent tools inside an E2B cloud sandbox.

Requires: E2B_API_KEY environment variable set.
Install:  pip install e2b
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# ── 1. Create agent with E2B compute ──
managed = ManagedAgent(
    provider="local",
    compute="e2b",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
        name="E2BAgent",
    ),
)

agent = Agent(name="e2b-agent", backend=managed)

print("[1] Agent created with E2B compute")
print(f"    Compute: {managed.compute_provider.provider_name}")

# ── 2. Provision E2B sandbox ──
print("\n[2] Provisioning E2B sandbox...")
info = asyncio.run(managed.provision_compute(idle_timeout_s=120))
print(f"    Instance: {info.instance_id}")
print(f"    Status:   {info.status}")

# ── 3. Execute commands in the sandbox ──
print("\n[3] Executing commands in E2B...")
result = asyncio.run(managed.execute_in_compute("python3 -c 'import sys; print(sys.version)'"))
print(f"    Python version: {result['stdout'].strip()}")
print(f"    Exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("echo 'Hello from E2B!'"))
print(f"    Echo: {result['stdout'].strip()}")

# ── 4. Run a Python script ──
print("\n[4] Running Python script...")
result = asyncio.run(managed.execute_in_compute(
    "python3 -c 'for i in range(5): print(f\"Line {i}\")'"
))
print(f"    Output:\n{result['stdout']}")

# ── 5. Agent LLM execution ──
print("[5] Agent LLM execution...")
result = agent.start("What is the square root of 144? Just the number.")
print(f"    Result: {result}")

# ── 6. Multi-turn ──
print("\n[6] Multi-turn...")
result = agent.start("Now cube that number.")
print(f"    Result: {result}")

# ── 7. Usage ──
info = managed.retrieve_session()
print(f"\n[7] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# ── 8. Shutdown ──
print("\n[8] Shutting down E2B sandbox...")
asyncio.run(managed.shutdown_compute())
print("    Shutdown complete.")

print("\nDone!")

Modal

Modal gives you serverless containers with GPU support. Configure modal token new first.

"""Modal compute provider — run agent tools inside a Modal cloud sandbox.

Requires: modal CLI configured (modal token set) or MODAL_TOKEN_ID + MODAL_TOKEN_SECRET.
Install:  pip install modal
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# ── 1. Create agent with Modal compute ──
managed = ManagedAgent(
    provider="local",
    compute="modal",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
        name="ModalAgent",
    ),
)

agent = Agent(name="modal-agent", backend=managed)

print("[1] Agent created with Modal compute")
print(f"    Compute: {managed.compute_provider.provider_name}")

# ── 2. Provision Modal sandbox ──
print("\n[2] Provisioning Modal sandbox...")
info = asyncio.run(managed.provision_compute(idle_timeout_s=120))
print(f"    Instance: {info.instance_id}")
print(f"    Status:   {info.status}")

# ── 3. Execute commands in the sandbox ──
print("\n[3] Executing commands in Modal...")
result = asyncio.run(managed.execute_in_compute("python3 -c 'import sys; print(sys.version)'"))
print(f"    Python version: {result['stdout'].strip()}")
print(f"    Exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("echo 'Hello from Modal!'"))
print(f"    Echo: {result['stdout'].strip()}")

# ── 4. Run a computation ──
print("\n[4] Running computation...")
result = asyncio.run(managed.execute_in_compute(
    "python3 -c 'print(sum(range(1, 101)))'"
))
print(f"    Sum 1..100 = {result['stdout'].strip()}")

# ── 5. Agent LLM execution ──
print("\n[5] Agent LLM execution...")
result = agent.start("What is 7 factorial? Just the number.")
print(f"    Result: {result}")

# ── 6. Multi-turn ──
print("\n[6] Multi-turn...")
result = agent.start("Is that number even or odd?")
print(f"    Result: {result}")

# ── 7. Usage ──
info = managed.retrieve_session()
print(f"\n[7] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# ── 8. Shutdown ──
print("\n[8] Shutting down Modal sandbox...")
asyncio.run(managed.shutdown_compute())
print("    Shutdown complete.")

print("\nDone!")

Daytona

Daytona provides managed developer workspaces. Set DAYTONA_API_KEY and make sure your org has a default region configured in the Daytona dashboard.

"""Daytona compute provider — run agent tools inside a Daytona cloud sandbox.

Requires: DAYTONA_API_KEY environment variable set.
          Organization must have a default region configured in Daytona Dashboard.
Install:  pip install daytona-sdk
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# ── 1. Create agent with Daytona compute ──
managed = ManagedAgent(
    provider="local",
    compute="daytona",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
        name="DaytonaAgent",
    ),
)

agent = Agent(name="daytona-agent", backend=managed)

print("[1] Agent created with Daytona compute")
print(f"    Compute: {managed.compute_provider.provider_name}")

# ── 2. Provision Daytona sandbox ──
print("\n[2] Provisioning Daytona sandbox...")
info = asyncio.run(managed.provision_compute(idle_timeout_s=120))
print(f"    Instance: {info.instance_id}")
print(f"    Status:   {info.status}")

# ── 3. Execute commands ──
print("\n[3] Executing commands in Daytona...")
result = asyncio.run(managed.execute_in_compute("python3 -c 'import sys; print(sys.version)'"))
print(f"    Python version: {result['stdout'].strip()}")
print(f"    Exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("echo 'Hello from Daytona!'"))
print(f"    Echo: {result['stdout'].strip()}")

# ── 4. Agent LLM execution ──
print("\n[4] Agent LLM execution...")
result = agent.start("What is 11 * 13? Just the number.")
print(f"    Result: {result}")

# ── 5. Usage ──
info = managed.retrieve_session()
print(f"\n[5] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# ── 6. Shutdown ──
print("\n[6] Shutting down Daytona sandbox...")
asyncio.run(managed.shutdown_compute())
print("    Shutdown complete.")

print("\nDone!")

Fly.io

Fly.io Machines give you edge-deployed VMs. Set FLY_API_TOKEN and FLY_APP first.

"""Fly.io compute provider — run agent tools inside a Fly Machines VM.

Requires: FLY_API_TOKEN env var + an existing Fly.io app (set FLY_APP).
Install:  pip install httpx  (already a praisonai dependency)
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig

# ── 1. Create agent with Fly.io compute ──
managed = ManagedAgent(
    provider="local",
    compute="flyio",
    config=LocalManagedConfig(
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
        name="FlyioAgent",
    ),
)

agent = Agent(name="flyio-agent", backend=managed)

print("[1] Agent created with Fly.io compute")
print(f"    Compute: {managed.compute_provider.provider_name}")

# ── 2. Provision Fly Machine ──
print("\n[2] Provisioning Fly Machine...")
info = asyncio.run(managed.provision_compute(image="python:3.12-slim"))
print(f"    Instance: {info.instance_id}")
print(f"    Status:   {info.status}")

# ── 3. Execute commands in the machine ──
print("\n[3] Executing commands on Fly.io...")
result = asyncio.run(managed.execute_in_compute("python3 -c 'import sys; print(sys.version)'"))
print(f"    Python version: {result['stdout'].strip()}")
print(f"    Exit code: {result['exit_code']}")

result = asyncio.run(managed.execute_in_compute("echo 'Hello from Fly.io!'"))
print(f"    Echo: {result['stdout'].strip()}")

# ── 4. Agent LLM execution ──
print("\n[4] Agent LLM execution...")
result = agent.start("What is the population of Tokyo? One number.")
print(f"    Result: {result}")

# ── 5. Usage ──
info = managed.retrieve_session()
print(f"\n[5] Usage: in={info['usage']['input_tokens']}, out={info['usage']['output_tokens']}")

# ── 6. Shutdown ──
print("\n[6] Shutting down Fly Machine...")
asyncio.run(managed.shutdown_compute())
print("    Shutdown complete.")

print("\nDone!")

All Providers — Comparison Runner

Run every provider end-to-end in a single script and print a token-usage summary.

"""All compute providers — comprehensive test across Local, Docker, E2B, and Modal.

This example mirrors the Anthropic app.py but uses the local provider with
various compute backends instead of Anthropic's managed infrastructure.

Requires:
  - Docker running locally
  - E2B_API_KEY set
  - modal CLI configured (modal token set)
"""
import asyncio
from praisonai import Agent, ManagedAgent, LocalManagedConfig


async def test_provider(name, compute, extra_provision_kwargs=None):
    """Test a single compute provider end-to-end."""
    print(f"\n{'='*60}")
    print(f"  PROVIDER: {name}")
    print(f"{'='*60}")

    managed = ManagedAgent(
        provider="local",
        compute=compute,
        config=LocalManagedConfig(
            model="gpt-4o-mini",
            system="You are a helpful assistant. Be concise.",
            name=f"{name}Agent",
        ),
    )
    agent = Agent(name=f"{name}-test", backend=managed)

    # 1. Provision
    print(f"\n  [1] Provisioning {name}...")
    provision_kwargs = extra_provision_kwargs or {}
    info = await managed.provision_compute(**provision_kwargs)
    print(f"      Instance: {info.instance_id}")
    print(f"      Status:   {info.status}")

    # 2. Execute command
    print(f"\n  [2] Execute in {name}...")
    result = await managed.execute_in_compute("python3 -c 'print(42 * 13)'")
    stdout = result["stdout"].strip()
    assert "546" in stdout, f"Expected 546, got: {stdout}"
    print(f"      42 * 13 = {stdout} ✓")

    # 3. Execute echo
    result = await managed.execute_in_compute(f"echo 'Hello from {name}'")
    print(f"      Echo: {result['stdout'].strip()}")

    # 4. Agent LLM
    print(f"\n  [3] Agent LLM via {name}...")
    llm_result = agent.start("What is 9 * 8? Just the number.")
    print(f"      LLM result: {llm_result}")

    # 5. Multi-turn
    print("\n  [4] Multi-turn...")
    llm_result = agent.start("Add 10 to that. Just the number.")
    print(f"      Follow-up: {llm_result}")

    # 6. Usage
    session = managed.retrieve_session()
    usage = session["usage"]
    print(f"\n  [5] Usage: in={usage['input_tokens']}, out={usage['output_tokens']}")

    # 7. Shutdown
    print(f"\n  [6] Shutdown {name}...")
    await managed.shutdown_compute()
    print("      Done ✓")

    return {
        "name": name,
        "input_tokens": usage["input_tokens"],
        "output_tokens": usage["output_tokens"],
    }


async def main():
    results = []

    # Docker
    try:
        r = await test_provider("Docker", "docker", {"image": "python:3.12-slim"})
        results.append(r)
    except Exception as e:
        print(f"\n  Docker FAILED: {e}")

    # E2B
    try:
        r = await test_provider("E2B", "e2b", {"idle_timeout_s": 120})
        results.append(r)
    except Exception as e:
        print(f"\n  E2B FAILED: {e}")

    # Modal
    try:
        r = await test_provider("Modal", "modal", {"idle_timeout_s": 120})
        results.append(r)
    except Exception as e:
        print(f"\n  Modal FAILED: {e}")

    # Summary
    print(f"\n\n{'='*60}")
    print("  SUMMARY")
    print(f"{'='*60}")
    total_in = 0
    total_out = 0
    for r in results:
        total_in += r["input_tokens"]
        total_out += r["output_tokens"]
        print(f"  {r['name']:15s} | in: {r['input_tokens']:6d} | out: {r['output_tokens']:6d}")
    print(f"  {'TOTAL':15s} | in: {total_in:6d} | out: {total_out:6d}")
    print(f"{'='*60}")
    print(f"  {len(results)}/{3} providers passed")


if __name__ == "__main__":
    asyncio.run(main())

API Surface

When a compute provider is attached, the built-in execute_command, read_file, write_file, and list_files tools are automatically bridged so the LLM-driven agent loop executes them inside the sandbox instead of on the host. This gives you secure, reproducible tool execution with no change to the agent code itself.

A single script that demonstrates the full PraisonAI Native Managed Agent lifecycle — automatic agent, environment, and session management with any LLM (OpenAI, Gemini, Ollama, local). No Anthropic key required. Covers streaming, tool selection, custom tool callbacks, web search, multi-provider switching, and usage tracking in one file.

Architecture

%%{init: {"theme": "base", "themeVariables": {"background": "transparent", "lineColor": "#000000"}}}%%
graph TD
    A[Agent + LocalManagedAgent] --> B[Auto Setup]
    B --> C[agent.start]
    C --> D[Response / Result]
    subgraph Auto Setup
      E[Create Agent] --> F[Create Environment]
      F --> G[Create Session]
    end
    B --> E
    F --> H[Any LLM via litellm]
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
    class A,D agent
    class B,C,E,F,G,H tool

How to Run

Follow these steps to run the full demo:

Step 1: Install PraisonAI

pip install praisonai

Step 2: Set your API key

export OPENAI_API_KEY=your-api-key

Prefer Gemini? export GEMINI_API_KEY=... and change provider="openai" to provider="gemini". Prefer zero cloud? Run ollama serve and switch to provider="ollama" with model="llama3.2".

Step 3: Run it

python native_full_app.py

Full Code

"""Native Managed Agents — Full App (no Anthropic required).

Demonstrates the full LocalManagedAgent lifecycle with any LLM (OpenAI/Ollama/
Gemini) via litellm. Covers:

    1. Create agent         6. Multi-turn conversation
    2. Update agent         7. Track usage
    3. Environment          8. List sessions
    4. Session              9. Select tools
    5. Stream response     10. Disable tools
                           11. Custom tools
                           12. Web search
                           13. Switch provider (Ollama)
                           14. Interrupt

Prerequisites:
    export OPENAI_API_KEY=sk-...
    pip install praisonai
"""
import json
from praisonai import Agent, LocalManagedAgent, LocalManagedConfig


# 1. Create an agent (use gpt-4o-mini for this project)
managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini"),
)
agent = Agent(name="teacher", backend=managed)
result = agent.start("Say hello briefly.")
print(f"[1] Agent created: {managed.agent_id} (v{managed.agent_version})")

# 2. Update the agent
managed.update_agent(
    name="Teaching Agent v2",
    system="You are a senior Python developer. Write clean, production-quality code.",
)
print(f"[2] Agent updated to v{managed.agent_version}")

# 3-4. Environment + Session are created automatically
print(f"[3] Environment: {managed.environment_id}")
print(f"[4] Session:     {managed.session_id}")

# 5. Send a response
print("\n[5] Response...")
result = agent.start("Write a Python one-liner that prints 'Hello from Native Managed Agents!'")
print(result)

# 6. Multi-turn conversation (same session remembers context)
print("\n[6] Multi-turn follow-up...")
result = agent.start("Now modify it to accept a name argument.")
print(result)

# 7. Track usage
info = managed.retrieve_session()
print("\n[7] Usage:")
print(f"   Input tokens:  {info['usage']['input_tokens']}")
print(f"   Output tokens: {info['usage']['output_tokens']}")

# 8. List sessions
sessions = managed.list_sessions()
print(f"\n[8] Sessions: {len(sessions)}")
for s in sessions[:3]:
    print(f"   {s['id']} | {s['status']} | {s['title']}")

# 9. Selective tools (only read + write + list)
files_managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Files Only Agent",
        model="gpt-4o-mini",
        system="You can only read/write/list files.",
        tools=["read_file", "write_file", "list_files"],
    ),
)
files_agent = Agent(name="files-only", backend=files_managed)
print("\n[9] Files-only agent...")
result = files_agent.start("List files in the current directory (ls .).")

# 10. Disable web/shell (omit them from tools)
no_web_managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="No Web Agent",
        model="gpt-4o-mini",
        system="You are a coding assistant with no web or shell access.",
        tools=["read_file", "write_file"],
    ),
)
no_web_agent = Agent(name="no-web", backend=no_web_managed)
print("\n[10] No-web agent...")
result = no_web_agent.start("Compute 2**100 mentally and return just the number.")

# 11. Custom tools
def handle_weather(tool_name, tool_input):
    print(f"   [custom tool: {tool_name} | {json.dumps(tool_input)}]")
    return "Tokyo: 22 C, sunny, humidity 55 percent"

custom_managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Weather Agent",
        model="gpt-4o-mini",
        system="Use get_weather to answer any weather question.",
        tools=[
            {
                "type": "custom",
                "name": "get_weather",
                "description": "Get current weather for a location",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string", "description": "City name"},
                    },
                    "required": ["location"],
                },
            },
        ],
    ),
    on_custom_tool=handle_weather,
)
custom_agent = Agent(name="weather", backend=custom_managed)
print("\n[11] Custom-tool agent...")
result = custom_agent.start("What is the weather in Tokyo?")

# 12. Web search agent
search_managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Search Agent",
        model="gpt-4o-mini",
        system="You are a research assistant. Use search_web to answer.",
        tools=["search_web"],
    ),
)
search_agent = Agent(name="searcher", backend=search_managed)
print("\n[12] Web search agent...")
result = search_agent.start("Find 3 bullet points about Python 3.13 new features.")

# 13. Switch provider — Ollama (only runs if Ollama is available)
print("\n[13] Ollama provider (skipped if Ollama not running)...")
try:
    ollama_managed = LocalManagedAgent(
        provider="ollama",
        config=LocalManagedConfig(model="llama3.2", system="Be concise."),
    )
    ollama_agent = Agent(name="local-llama", backend=ollama_managed)
    print(ollama_agent.start("Say hi in 5 words."))
except Exception as e:
    print(f"   (Ollama skipped: {e})")

# 14. Interrupt a session (best-effort for local backend)
interrupt_managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini"),
)
interrupt_managed.interrupt()
print("\n[14] Interrupt signal sent.")

# Final usage summary
print("\n" + "=" * 60)
print("FINAL USAGE SUMMARY")
print("=" * 60)
all_backends = [
    ("Teaching Agent v2", managed),
    ("Files Only Agent",  files_managed),
    ("No Web Agent",      no_web_managed),
    ("Weather Agent",     custom_managed),
    ("Search Agent",      search_managed),
]
total_in = total_out = 0
for name, backend in all_backends:
    info = backend.retrieve_session()
    inp = info["usage"]["input_tokens"]
    out = info["usage"]["output_tokens"]
    total_in += inp
    total_out += out
    print(f"  {name:20s} | in: {inp:6d} | out: {out:6d}")
print(f"  {'TOTAL':20s} | in: {total_in:6d} | out: {total_out:6d}")
print("=" * 60)

What You Get

Anthropic vs Native

The Anthropic version (ManagedAgent / ManagedConfig) runs on Anthropic’s managed cloud with Claude. The Native version (LocalManagedAgent / LocalManagedConfig) runs the same lifecycle on your machine with any LLM via litellm. Same API, different backend — pick whichever fits your constraints.

PraisonAI Native Managed Agents (LocalManagedAgent) give you the same auto-managed agent, environment, and session experience as Anthropic Managed Agents — but using any LLM (OpenAI, Gemini, Ollama, local) with no Anthropic dependency. Each section below is a standalone, runnable script.

Architecture

%%{init: {"theme": "base", "themeVariables": {"background": "transparent", "lineColor": "#000000"}}}%%
graph TD
    A[PraisonAI Agent] --> B[LocalManagedAgent Backend]
    B --> C[Auto-Create Agent]
    B --> D[Auto-Create Environment]
    B --> E[Auto-Create Session]
    C --> F[Any LLM via litellm]
    D --> F
    E --> F
    F --> G[Response]
    G --> H[Result]
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
    classDef decision fill:#444,color:#fff
    class A,H agent
    class B,C,D,E tool
    class F,G decision

Prerequisites

pip install praisonai

Set your LLM API key as an environment variable (OpenAI shown; Gemini or Ollama work equally well):

export OPENAI_API_KEY=your-api-key

basic

The simplest possible native managed agent — a handful of lines. No Anthropic key required.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(provider="openai", config=LocalManagedConfig(model="gpt-4o-mini"))
agent = Agent(name="teacher", backend=managed)
result = agent.start("Say hello from native managed agents in one sentence.")
print(result)

01_create_agent

Zero config — default name="Agent". Access agent_id and agent_version after the first call.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(provider="openai", config=LocalManagedConfig(model="gpt-4o-mini"))
agent = Agent(name="coder", backend=managed)
result = agent.start("Say hello")
print(f"Agent ID: {managed.agent_id}")
print(f"Version:  {managed.agent_version}")

02_create_environment

Environment is created automatically — just set model and system on LocalManagedConfig.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Coding Assistant",
        model="gpt-4o-mini",
        system="You are a helpful coding assistant. Be concise.",
    ),
)
agent = Agent(name="coder", backend=managed)
result = agent.start("Say hello")
print(f"Agent ID:       {managed.agent_id}")
print(f"Environment ID: {managed.environment_id}")

03_create_session

Agent, environment, and session are all created automatically on first use.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Coding Assistant",
        model="gpt-4o-mini",
        system="You are a helpful coding assistant.",
        session_title="Quickstart native session",
    ),
)
agent = Agent(name="coder", backend=managed)
result = agent.start("Say hello")
print(f"Agent ID:       {managed.agent_id}")
print(f"Environment ID: {managed.environment_id}")
print(f"Session ID:     {managed.session_id}")

04_async_execute

LocalManagedAgent satisfies the async ManagedBackendProtocol — await execute() directly from asyncio code.

import asyncio
from praisonai import LocalManagedAgent, LocalManagedConfig


async def main():
    managed = LocalManagedAgent(
        provider="openai",
        config=LocalManagedConfig(model="gpt-4o-mini", system="Be concise."),
    )
    text = await managed.execute("List 3 fun facts about octopuses.")
    print(text)


asyncio.run(main())

05_select_tools

Defaults: execute_command, read_file, write_file, list_files, search_web. Pass a reduced list to restrict capabilities.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Read/Write Only",
        model="gpt-4o-mini",
        system="You can only read and write files.",
        tools=["read_file", "write_file", "list_files"],
    ),
)
agent = Agent(name="files-only", backend=managed)
result = agent.start("List the files in the current directory.")
print(result)

06_disable_tools

Omit tools you do not want. Missing tools are effectively disabled.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="No Web Agent",
        model="gpt-4o-mini",
        system="You are a coding assistant. You cannot access the web or shell.",
        tools=["read_file", "write_file"],
    ),
)
agent = Agent(name="no-web", backend=managed)
result = agent.start("Compute 2**100 and explain it in one sentence.")
print(result)

07_custom_tools

Define a tool schema and PraisonAI calls your on_custom_tool callback when the LLM invokes it.

import json
from praisonai import Agent, LocalManagedAgent, LocalManagedConfig


def handle_weather(tool_name, tool_input):
    print(f"  [Custom tool: {tool_name} | Input: {json.dumps(tool_input)}]")
    return "Tokyo: 22 C, sunny, humidity 55 percent"


managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Weather Agent",
        model="gpt-4o-mini",
        system="You are a weather assistant. Use get_weather to check weather.",
        tools=[
            {
                "type": "custom",
                "name": "get_weather",
                "description": "Get current weather for a location",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string", "description": "City name"},
                    },
                    "required": ["location"],
                },
            },
        ],
    ),
    on_custom_tool=handle_weather,
)
agent = Agent(name="weather", backend=managed)
result = agent.start("What is the weather in Tokyo?")
print(result)

08_update_agent

Update the agent’s name, system prompt, or model in place. Each update bumps agent_version while keeping the session alive.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(name="v1", model="gpt-4o-mini", system="Be terse."),
)
agent = Agent(name="coder", backend=managed)
agent.start("Hi")
print(f"v{managed.agent_version}")

managed.update_agent(
    name="Senior Dev",
    system="You are a senior Python developer. Write clean, production code.",
)
print(f"v{managed.agent_version}")

result = agent.start("Write a one-liner that sums 1..10.")
print(result)

09_list_sessions

Every call to reset_session() starts a fresh session. list_sessions() returns all sessions this backend instance created.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini", session_title="Session A"),
)
agent = Agent(name="coder", backend=managed)
agent.start("Say hi")

managed.reset_session()
agent.start("Say hi again")

sessions = managed.list_sessions()
print(f"Total sessions: {len(sessions)}")
for s in sessions:
    print(f"  {s['id']} | {s['status']} | {s['title']}")

10_web_search

Web search is one of the default tools — enable just search_web for a pure research agent.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(
        name="Search Agent",
        model="gpt-4o-mini",
        system="You are a research assistant. Use search_web and summarize.",
        tools=["search_web"],
    ),
)
agent = Agent(name="searcher", backend=managed)
result = agent.start("Search for 'Python 3.13 new features' and give 3 bullet points.")
print(result)

11_multi_turn

The same session remembers context across turns.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini", system="Remember context across turns."),
)
agent = Agent(name="chatbot", backend=managed)

print("Turn 1:", agent.start("My favorite number is 42. Remember it."))
print("Turn 2:", agent.start("What was my favorite number?"))

12_track_usage

retrieve_session() returns a unified dict with id, status, title, and usage (input / output tokens).

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini", system="Be concise."),
)
agent = Agent(name="coder", backend=managed)
agent.start("Say hello.")
agent.start("Say goodbye.")

info = managed.retrieve_session()
print(f"Session:       {info['id']}")
print(f"Status:        {info['status']}")
print(f"Input tokens:  {info['usage']['input_tokens']}")
print(f"Output tokens: {info['usage']['output_tokens']}")

13_resume_session

Resume any existing session by ID. Works across process restarts because chat history is written to the default session store.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

# First run — create and save session id
m1 = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini", system="Remember context."),
)
a1 = Agent(name="coder", backend=m1)
a1.start("My favorite color is teal. Remember it.")
session_id = m1.session_id
print(f"Saved session: {session_id}")

# Second run — resume the same session (simulates restart)
m2 = LocalManagedAgent(
    provider="openai",
    config=LocalManagedConfig(model="gpt-4o-mini", system="Remember context."),
)
m2.resume_session(session_id)
a2 = Agent(name="coder", backend=m2)
print(a2.start("What color did I mention?"))

14_ollama

Swap provider="openai" for provider="ollama" and you get the same API running fully local — no cloud, no API key.

from praisonai import Agent, LocalManagedAgent, LocalManagedConfig

managed = LocalManagedAgent(
    provider="ollama",
    config=LocalManagedConfig(model="llama3.2", system="Be concise."),
)
agent = Agent(name="local-llama", backend=managed)
print(agent.start("Say hello in one short sentence."))

Anthropic vs Native Managed Agents

Use Anthropic Managed Agents when you want Claude + fully managed infrastructure. Use the Native backend when you want the same developer experience with any LLM, fully under your control.