AI Agent SDK

Build the agent once,
run it on any model

Tool calling, MCP, streaming and tracing are built in,
and the same agent runs on 550+ models through one European gateway.

Get started Read the docs

1from opperai import Agent, tool
2
3@tool
4def search_docs(query: str) -> str:
5    """Search the product docs and return matching passages."""
6    return docs.search(query)
7
8agent = Agent(
9    name="support-agent",
10    instructions="Answer support questions from the docs.",
11    tools=[search_docs],
12    model="anthropic/claude-sonnet-4-6",
13)
14
15result = await agent.run("Why is my webhook returning 401?")
16print(result.output, result.meta.usage)

Trusted by 50k+ developers and companies serving 10M+ users

Challenge

Agents are easy to demo and hard to keep running

The framework you pick on day one quietly decides which models you can use, what you can see when a run goes wrong, and where your customers' data ends up.

The SDK decides the model

Agent frameworks shipped by model vendors only run that vendor's models, so trying a cheaper or faster model means rewriting the agent rather than changing a string.

Moving model means moving code

A cheaper model ships, or a customer asks for a European route, and the change turns into a migration instead of an edit to one line.

The loop is a black box

An agent takes six steps to reach a wrong answer and you only see the last one, so you cannot tell which tool returned bad data or which step burned the budget.

Data residency is an afterthought

Agents touch customer data on every iteration, and bolting compliance on later means auditing every provider your agent happened to reach.

The Opper Way

One agent, every model,
and a record of every step

Python and TypeScript with a matching API, and the model is a parameter rather than a dependency.

Any model, changed in one line

The model field takes any model id in the catalogue, and you can override it for a single run. Move an agent from a frontier model to a fast one, or from a US route to a European one, without touching the tools or the loop.

550+ text models behind one API key
Override the model per run
Identical API in Python and TypeScript

Browse the model catalogue

1agent = Agent(
2    name="support-agent",
3    instructions="Answer from the docs.",
4    tools=[search_docs],
5    model="anthropic/claude-sonnet-4-6",
6)
7
8# Same agent, different model, per run
9result = await agent.run(
10    "Summarise this thread",
11    model="cerebras/gpt-oss-120b",
12)

Your functions and any MCP server

Decorate a Python function or describe a TypeScript one and the agent can call it. Point it at an MCP server and every tool that server exposes becomes an agent tool, with local servers started and shut down around the run.

Schemas inferred from your type hints
MCP over stdio, streamable HTTP and SSE
Merge several servers into one agent

1from opperai.agent.mcp import mcp, MCPStdioConfig
2
3# Local server, started and stopped for you
4agent = Agent(
5    name="devops-agent",
6    instructions="Triage issues, open PRs.",
7    tools=[mcp(MCPStdioConfig(
8        name="git",
9        command="uvx",
10        args=["mcp-server-git"],
11    ))],
12)
13
14await agent.run("Fix the failing test.")

Stream the work, return a typed answer

Iterate the run as it happens and surface tool calls and partial text to your users, then take a final result that has been validated against a Pydantic or Zod schema instead of a paragraph you have to parse.

Typed events for every iteration and tool call
Pydantic, Zod or raw JSON Schema
Lifecycle hooks for logging and timing

1agent = Agent(
2    name="triage",
3    instructions="Classify the report.",
4    output_schema=Triage,
5)
6
7stream = agent.stream("No login after SSO")
8
9async for event in stream:
10    if event.type == "text_delta":
11        print(event.text, end="")
12
13result = await stream.result()
14result.output.severity  # validated str

Compose specialists, each on its own model

Expose one agent as a tool to another and a researcher on a cheap fast model can feed a writer on a frontier one. You pay frontier prices only for the step that needs them.

Any agent becomes a tool
A different model per specialist
Multi-turn state with conversations

1researcher = Agent(
2    name="researcher",
3    instructions="Gather and quote sources",
4    tools=[web_search],
5    model="gemini/gemini-3.1-flash-lite",
6)
7
8writer = Agent(
9    name="writer",
10    instructions="Write a grounded brief.",
11    tools=[researcher.as_tool(
12        name="research", description="Research a topic")],
13    model="anthropic/claude-opus-4-6",
14)

Every run traced, without wiring anything up

Each run opens a trace, and every iteration, model call and tool execution lands under it as its own span. When an agent gives a bad answer you can read the tree and find the step that caused it, rather than guessing from the final response.

On by default, no instrumentation
Duration and tokens per step, cost per trace
Full inputs and outputs once you turn retention on

See the control plane

Trace

Live

agent.run support-agent1,284ms

└iteration 1612ms

└llm anthropic/claude-sonnet-4-6498ms

└tool search_docs108ms

└iteration 2672ms

└llm anthropic/claude-sonnet-4-6…

Give the agent your data to search

Create a knowledge base, add documents or upload files, and query it semantically with metadata filters. Wrap that query in a tool and the agent decides when to look something up, with no separate vector database to run.

Semantic search with metadata filters
File upload and chunking handled
No vector database to operate

Read the knowledge base docs

1kb = opper.knowledge.create(name="tickets")
2opper.knowledge.add(
3    kb.id,
4    content="Login fails after SSO setup",
5    metadata={"status": "open"},
6)
7
8@tool
9def search_tickets(query: str) -> list:
10    """Find similar past tickets."""
11    return opper.knowledge.query(
12        kb.id, query=query,
13        filters=[{"field": "status", "operation": "=",
14                  "value": "open"}],
15    )

Already building

Or bring the agent framework you already use

Opper speaks the OpenAI Chat Completions, OpenAI Responses and Anthropic Messages APIs, so frameworks that take a base URL can run on any Opper model and land in the same traces. You do not have to adopt our SDK to get the gateway.

1from agents import Agent, Runner, function_tool, OpenAIChatCompletionsModel
2from openai import AsyncOpenAI
3
4client = AsyncOpenAI(
5    api_key=OPPER_API_KEY,
6    base_url="https://api.opper.ai/v3/compat",
7)
8
9@function_tool
10def get_weather(city: str) -> str:
11    """Get the current weather for a city."""
12    return f"Sunny, 22C in {city}"
13
14agent = Agent(
15    name="weather-assistant",
16    instructions="You are a helpful weather assistant.",
17    tools=[get_weather],
18    model=OpenAIChatCompletionsModel(
19        model="anthropic/claude-sonnet-4-6",
20        openai_client=client,
21    ),
22)
23
24result = await Runner.run(agent, "What's the weather in Paris?")

Every route runs through the same European gateway, with one key, one bill and one set of traces, whichever framework made the call. Explore the LLM gateway

Keep reading

Agent CLI Launch Claude Code, Codex, OpenCode or Hermes on any model, one command Run Claude Code on any model Three ways to point Claude Code at a different model Run Codex CLI on any model The same swap for OpenAI's Codex CLI

Build the agent once, run it on any model