unbiased ai

DSPy on Pareto: declare the fields, let the model fill them

DSPy asks you to say what a program takes in and hands back, then writes the prompts itself. Keep the signatures, the modules and the optimizers, and change the one LM they all share. Give dspy.LM the name openai/pareto and Unbiased’s base URL, and every call goes to Pareto, which selects frontier and open models for each request and blends their outputs into one answer.

Choose Personal · $10/month See the setup →

Tested live with DSPy 3.4.150M tokens a week

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

Set it up with dspy.LM

DSPy reaches any OpenAI-compatible API through dspy.LM, which hands the call to LiteLLM. Put openai/ in front of the model name, pass Unbiased’s base URL and your key, and make it the default with dspy.configure.

  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 DSPy

    Run pip install dspy. It brings LiteLLM and everything else it needs.

  3. Name the model openai/pareto

    The openai/ prefix tells DSPy to speak the OpenAI Chat Completions format; pareto is the model. Type it by hand: Unbiased does not list models at /v1/models.

  4. Set api_base with /v1 on the end

    Pass api_base="https://api.unbiased.ai/v1" and your key as api_key, then call dspy.configure(lm=lm). Every module and optimizer that uses the default LM now calls Pareto.

Tested on October 20, 2026DSPy 3.4.1 on Pareto (pareto). A typed ChainOfThought signature sorted three support tickets into a fixed set of categories with an urgency flag, and all three came back correct. Run record.
The LM
import dspy
lm = dspy.LM("openai/pareto", api_base="https://api.unbiased.ai/v1", api_key="your-unbiased-api-key")
dspy.configure(lm=lm)
triage.py
import os
from typing import Literal
import dspy

lm = dspy.LM("openai/pareto", api_base="https://api.unbiased.ai/v1",
             api_key=os.environ["UNBIASED_API_KEY"], cache=False)
dspy.configure(lm=lm)

class Triage(dspy.Signature):
    """Classify a customer support ticket."""
    ticket: str = dspy.InputField()
    category: Literal["billing", "bug", "account",
                      "feature_request"] = dspy.OutputField()
    urgent: bool = dspy.OutputField()

triage = dspy.ChainOfThought(Triage)
p = triage(ticket="The export button crashes the app. Our team is blocked.")
print(p.category, p.urgent)
print(p.reasoning)
Shell
pip install dspy
export UNBIASED_API_KEY=your-unbiased-api-key
python triage.py

DSPy caches LM calls by default, so running the same input twice returns the first answer without a new request. Pass cache=False, as triage.py above does, when you want a fresh call every time.

DSPy stays. The model changes.

One dspy.LM line changes. Your program is none the wiser.

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 DSPy 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 DSPy by the month

One API key works across DSPy 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.

DSPy on Pareto, questions answered

Why does the model name start with openai/?

DSPy passes the model string to LiteLLM, and the prefix picks the request format. DSPy’s docs say that for any provider with an OpenAI-compatible endpoint, you add openai/ in front of the model name. Unbiased serves that format, so openai/pareto sends Chat Completions requests for the model pareto. In our test run, every call went to Pareto.

Does it work with typed signatures and ChainOfThought?

Yes, in our test. We ran DSPy 3.4.1 against Pareto on October 20, 2026 with a ChainOfThought signature that sorted support tickets into four fixed categories with an urgency flag. All three tickets came back in the right category, each with its reasoning. Format compatibility is not a promise that every feature works, so tell us if one doesn’t.

Do optimizers like BootstrapFewShot and MIPROv2 run on Pareto?

They call the LM you set with dspy.configure, so with this setup they call Pareto. We tested a single program, not a full compile, and we make no claim about how much an optimizer will improve your scores. A compile sends many requests, so it draws on your weekly tokens faster than a normal run.

Should I set model_type="responses"?

No need. DSPy uses Chat Completions by default, and that is the path we tested. Unbiased also serves /v1/responses, but DSPy’s docs warn that not every provider supports its Responses mode, so stay on the default unless you have a reason to switch.

Do I need an OpenAI account?

No. The prefix names a request format, not a company. With api_base and api_key set, requests go to Unbiased with your Unbiased key, and your Unbiased plan pays for them. DSPy itself is free and open source.

Is Pareto made by the DSPy team?

No. Pareto is Unbiased’s model. DSPy is made by Stanford NLP, and Unbiased is not affiliated with or endorsed by them. You keep DSPy 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.

Put your ticket queue through a DSPy signature

One dspy.LM line, one key and the same program. Pareto starts at $10 a month for 50M tokens a week. Building agents that call a model all day? See what that costs.

Choose Personal · $10/month See the setup →