How can I change the configured model for an LlmAgent at runtime?

[tdakanalis]

Hi,

I have a use case where I want to use the same agent in both text and live audio modes. My challenge is that I want to use gemini-2.5-flash for text and gemini-live-2.5-flash-native-audio for live audio. How can I achieve this?

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: The model for an LlmAgent is configured at the time of its creation and cannot be changed on an existing agent instance at runtime. The recommended approach is to create two separate LlmAgent instances, one for each model, and then choose the appropriate agent to run based on the context (text or live audio).

---

Hi there! That's an interesting use case.

The model is a fundamental part of an LlmAgent's configuration and is set when you first create the agent. [3] The ADK is not designed to allow the model of an already-instantiated agent to be changed at runtime.

The most effective way to achieve your goal is to adopt a multi-agent approach. You can create two distinct LlmAgent instances:

1. An agent for handling text-based interactions, configured with gemini-2.5-flash.
2. An agent for handling live audio, configured with gemini-live-2.5-flash-native-audio.

Here is a conceptual example of how you might set this up:

from google.adk.agents import LlmAgent
from google.adk.models import Gemini

# Agent for text-based interactions
text_agent = LlmAgent(
    model=Gemini(model="gemini-2.5-flash"),
    instruction="You are a helpful text-based assistant."
)

# Agent for live audio interactions
audio_agent = LlmAgent(
    model=Gemini(model="gemini-live-2.5-flash-native-audio"),
    instruction="You are a helpful voice assistant."
)

# --- In your application logic ---

def process_request(is_live_audio: bool, user_input: str):
    if is_live_audio:
        # Use the runner with the agent configured for audio
        print("Using the live audio agent...")
        # runner.run(agent=audio_agent, ...)
    else:
        # Use the runner with the agent configured for text
        print("Using the text agent...")
        # runner.run(agent=text_agent, ...)

In this pattern, your application logic would determine whether the context is live audio or text and then select the appropriate agent to process the request. This keeps the concerns of each modality separate and clean. This is conceptually similar to how different agents can be used for different tasks in a multi-agent system. [4]

Let me know if you have any other questions!

[tdakanalis]

@adk-bot My agent actually consists of multiple interacting sub-agents with their own prompts and agent transfer logic, so duplicating all that logic does not seem very practical. I assume that if I could keep the same name for both the text and live instances of each individual sub-agent, I could minimize the duplicated code to just the agent definition, but I do not think that is possible.

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: The recommended approach is to create two separate LlmAgent instances, one for each model, and use a coordinator agent to route requests to the appropriate one based on the input modality.

---

Hi @tdakanalis,

That's a great question! While you can't directly change the model of an existing LlmAgent at runtime, the recommended approach in ADK for this use case is to use a multi-agent system with a coordinator pattern.

Here's how you can achieve this:

1. Create two specialized LlmAgent instances:

   • One for handling text-based interactions with model="gemini-2.5-flash".
   • Another for handling live audio with model="gemini-live-2.5-flash-native-audio".

2. Create a Coordinator Agent:

   • This will be a parent LlmAgent that has the two specialized agents as sub_agents.
   • The coordinator's instructions will be to analyze the incoming request and delegate it to the appropriate sub-agent (text or audio).

Here is a conceptual example in Python:

from google.adk.agents import LlmAgent

# 1. Define the specialized agents
text_agent = LlmAgent(
    name="TextAgent",
    model="gemini-2.5-flash",
    description="Handles text-based conversations."
)

audio_agent = LlmAgent(
    name="AudioAgent",
    model="gemini-live-2.5-flash-native-audio",
    description="Handles live audio conversations."
)

# 2. Define the coordinator agent
coordinator = LlmAgent(
    name="CoordinatorAgent",
    model="gemini-2.5-flash", # A lightweight model is usually sufficient for routing
    instruction="""
        You are a coordinator agent. Your job is to route the user's request
        to the correct sub-agent. If the user is interacting via text,
        delegate to the TextAgent. If the user is interacting via audio,
        delegate to the AudioAgent.
    """,
    sub_agents=[text_agent, audio_agent]
)

This approach is flexible and aligns with the structured multi-agent patterns that ADK is designed to support. You can find more information about this in the ADK documentation on Multi-Agent Systems. [1]

Let me know if you have any other questions!

[1] https://google.github.io/adk-docs/agents/multi-agents/