Early access · OpenAI-compatible

One endpoint.
Every model.

Mungol AI routes each request to the model best suited for it — across leading providers — through a single OpenAI-compatible API. Frontier results, no vendor lock-in, one bill.

Start building How it works

one drop-in change

from openai import OpenAI

client = OpenAI(
    base_url="https://api.mungol.com/v1",
    api_key="mgl-...",
)

resp = client.chat.completions.create(
    model="mungol",          # we pick the best model per request
    messages=[{"role": "user",
               "content": "Refactor this function for clarity."}],
)

How it works

Drop-in simple, smart underneath

Keep the API you already use. Mungol AI does the model selection so you don't ship a dozen integrations and a routing layer of your own.

Send a standard request

Point the OpenAI SDK (or any compatible client) at api.mungol.com. No new SDK, no rewrite — just a base URL and a key.

We route & orchestrate

A lightweight router scores the request and dispatches it to the model that fits — fast models for simple turns, deep reasoners for hard ones.

Get one clean answer

Streaming responses in the OpenAI shape your code already expects. Usage and cost roll up into a single dashboard and bill.

Why Mungol AI

The integration layer you'd otherwise build

OpenAI-compatible

Chat completions, streaming, and tool calls in the exact shape your code expects. Migrate by changing one base URL.

Per-request routing

Each call goes to the model best suited for it — balancing quality, latency, and cost automatically.

No vendor lock-in

One key, many providers. If a model changes or a provider has an outage, your app keeps working.

Provider controls

Opt out of specific models or providers to meet privacy, residency, or compliance needs — per project.

One bill, one dashboard

Unified usage, spend caps, and per-key budgets across every model you touch.

Bring your own keys

Use your own provider keys when you want, or let Mungol handle access. You stay in control.

Models

Two models. Pick by intent, not vendor.

Choose a tier by how hard the task is — Mungol handles which underlying model actually runs.

mungolBalanced

The everyday default. Tuned for the best mix of quality, speed, and cost across general chat, coding, and extraction.

Great for most production traffic
Low latency, streaming
Cost-aware routing

mungol-ultraDeep reasoning

For the hard problems. Leans on the strongest available reasoners and multi-step orchestration when a task needs it.

Complex reasoning & long context
Research, analysis, hard coding
Higher quality, higher cost

Quickstart

Live in two minutes

If your code already talks to the OpenAI API, you're basically done.

curl

curl https://api.mungol.com/v1/chat/completions \
  -H "Authorization: Bearer $MUNGOL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mungol",
    "messages": [{"role":"user","content":"Hello!"}],
    "stream": true
  }'

node

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.mungol.com/v1",
  apiKey: process.env.MUNGOL_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "mungol-ultra",
  messages: [{ role: "user", content: "Plan a migration." }],
  stream: true,
});

Pricing

Simple while we're in early access

Free during preview, then a flat subscription plus transparent pay-as-you-go. Prices shown are introductory and may change before general availability.

Free

$0during preview

Generous monthly request allowance
Both models
Community support

Start free

Pro

$20/ month

Higher rate limits
Pay-as-you-go beyond the included usage
Usage dashboard & spend caps
Email support

Get API key

Enterprise

Customtalk to us

Provider/residency controls
SSO & per-key budgets
Priority routing & SLAs
Dedicated support

Contact

FAQ

Questions, answered honestly

Is it really OpenAI-compatible?+

Yes — chat completions, streaming, and tool calls follow the OpenAI request/response shape, so most apps migrate by changing the base URL and key.

Which models does it use?+

Mungol routes across leading models from multiple providers and picks per request. The exact set evolves as models improve; you can restrict providers per project.

Do you train on my data?+

No. Your prompts and completions are not used to train models. Enterprise plans add residency and provider-exclusion controls.

How is this different from calling one provider?+

You get one integration, one bill, and automatic fallback/selection across providers — instead of building and maintaining that routing yourself.

Is this production-ready today?+

It is in early access. Expect rapid changes; pricing and limits are introductory. Build with that in mind.

Stop integrating models.
Start shipping.

One endpoint, every model. Grab a key and make your first call in minutes.

Get your API key