unbiased ai

Your LangChain agent, running on Pareto

LangChain already knows how to talk to an OpenAI-compatible endpoint, so trying Pareto takes two arguments and a key rather than a rewrite. Give ChatOpenAI the model name pareto and the Unbiased base URL, and your chains, tools and create_agent loops carry on as written. Each call goes to Pareto, which selects frontier and open models for the request and blends their outputs into one answer.

Choose Personal · $10/month See the setup →

Tested live with LangChain 1.4.650M tokens a week

A demonstration of LangChain on Pareto, recreated from a real run. Not a screenshot.

Set it up in ChatOpenAI

Pareto speaks the OpenAI Chat Completions format, so LangChain reaches it through the langchain-openai package. Build one ChatOpenAI object with the Unbiased base URL, and every agent, chain or tool binding you hand it uses Pareto.

  1. Get an Unbiased API key

    Choose a plan, then create a key in the Unbiased platform. New accounts are reviewed and approved by a person before the key works.

  2. Install the OpenAI integration

    Run pip install -U langchain langchain-openai. You do not need an OpenAI account; the package is only the client.

  3. Point ChatOpenAI at Unbiased

    Pass model="pareto", base_url="https://api.unbiased.ai/v1" (keep the /v1) and your key as api_key. Type pareto yourself: Unbiased does not serve a model list.

  4. Hand it to your agent

    Pass the ChatOpenAI object to create_agent, or use it anywhere LangChain takes a chat model: .invoke, .bind_tools or a chain. Leave use_responses_api at its default so requests use /v1/chat/completions.

Tested on October 20, 2026LangChain langchain 1.4.6, langchain-openai 1.7.2 on Pareto (pareto). A LangChain agent with two tools looked up prices and stock for two items, spotted the one that could not be filled, and returned the correct $84.25 total. Run record.
Install
pip install -U langchain langchain-openai
agent.py
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.tools import tool

llm = ChatOpenAI(
    model="pareto",
    base_url="https://api.unbiased.ai/v1",
    api_key="your-unbiased-api-key",
)

@tool
def get_price(item: str) -> float:
    """Return the unit price in dollars of an item."""
    return {"widget": 12.5, "gadget": 7.25}[item.lower()]

@tool
def get_stock(item: str) -> int:
    """Return how many units of an item are in stock."""
    return {"widget": 40, "gadget": 3}[item.lower()]

agent = create_agent(llm, tools=[get_price, get_stock])
q = ("I want to buy 5 widgets and 5 gadgets. Look up prices and stock. "
     "Which item can't be fully filled, and what is the total cost of what can be bought "
     "(all widgets plus whatever gadgets are in stock)? Answer with the item name and the dollar total.")
result = agent.invoke({"messages": [{"role": "user", "content": q}]})
print(result["messages"][-1].content)
Or environment variables
# ChatOpenAI checks base_url first, then OPENAI_API_BASE, then OPENAI_BASE_URL
export OPENAI_BASE_URL=https://api.unbiased.ai/v1
export OPENAI_API_KEY=your-unbiased-api-key
# then in Python: llm = ChatOpenAI(model="pareto")

An old OPENAI_API_BASE in your shell wins over OPENAI_BASE_URL, so clear it if requests land somewhere unexpected. In code, keep real keys in an environment variable rather than the file.

Your LangChain code stays. The model changes.

Two arguments on one object change. The graph, the tools and the prompts above it never notice.

One model string, several models behind it

Pareto is Unbiased’s blended AI model. On each request it selects frontier and open models and blends their outputs into one answer, so LangChain talks to one model string, pareto, and never has to pick.

“When the frontier improves, Pareto improves; when frontier prices fall, you should benefit.” From the pricing page.

How a Pareto answer gets made →
An illustration, not a wiring diagram. The blend includes frontier and open models, and its composition can change.

What an agent task costs on Pareto

Agents make many model calls per task, so the price of a finished task matters more than the price of a token. The model card publishes both for Pareto on two public agent benchmarks.

Terminal-Bench 4.0Tasks an agent completes in a terminal
$0.48/task
50.8% solved
DeepSWE v1.1Changes an agent makes in a real codebase
$0.24/task
69.9% solved

Pareto 26.10, preliminary October 1, 2026 runs that may change; denominators and the cost method still require confirmation. Cost is the reported mean USD per task at API rates, not an estimate for your workload. Model card and method.

Pay for Pareto by the month

One API key works across LangChain and any other tool you point at Pareto. Pick a monthly allowance, or pay per token on Team.

Personal

$10/month

  • 50M tokens a week
  • 20 requests per minute
  • For one person
Choose Personal

Personal Max

$100/month

  • 600M tokens a week
  • 60 requests per minute
  • For one person
Choose Personal Max

Team

Pay as you go

  • Prepaid credits at published rates
  • 300 requests per minute
  • No weekly token cap
Get started with Team

Subscriptions are for one person and are not unlimited. New API accounts are reviewed by a person before access turns on, and commercial or production use needs a separate written agreement. Rates and limits are on Pricing.

LangChain on Pareto, questions answered

Which LangChain package do I use for Pareto?

langchain-openai and its ChatOpenAI class. Pareto accepts the OpenAI Chat Completions format at https://api.unbiased.ai/v1. We ran LangChain 1.4.6 with langchain-openai 1.7.2 against Pareto on October 20, 2026: a create_agent agent with two tools looked up price and stock for both items and returned the right answer. Format compatibility is not a promise that every LangChain feature works, so tell us if one doesn’t.

Can I use the openai:pareto string with init_chat_model?

Only if you also pass base_url, or set it in the environment. Without it the shortcut sends requests to OpenAI. Building a ChatOpenAI object yourself, as in the setup above, is the clearest option.

Why are token counts missing when I stream?

ChatOpenAI leaves streaming usage off by default when it talks to an endpoint other than OpenAI’s. Pass stream_usage=True to get token counts on streamed responses.

Does this work for agents in production?

Personal and Personal Max subscriptions are for one person. Commercial or production use needs a separate written agreement with Unbiased. If you are building agents for others, see the page for agent builders.

Is Pareto made by the LangChain team?

No. Pareto is Unbiased’s model. LangChain is made by LangChain, and Unbiased is not affiliated with or endorsed by them. You keep LangChain and point it at the Unbiased API.

What happens when I hit the weekly allowance?

Requests over your plan’s limits return an HTTP 429 error. Personal includes 50M tokens a week and 20 requests per minute. Personal Max raises that to 600M a week and 60 requests per minute for $100/month. Team uses prepaid pay-as-you-go credits with no weekly token cap.

Do I choose between models?

No. You send every request to one model string, pareto. Pareto selects frontier and open models for each request and blends their outputs into one answer.

Is my code kept?

Personal and Personal Max are not our zero data retention tier: prompts and responses may be kept up to 30 days, as section 5(c) of the Terms explains. For work that must not be kept, ask about the Zero Data Retention API on the Private AI page.

Pareto works in other tools too

The same key and the same model string go into each of these. See them all.

Product names belong to their owners. Except where a guide says otherwise, Unbiased is not affiliated with or endorsed by the makers of the tools on this page.

Give your agent a harder question

Two arguments on ChatOpenAI, one key and the same graph. Pareto starts at $10 a month for 50M tokens a week.

Choose Personal · $10/month See the setup →