when you deploy agent via livekit dashboard web to livekit cloud, how do you edit code of that deployed agent?

Thanks for reaching out, G. I'm an AI assistant and I'm here to help. Give me a moment while I research this topic.

ah so you create livekit cloud deployed agent and then you change code then redeploy it as new agent?

Yes — that’s correct. Once you create and deploy an agent from the dashboard, you edit its code locally and then redeploy the updated project as a new agent on LiveKit Cloud. Quick recap of the workflow: • Download the agent code from the Agent Builder dashboard (you get a ZIP with the source,

Dockerfile

, and

livekit.toml

). • Make your changes locally (Python or Node.js files, instructions, tools, etc.). • Redeploy with the LiveKit CLI:

lk agent deploy --working-directory path/to/your/agent

• Optionally delete the original dashboard-deployed agent after confirming the new deployment works to avoid duplicates. If you want, tell me: • Whether your agent is Python or Node.js (I can point to the main files like

agent.py

), and • What kind of change you plan to make (logic, instructions, new tools). I’ll give specific file names and deployment tips for your runtime.

flash 2.5 gemini audio native is offered as inference?

Thanks — I’m following up on your question about “flash 2.5 gemini audio native.” I don’t have information that ties “flash 2.5 gemini audio native” to LiveKit or LiveKit Cloud inference offerings. Could you share a bit more about what you mean by that phrase? A few clarifying questions that will help me point you in the right direction: • Are you asking whether that specific model/format is available as an inference endpoint on a particular cloud provider or ML service? If so, which provider or service are you referring to? • Do you mean a text- or audio-generation model, or an on-device (native) runtime? • Are you trying to use that model inside a LiveKit agent (for example, as part of audio processing in an agent) or separately? If your goal is to integrate an external model with LiveKit (for audio transcription, generation, or processing), tell me: • whether you plan to run the model yourself (self-host) or call a hosted inference API, and • what runtime you’re using (Python/Node.js). With that info I can suggest next steps and how to connect a model/inference service to LiveKit agents or streams.

Gemini Live API plugin are this offered as inference?

Thanks — I’m responding to your question about whether the “Gemini Live API plugin” (and earlier “flash 2.5 gemini audio native”) is offered as an inference endpoint. I don’t have information that confirms those exact names are provided as inference endpoints on LiveKit Cloud. To give a useful answer, I need a bit more context from you — could you clarify one or more of the following? • Which provider or product are you asking about for inference (Google/Vertex AI, OpenAI, another hosted ML provider, or something else)? • By “Gemini Live API plugin” do you mean Google’s Gemini Live API (real‑time model/plugin) specifically, or a third‑party plugin named Gemini? • Do you need a hosted inference endpoint (cloud API you call) or a native/on‑device runtime? • Are you trying to use this model inside a LiveKit agent or pipeline (e.g., for live audio processing, transcription, or generation), or do you just want to know availability of the model itself? If your goal is to integrate an external inference service with LiveKit, tell me: • whether you’ll self‑host the model or call a hosted API, and • your runtime (Python or Node.js). With those details I can: • confirm whether that specific provider’s API is something you can call from a LiveKit agent, and • outline the integration approach (calling a hosted inference API from an agent, or running a local model and connecting it to LiveKit streams). Tell me which of the above applies and I’ll give concrete next steps.

google/vertex ai, yes i mean google gemini live api realtime model specificially. I want cloud on livekit, inside a livekit agnet

Thanks — I’m responding to your question about using the Google Gemini Live API realtime model as an inference endpoint inside a LiveKit agent deployed to LiveKit Cloud. Short answer: Yes. You can use the Gemini Live API realtime model from within a LiveKit agent running on LiveKit Cloud by using the LiveKit Google plugin (

google.realtime.RealtimeModel

). The plugin lets your agent call Gemini for low‑latency two‑way audio/video interactions and can be used directly as the agent’s LLM (no separate STT→LLM→TTS pipeline is required). Key points and next steps you can follow: • How it’s used in an agent ◦ Instantiate

google.realtime.RealtimeModel

and pass it to your

AgentSession

as the

llm

. Example (conceptual):

from livekit.plugins import google

    session = AgentSession(
      llm=google.realtime.RealtimeModel(
        voice="Puck",
        temperature=0.8,
        instructions="You are a helpful assistant",
      ),
    )

• The model supports voice settings, proactivity/affective dialogue, and can accept video input when you enable

RoomOptions(video_input=True)

. • Authentication & secrets ◦ For Gemini API set

GOOGLE_API_KEY

. ◦ For Vertex AI use

GOOGLE_APPLICATION_CREDENTIALS

