Agentor class API reference

Agentor(
    name: str,
    instructions: Optional[str] = None,
    model: Optional[str | LitellmModel] = "gpt-5-nano",
    tools: Optional[List[Union[FunctionTool, str, MCPServerStreamableHttp, BaseTool]]] = None,
    output_type: type[Any] | AgentOutputSchemaBase | None = None,
    debug: bool = False,
    api_key: Optional[str] = None,
    model_settings: Optional[ModelSettings] = None,
    skills: Optional[List[str]] = None,
    enable_tracing: bool = False,
)

def run(input: str) -> List[str] | str

from agentor import Agentor

agent = Agentor(
    name="Assistant",
    instructions="You are a helpful assistant"
)

result = agent.run("Write a haiku about recursion in programming.")
print(result.final_output)

async def arun(
    input: list[str] | str | list[AgentInputType],
    limit_concurrency: int = 10,
    max_turns: int = 20,
    fallback_models: Optional[List[str]] = None,
) -> List[str] | str

import asyncio
from agentor import Agentor

agent = Agentor(name="Assistant", model="gpt-5-mini")

# Single prompt
result = await agent.arun("What is the weather in London?")
print(result.final_output)

# Batch prompts
results = await agent.arun([
    "What is the weather in London?",
    "What is the weather in Paris?"
])
for result in results:
    print(result.final_output)

# With fallback models
result = await agent.arun(
    "Analyze this dataset",
    fallback_models=["gpt-4o-mini", "gpt-4"]
)

async def chat(
    input: str,
    stream: bool = False,
    serialize: bool = True,
)

async def stream_chat(
    input: str,
    serialize: bool = True,
) -> AsyncIterator[Union[str, AgentOutput]]

import asyncio
from agentor import Agentor

agent = Agentor(name="Assistant", model="gpt-5-mini")

async def main():
    async for event in agent.stream_chat("Tell me a story"):
        print(event, flush=True)

asyncio.run(main())

def serve(
    host: Literal["0.0.0.0", "127.0.0.1", "localhost"] = "0.0.0.0",
    port: int = 8000,
    log_level: Literal["debug", "info", "warning", "error"] = "info",
    access_log: bool = True,
)

from agentor import Agentor

agent = Agentor(
    name="Weather Agent",
    model="gpt-5-mini",
    instructions="You are a helpful weather assistant."
)

# Serves at http://0.0.0.0:8000
# Agent card available at http://0.0.0.0:8000/.well-known/agent-card.json
agent.serve(port=8000)

@classmethod
def from_md(
    cls,
    md_path: str | Path,
    *,
    model: Optional[str | LitellmModel] = None,
    tools: Optional[List[Union[FunctionTool, str, MCPServerStreamableHttp, BaseTool]]] = None,
    output_type: type[Any] | AgentOutputSchemaBase | None = None,
    debug: bool = False,
    api_key: Optional[str] = None,
    model_settings: Optional[ModelSettings] = None,
) -> Agentor

---
name: Weather Agent
tools: ["get_weather", "gmail"]
model: gpt-4o
temperature: 0.3
---

You are a helpful weather assistant with access to real-time data.

from agentor import Agentor

agent = Agentor.from_md("agents/weather_agent.md")
result = agent.run("What's the weather in Tokyo?")

def think(query: str) -> List[str] | str

from agentor import Agentor

agent = Agentor(
    name="Assistant",
    instructions="You are a helpful assistant"
)

result = agent.run("Explain quantum computing in simple terms")
print(result.final_output)

import os
from agentor import Agentor

agent = Agentor(
    name="Assistant",
    model="gemini/gemini-pro",
    api_key=os.environ.get("GEMINI_API_KEY")
)

result = agent.run("What are the latest advances in AI?")

from agentor import Agentor, function_tool

@function_tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny and 72°F"

agent = Agentor(
    name="Weather Agent",
    instructions="Use the weather tool to answer questions.",
    tools=[get_weather]
)

result = agent.run("What's the weather in San Francisco?")

from agentor import Agentor, ModelSettings

model_settings = ModelSettings(
    temperature=0.7,
    max_tokens=1000
)

agent = Agentor(
    name="Creative Writer",
    model="gpt-4o",
    model_settings=model_settings,
    instructions="You are a creative writing assistant."
)

from agentor import Agentor

agent = Agentor(
    name="Customer Support",
    model="gpt-5-mini",
    instructions="You are a helpful customer support agent."
)

# Serves on http://0.0.0.0:8000
# POST to /chat with {"input": "your message", "stream": false}
agent.serve(port=8000)