Not Diamond Review: Pricing & Comparison

Not Diamond: Let the Machine Decide Which Model to Use

Have you ever run into this dilemma: within the same app, Claude is better for writing code, GPT is better for marketing copy, DeepSeek Flash is cheaper for quick translation, and Opus is the only one strong enough for complex reasoning — but you don’t want to hard-code that logic into your app, because model capability rankings shift every month.

Not Diamond’s (notdiamond.ai) answer: let a model make that choice for you.

Not Diamond is a smart routing layer that automatically picks the most suitable model based on each request’s characteristics (task type, complexity, language, length, etc.) — the goal is to maximize output quality within a given cost budget, or minimize cost for a given quality bar.

How the Routing Logic Works

Not Diamond trained a routing model on a large volume of benchmark data:

1. Receive your request
2. Classify the task type (code/writing/reasoning/translation, etc.)
3. Assess complexity
4. Look up each model’s current performance ranking for that task type
5. Select the optimal model based on your configured cost/quality preference
6. Forward the request and return the result

Routing latency is under 10ms — its impact on total latency is negligible.

Integration Example

from notdiamond import NotDiamond

client = NotDiamond(api_key="your Not Diamond API key")

session_id, provider, model = client.chat.completions.model_select(
    messages=[
        {"role": "system", "content": "You are a professional code review engineer"},
        {"role": "user", "content": "Help me review this TypeScript code for performance issues"}
    ],
    model=["openai/gpt-5.5", "anthropic/claude-fable-5", "google/gemini-3.5-flash"],
    tradeoff="cost"  # or "quality"
)

print(f"Not Diamond selected: {provider}/{model}")

# Then send the actual request using the selected model

Also supports direct pass-through in OpenAI-compatible format.

When to Bring In Not Diamond

Good fit for:

• High-traffic apps where quality requirements vary significantly across requests, so routing can save meaningful cost
• Not wanting to maintain hand-written routing rules that need constant manual updates as models evolve
• Needing a benchmark reference — Not Diamond’s routing choices double as a real-time signal of each model’s relative performance

Poor fit for:

• Low-traffic use cases, where the routing overhead (time + money) isn’t worth it
• Cases with a hard requirement for a specific model (compliance/data agreements)
• Mainland China users, since a proxy is required

A comparable routing tool is Unify AI — worth testing both side by side to compare routing accuracy.

Information verified 2026-07-04. The routing model is continually updated — refer to notdiamond.ai’s official benchmark data for the latest figures.

Related Reviews

• Jiekou AI: full model coverage, clean interface design, 30-second quick integration, mainland direct connect
• RunPod: per-second billed GPU cloud, community compute pool, 70% cheaper than AWS
• Together AI: large-scale open-source model compute aggregation, 100+ models via one API, suited to both research and enterprise use
• Inworld Router: 200+ models at 0% markup, deeply optimized for gaming and entertainment AI scenarios, smart request-complexity-based routing