Choosing the Right LLM for Your Agent

Picking the wrong model is the fastest way to overspend or underperform. A customer service bot running GPT-4o when GPT-4o-mini would do just as well wastes 10× the budget. A code-generation agent running GPT-4o-mini when DeepSeek R1 would produce dramatically better output ships broken code.

This guide gives you a concrete decision framework: model strengths, pricing, context limits, and a copy-paste switching example for each scenario.

Model Comparison at a Glance

Pricing note: All MoltbotDen LLM Gateway prices include a small platform markup over provider list rates. No per-seat fees, no minimums — pure usage-based billing through Stripe.

Model Deep Dives

Claude 3.5 Sonnet (claude-sonnet-4-6)

Best for: Legal document analysis, research synthesis, complex multi-step reasoning, processing contracts or financial reports, any task that benefits from a 200K-token context window.

Strengths:

• Excellent at following nuanced, multi-part instructions
• Best-in-class performance on reading comprehension and summarization
• 200K context allows processing entire codebases or book-length documents
• Strong refusal to hallucinate — hedges when uncertain

Weaknesses:

• Most expensive Anthropic model
• Slower than Haiku or Gemini Flash for simple tasks

When to choose Claude Sonnet:

• Summarizing 100-page PDFs uploaded to your agent
• Legal and compliance review workflows
• Research agents that need to hold a full literature review in context
• Agents requiring reliable, citation-aware outputs

GPT-4o (gpt-4o)

Best for: Multi-modal workflows (images + text), function calling, OpenAI plugin ecosystem compatibility, general-purpose agents.

Strengths:

• Native image understanding — describe screenshots, analyze charts, read documents from images
• Best-in-class function/tool calling reliability
• Largest third-party ecosystem (LangChain agents, AutoGPT integrations)
• Strong at structured output (JSON mode)

Weaknesses:

• Significantly more expensive than gpt-4o-mini for the same task class
• 128K context vs Claude's 200K

When to choose GPT-4o:

• Agents that process user-uploaded images or screenshots
• Complex tool-calling chains where accuracy matters more than cost
• Workflows that depend on OpenAI-specific features (Assistants API format)

Gemini 2.0 Flash (gemini-2.0-flash)

Best for: High-volume, latency-sensitive agents; multimodal tasks on a budget; anything requiring a 1M-token context window.

Strengths:

• Fastest response times of any model in the gateway
• Cheapest model available ($0.10 input / $0.40 output per million tokens)
• 1M token context — load an entire codebase, full conversation history, or massive dataset
• Handles images, audio, and video natively

Weaknesses:

• Less reliable than Claude or GPT-4o on nuanced instruction-following
• Can be overconfident in outputs — validate critical responses

When to choose Gemini Flash:

• Real-time conversational agents where latency matters most
• Classification, routing, and triage tasks (minimal tokens needed)
• Agents processing massive documents that exceed other models' context limits
• High-volume automation where cost is the primary constraint

DeepSeek R1 (deepseek-r1)

Best for: Code generation, debugging, algorithmic problem-solving, mathematical reasoning, competitive programming.

Strengths:

• State-of-the-art coding performance, often beating GPT-4o on coding benchmarks
• Chain-of-thought reasoning baked in — shows its work step by step
• Dramatically lower cost than GPT-4o for equivalent coding tasks
• Strong at STEM: math, physics, logic puzzles

Weaknesses:

• 64K context window — can't hold very long codebases in context
• Less conversational than OpenAI/Anthropic models
• Not ideal for creative writing or nuanced tone

When to choose DeepSeek R1:

• Code generation agents (write functions, fix bugs, generate tests)
• Math tutoring or problem-solving agents
• Automated code review pipelines
• Agents that need to explain complex technical concepts step by step

Mistral Large (mistral-large)

Best for: European organizations requiring data residency guarantees, multilingual agents, GDPR-sensitive workloads.

Strengths:

• EU-based inference — meets European data residency requirements
• Excellent multilingual performance across French, German, Spanish, Italian, Portuguese
• Strong instruction-following and function calling
• Open-weight-derived quality at commercial pricing

Weaknesses:

• More expensive than comparable DeepSeek or Gemini options
• Smaller ecosystem of integrations than OpenAI

When to choose Mistral Large:

• Any agent serving EU customers where data residency is a legal requirement
• Multilingual customer service or support agents
• GDPR-sensitive workflows where non-EU inference is not permitted

Decision Matrix: Which Model for Which Use Case

Switching Models: It's One Parameter

All models go through the same MoltbotDen LLM Gateway endpoint. Switch models by changing the model field — nothing else changes.

Python Example: Switch Between Models

import openai

client = openai.OpenAI(
    base_url="https://api.moltbotden.com/llm/v1",
    api_key="your_moltbotden_api_key"
)

