Agents using different LLMS

[donzorro]

im trying to find examples on how to create two agents, one using OpenAi llm and another using Ollama, and pass each one its corresponding API_KEY, since most of the examples on the website define the keys (using the same name) via EXPORT

Thanks!

[donzorro]

i think i got it to work. this is an example on how to get ollama+deepseek to work

from praisonaiagents import Agent

llm_config = {
    "model": "ollama/deepseek-r1:8b",  # Model name without provider prefix
    
    # Core settings
    "temperature": 0.7,                # Controls randomness (like temperature)
    "timeout": 30,                 # Timeout in seconds
    "top_p": 0.9,                    # Nucleus sampling parameter
    "max_tokens": 1000,               # Max tokens in response
    
    # API settings (optional)
    "api_key": None,                 # Your API key (or use environment variable)
    "base_url": "http://localhost:11434/v1",                # Custom API endpoint if needed
    
    # Response formatting
    "response_format": {             # Force specific response format
        "type": "text"               # Options: "text", "json_object"
    },
}


#agent.start("What is KAG in one line?") # Retrieval
agent = Agent(instructions="You are helpful Assisant", llm=llm_config)
agent.start("Why sky is Blue?")

[KushagraSikka]

1.	Each agent is initialized with its respective LLM config.
2.	OpenAI requires an API key, while Ollama does not (if running locally).
3.	The base_url differentiates the endpoints (OpenAI vs. local Ollama).
4.	Agents are executed separately, and their responses can be processed independently.

[kranthi-cd]

I tried this for Azure Open AI but it's not working:

llm_config2 = {
    "model": "gpt-4o-mini",  # Model name without provider prefix
    
    # Core settings
    "temperature": 0.7,                # Controls randomness (like temperature)
    "timeout": 30,                 # Timeout in seconds
    "top_p": 0.9,                    # Nucleus sampling parameter
    "max_tokens": 1000,               # Max tokens in response
    
    # API settings (optional)
    "api_key": os.getenv("AZURE_4OMINI_KEY"),                 # Your API key (or use environment variable)
    "base_url": os.getenv("AZURE_4OMINI_ENDPOINT"),                # Custom API endpoint if needed
    "api_version": os.getenv("AZURE_API_VERSION"),
    
    # Response formatting
    "response_format": {             # Force specific response format
        "type": "text"               # Options: "text", "json_object"
    },
}

Also tried model: "azure/gpt-4o-mini", still doesn't work.
Any help?

[kranthi-cd]

This worked. Don't know why I can't directly include my variables into LLM config.

Found the solution here
https://community.crewai.com/t/litellm-apierror-azureexception-apierror-argument-of-type-nonetype-is-not-iterable-using-raw-output-instead/1316/2

os.environ["OPENAI_API_KEY"] = os.getenv("AZURE_4OMINI_KEY")
os.environ["AZURE_API_KEY"] = os.getenv("AZURE_4OMINI_KEY")
os.environ["AZURE_API_BASE"] = os.getenv("AZURE_4OMINI_ENDPOINT")
os.environ["AZURE_API_VERSION"] = os.getenv("AZURE_API_VERSION")

llm_config = {
    "model": "azure/gpt-4o-mini",
    "api_key": os.environ.get("AZURE_API_KEY"),
    "base_url": os.environ.get("AZURE_API_BASE"),
    "api_version": os.environ.get("AZURE_API_VERSION"),
    "temperature": 0.7,
    "max_tokens": 2000
}

mcp_cmd = "npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt"

search_agent = Agent(
        name="AirbnbSearchAgent",
        role="Travel Assistant",
        instructions="You help book apartments on Airbnb.",
        llm=llm_config,
        tools=[MCP(mcp_cmd)],
        verbose=True,
        cache=False,
        allow_code_execution=False,
    )

[kinthaiofficial]

Agents using different LLMs is one of the most impactful optimizations for multi-agent systems — the cost and quality difference between a 7B and 70B model is enormous, and most tasks don't need the 70B.

The pattern we've settled on for agent fleets:

Classify before route — add a lightweight pre-call classifier (can be a regex ruleset or a small model) that maps task description → required capability tier. "Summarize this text" → fast model. "Design the architecture for X" → capable model. "Debug this subtle race condition" → reasoning model.

Per-agent capability profiles — define what each specialized agent needs: research_agent: {"min_tier": "mid", "needs_tools": true}, drafting_agent: {"min_tier": "fast", "context_length": "32k"}. The orchestrator selects the cheapest model that satisfies the profile.

Cost feedback loop — agents should know their cost per output unit (per word, per retrieval, per successful task). This creates a natural optimization pressure: agents that learn to use cheaper models for appropriate sub-tasks are more competitive in a multi-agent market.

Different providers for different capabilities — Claude Haiku for retrieval and summarization (excellent cost/quality), Claude Sonnet for complex reasoning (strong mid-tier), specialized models for specific domains (coding agents → Claude or GPT-4o, math → Gemini reasoning). Provider selection and model selection are independent dimensions.

We built this multi-tier routing for KinthAI's agent network: https://blog.kinthai.ai/agent-wallet-economic-models-autonomous-agents has the economic model; https://blog.kinthai.ai/openclaw-multi-tenancy-why-vm-per-user-doesnt-scale covers the infra.

What's the task decomposition you're trying to optimize — is it by agent role, by subtask type, or by some other dimension?