The LLM layer under your agent

Works with every agent framework

Any framework that speaks OpenAI SDK works. That's every modern agent framework in 2026.

Why agent developers choose a gateway

LangGraph: one line to swap model

Point ChatOpenAI at AIPower. The graph, the tools, the state — everything else stays.

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode

# Only change: base_url + AIPower key
llm = ChatOpenAI(
    model="auto-code",              # Claude Sonnet for agents
    base_url="https://api.aipower.me/v1",
    api_key="sk-aipower-xxx",
)

# Rest of your LangGraph code — unchanged
workflow = StateGraph(AgentState)
workflow.add_node("agent", lambda s: call_model(llm, s))
workflow.add_node("tools", ToolNode(tools))
workflow.add_edge("tools", "agent")
workflow.add_conditional_edges("agent", should_continue)
app = workflow.compile()

CrewAI: different models per agent role

Researcher uses cheap DeepSeek. Analyst uses Claude Opus. Writer uses Qwen. One API, three models.

from crewai import Agent, Crew, Task
from langchain_openai import ChatOpenAI

def llm(model):
    return ChatOpenAI(
        model=model,
        base_url="https://api.aipower.me/v1",
        api_key="sk-aipower-xxx",
    )

researcher = Agent(
    role="Senior researcher",
    llm=llm("auto-cheap"),           # DeepSeek V3 — cheap, fast for research
    tools=[web_search_tool],
)

analyst = Agent(
    role="Strategy analyst",
    llm=llm("auto-best"),            # Claude Opus — deep reasoning
)

writer = Agent(
    role="Content writer",
    llm=llm("qwen/qwen-plus"),       # Qwen — strong writing, cheap
)

# Normal CrewAI orchestration
crew = Crew(agents=[researcher, analyst, writer], tasks=[...])
result = crew.kickoff()

AutoGen / OpenAI Swarm: config-only switch

# AutoGen
from autogen import ConversableAgent

config_list = [{
    "model": "auto-code",
    "base_url": "https://api.aipower.me/v1",
    "api_key": "sk-aipower-xxx",
}]

coder = ConversableAgent("coder", llm_config={"config_list": config_list})

# OpenAI Swarm / Agents SDK
from openai import OpenAI
client = OpenAI(
    base_url="https://api.aipower.me/v1",
    api_key="sk-aipower-xxx",
)
# All function calls, tool-use, handoffs work identically

Tool use works across all providers

Agents depend on tool_choice and function-calling. We normalize Claude's native format, Gemini's format, and Chinese models' variations into OpenAI-standard tool calls.

Per-agent cost attribution

Tag each request with an agent ID. Query which agents are eating your budget. Optimize the top 20% that cost 80%.

# Tag requests with the agent role
res = client.chat.completions.create(
    model="auto-code",
    user="agent:researcher",          # or "agent:analyst", "agent:writer"
    messages=[...],
)

# Query cost by agent
# GET https://api.aipower.me/api/usage/logs?user=agent:researcher
# Returns CSV: tokens, cost, model, timestamp, agent_id
# Plug into your observability (Langfuse, Helicone, datadog)

When OpenAI goes down, your agent doesn't

This is why production agent teams route through a gateway, not direct-to-vendor.

What a multi-agent SaaS pays

100 users/day × 50 agent LLM calls each = 5,000 calls/day. Mixed model routing.

Agent-specific FAQ

Building a different kind of AI product?