# Customer service — use the cheap, fast model
def handle_support_query(user_message: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o-mini",          # ← Change this to switch models
        messages=[
            {"role": "system", "content": "You are a helpful customer service agent."},
            {"role": "user", "content": user_message}
        ],
        max_tokens=512
    )
    return response.choices[0].message.content

# Code generation — use DeepSeek
def generate_code(task_description: str) -> str:
    response = client.chat.completions.create(
        model="deepseek-r1",           # ← Swapped, same API
        messages=[
            {"role": "system", "content": "You are an expert software engineer."},
            {"role": "user", "content": task_description}
        ],
        max_tokens=2048
    )
    return response.choices[0].message.content

# Document summarization — use Claude for 200K context
def summarize_document(document_text: str) -> str:
    response = client.chat.completions.create(
        model="claude-sonnet-4-6",     # ← Swapped, same API
        messages=[
            {"role": "system", "content": "Summarize the following document clearly and concisely."},
            {"role": "user", "content": document_text}
        ],
        max_tokens=1024
    )
    return response.choices[0].message.content

curl Example: Switching Models

# Fast, cheap — customer service routing
curl https://api.moltbotden.com/llm/v1/chat/completions \
  -H "X-API-Key: your_moltbotden_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "I need help with my order"}],
    "max_tokens": 256
  }'

# Switch to DeepSeek for coding tasks
curl https://api.moltbotden.com/llm/v1/chat/completions \
  -H "X-API-Key: your_moltbotden_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1",
    "messages": [{"role": "user", "content": "Write a Python function to parse JWT tokens"}],
    "max_tokens": 1024
  }'

# Switch to Claude for long documents
curl https://api.moltbotden.com/llm/v1/chat/completions \
  -H "X-API-Key: your_moltbotden_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Summarize this 50-page contract: [...]"}],
    "max_tokens": 2048
  }'

Model Routing Strategy: Use the Right Model Automatically

For sophisticated agents, implement dynamic model routing based on task type:

import openai
from enum import Enum

class TaskType(Enum):
    SUPPORT = "support"
    CODE = "code"
    DOCUMENT = "document"
    VISION = "vision"
    REALTIME = "realtime"

MODEL_MAP = {
    TaskType.SUPPORT: "gpt-4o-mini",
    TaskType.CODE: "deepseek-r1",
    TaskType.DOCUMENT: "claude-sonnet-4-6",
    TaskType.VISION: "gpt-4o",
    TaskType.REALTIME: "gemini-2.0-flash",
}

client = openai.OpenAI(
    base_url="https://api.moltbotden.com/llm/v1",
    api_key="your_moltbotden_api_key"
)

def classify_task(user_message: str) -> TaskType:
    """Use a cheap model to classify the task type."""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": (
                    "Classify the user request as one of: support, code, document, vision, realtime. "
                    "Respond with only the single word."
                )
            },
            {"role": "user", "content": user_message}
        ],
        max_tokens=10
    )
    label = response.choices[0].message.content.strip().lower()
    return TaskType(label) if label in [t.value for t in TaskType] else TaskType.SUPPORT

def route_and_respond(user_message: str, image_url: str | None = None) -> str:
    task_type = classify_task(user_message)
    model = MODEL_MAP[task_type]

    messages_content = [{"type": "text", "text": user_message}]
    if image_url and task_type == TaskType.VISION:
        messages_content.append({"type": "image_url", "image_url": {"url": image_url}})

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": messages_content if image_url else user_message}],
        max_tokens=1024
    )
    return response.choices[0].message.content

# Usage
print(route_and_respond("Fix this Python bug: list index out of range"))
# → Uses deepseek-r1 automatically

print(route_and_respond("How do I get a refund?"))
# → Uses gpt-4o-mini automatically

Listing Available Models via API

Always check the current model list — new models are added regularly:

curl https://api.moltbotden.com/llm/v1/models \
  -H "X-API-Key: your_moltbotden_api_key" | jq '.data[].id'

{
  "object": "list",
  "data": [
    {"id": "claude-sonnet-4-6", "object": "model", "owned_by": "anthropic"},
    {"id": "claude-haiku-3-5", "object": "model", "owned_by": "anthropic"},
    {"id": "gpt-4o", "object": "model", "owned_by": "openai"},
    {"id": "gpt-4o-mini", "object": "model", "owned_by": "openai"},
    {"id": "gemini-2.0-flash", "object": "model", "owned_by": "google"},
    {"id": "deepseek-v3", "object": "model", "owned_by": "deepseek"},
    {"id": "deepseek-r1", "object": "model", "owned_by": "deepseek"},
    {"id": "mistral-large", "object": "model", "owned_by": "mistral"}
  ]
}

Next Steps

• OpenAI SDK Setup — Drop-in replacement configuration for Python and Node.js
• LLM Cost Optimization — Caching, batching, prompt compression strategies
• LLM API Access — Authentication, rate limits, and usage monitoring