(service account key file). ◦ When deploying to LiveKit Cloud, store these securely using LiveKit Cloud’s secrets store (file‑mounted secrets are supported for Vertex AI). • Deployment flow a. Add the Google plugin to your agent environment (for example:

uv add "livekit-agents[google]"

as part of your project setup). b. Configure environment variables or mounted service account file. c. Deploy the agent to LiveKit Cloud using the LiveKit CLI (

lk agent create

or

lk agent deploy

depending on your workflow). LiveKit Cloud will run the agent and route inference calls to Gemini. • Useful capabilities ◦ Real‑time audio and video handling (vision-aware agents). ◦ Control over voice and modalities (e.g., use Gemini for reasoning while using a separate TTS if desired). To give you concrete, runnable code and exact deployment steps, I need two quick details: 1. Which runtime are you using for the agent — Python or Node.js? 2. Are you planning to call Gemini Live via the Gemini API (API key) or via Vertex AI using service account credentials? Tell me those and I’ll provide the specific code snippets (for your runtime), the exact env vars or secret setup for LiveKit Cloud, and a short deploy checklist. Sources: Gemini Realtime Agent with Live Vision | LiveKit Documentation | Gemini Live API plugin | LiveKit Documentation | Google AI and LiveKit | LiveKit Documentation | Deploy and scale agents on LiveKit Cloud

so livekit does not offer inference addon for gemini live?

Thanks — I’m replying to your question about whether LiveKit offers a built‑in inference add‑on for Google’s Gemini Live API. Short answer: LiveKit does not host Gemini Live inference as a managed, built‑in add‑on. However, LiveKit fully supports using Gemini Live from inside an agent via the LiveKit Google plugin — the agent calls Gemini’s realtime API (or Vertex AI) as an external inference service. What LiveKit provides • A plugin (

google.realtime.RealtimeModel

) that lets an agent call Gemini Live in real time and use it directly as the agent’s LLM for two‑way audio/video interactions. • Support for passing voice and modality parameters, enabling video input, and using Gemini for reasoning + speech. • Secure secret handling when you deploy agents to LiveKit Cloud (you provide API keys or service account files). What you must provide/configure • The actual Gemini/Vertex inference access (API key or Vertex service account). LiveKit does not provide the model hosting or the Gemini inference endpoint itself. • Integration setup in your agent code and environment (install plugin, set env vars such as

GOOGLE_API_KEY

or

GOOGLE_APPLICATION_CREDENTIALS

, and deploy the agent). If you want, I can: • Show the exact code snippet for your runtime (Python or Node.js) that uses

google.realtime.RealtimeModel

. • Walk you through storing the Gemini/Vertex credentials as LiveKit Cloud secrets and a short deploy checklist. Which runtime are you using (Python or Node.js), and will you call Gemini via API key or via Vertex AI service account?

does livekit agent offers somewhat automation? Like querying calls, getting full lsit off number and then calling it himself or we need to build around it ourselves

Thanks — I’m replying to your question about whether LiveKit agents provide built‑in automation for querying call lists, retrieving phone numbers, and automatically placing outbound calls. Short answer: No — LiveKit Agents do not provide a built‑in system that autonomously queries phone lists and dials them for you. LiveKit gives you the building blocks (agent runtime, dispatch API, SIP calling, and tools) but you must build the orchestration around those tools. What LiveKit does provide • Agent runtime that runs your conversation logic when an agent is dispatched into a room. • Programmatic outbound calling via SIP (e.g.,

create_sip_participant

) so an agent can dial a phone number once running. • A dispatch mechanism to start agent jobs/rooms with metadata (so you can pass the phone number to the agent). • Function tools in agents so your agent logic can take actions (like creating SIP participants) during a session. What you must build • The job scheduler / orchestrator that: ◦ Queries your data source (CRM, database, call list service) to get phone numbers and customer data. ◦ Creates dispatches (or otherwise triggers agent sessions) for each number, passing the number in the job metadata. ◦ Handles retries, rate limiting, concurrency, logging, and compliance rules. • Any persistence and business logic (who to call, when, call outcomes, reporting). • The in‑agent dialing workflow that reads metadata and uses the SIP API to place the call and run the conversation. Typical automated workflow (high level) 1. Your application queries the phone list from your DB/CRM. 2. For each number, your app calls the LiveKit dispatch API (or CLI) to create a job and include the phone number in metadata. 3. The agent starts with that metadata, extracts the phone number, then calls

create_sip_participant()

to dial the number and handle the conversation. 4. Your app or the agent records call results (success/failure, transcript, tags) back to your system. Concrete examples (conceptual) • Dispatch command:

lk dispatch create \
    --new-room \
    --agent-name my-telephony-agent \
    --metadata '{"phone_number":"+15105550123"}'

• In-agent dialing (Python snippet):

dial_info = json.loads(ctx.job.metadata)
  phone_number = dial_info["phone_number"]

  await ctx.api.sip.create_sip_participant(
      api.CreateSIPParticipantRequest(
          room_name=ctx.room.name,
          sip_trunk_id='ST_xxxx',
          sip_call_to=phone_number,
          participant_identity=phone_number,
          wait_until_answered=True,
      )
  )

Helpful resources • Use the examples for outbound callers (GitHub) and the Agents telephony docs as templates when building your orchestrator and agent logic. If you’d like, I can help with the next step — tell me which part you want help with: • Building the dispatcher/orchestrator (language and hosting environment), • An end‑to‑end example agent that dials a number and records results (Python or Node.js), or • Best practices for concurrency, retries, and compliance when automating outbound calling. Sources: Agents telephony integration | LiveKit Documentation