How do I make the agent work locally after spinning up dev mode?

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

Do I need to make another cli command to initiate the room?

You're asking how to run the agent locally after starting dev mode, and whether you need another CLI command to create/join a room. When you run the agent in dev mode (for example

uv run agent.py dev

for Python or

pnpm dev

for Node), the agent connects to LiveKit Cloud and automatically creates/joins a room as part of that process. Rooms are also created automatically when the first participant joins, so you do not need a separate CLI command to initiate the room unless you need to pre-configure specific room settings. If the agent isn't appearing in the room after

dev

, tell me: • Which agent runtime you’re using (Python or Node) • The exact dev command you ran • Any error messages or logs you see I can walk through next troubleshooting steps with those details. Sources: Voice AI quickstart | LiveKit docs | Managing rooms | LiveKit docs

python warm_transfer.py dev

is working but it doesnt talk to me like in console mode

Thanks — this helps. You're running the warm-transfer example with credentials and

python warm_transfer.py dev

, so here’s what’s happening and what you can do next. • What dev mode does:

dev

connects the agent to LiveKit Cloud and waits for external participants (web/mobile/SIP) to join a room. It does not open a local interactive voice session in your terminal, so you won't see the agent "talk to you" there. • Room creation: You do NOT need another CLI command to create or initiate the room. Rooms are created automatically when participants join (or the agent joins), so the agent is already connected and ready in dev mode. • If you want local, interactive voice in the terminal: run the agent in console mode instead:

uv run warm_transfer.py console

Console mode runs the agent locally and enables bidirectional audio/console interaction (the agent will speak and listen in your terminal). If you want, tell me whether you want to test with a browser client, SIP, or local console and I’ll give the exact steps to connect that client to the warm-transfer example. Sources: Voice AI quickstart | LiveKit docs

so if I run in dev, how do I get a participant to join the room?

You're running the warm-transfer agent in

dev

mode and want a participant to join — here’s how to get that participant connected so the agent is dispatched to the same room. Which client do you want to use to join? Pick one and I’ll give exact steps: • Web client (quick test with LiveKit Meet or a custom web app) • Local console (for interactive testing use

console

mode instead) • Mobile/desktop app built with a LiveKit SDK • SIP / PSTN call If you want the web path, tell me whether you prefer using LiveKit Meet (fast) or generating a token for a custom web page and I’ll provide the exact token fields and connect steps. Sources: Agent server | LiveKit docs | Agent dispatch | LiveKit docs | Connecting to LiveKit | LiveKit docs | server-sdk-ruby | livekit/livekit_composite | DeepWiki | Building an Automated IVR Menu Caller | LiveKit docs

how do I test with livekit meet

You're running the warm-transfer agent in

dev

mode — to test it with LiveKit Meet, do this: 1. Generate an access token for the room • Create a token with your API key/secret, an

identity

, and a grant that allows joining the room: ◦ Grant:

roomJoin: true

◦ `room`: the room name you want the participant to join (e.g.,

warm-transfer-room

) • Example (Node.js):

const at = new AccessToken(API_KEY, API_SECRET, { identity: 'tester' });
  at.addGrant({ roomJoin: true, room: 'warm-transfer-room' });
  const token = await at.toJwt();

Or generate an equivalent JWT in Python or your environment. 1. Open LiveKit Meet • Go to LiveKit Meet and open the "Custom" tab (or the custom connection UI). 1. Fill in Meet connection fields • wsUrl / url: your LiveKit server URL (for LiveKit Cloud use the provided ws/wss URL). • Token: paste the JWT you generated. • Room name: the same room name you used in the token (if the Meet UI asks separately). 1. Join the room • Click join. When the participant connects, LiveKit will create the room (if not present) and dispatch the running dev agent to that room. The agent will then subscribe to the participant’s audio/video and participate in the session. Notes and tips • Ensure the agent is running in

dev

mode before joining so it can be dispatched. • Use the same room name in token and Meet. • If you want quick testing without a custom client, LiveKit Meet is the fastest path. Want the exact token snippet for Python or help with the wsUrl you should use? Which language/environment are you using to create the token?

how to do it in python? do I need both the livekit server url and the token?

You're right to ask — you need both the LiveKit server URL and a JWT token. Below are concise Python steps to generate the token and connect via LiveKit Meet. 1) Install SDK

pip install livekit-api

2) Generate token (Python)

from livekit import api

API_KEY = "your-api-key"
API_SECRET = "your-api-secret"
ROOM = "warm-transfer-room"
IDENTITY = "tester"

token = (
    api.AccessToken(API_KEY, API_SECRET)
    .with_identity(IDENTITY)
    .with_grants(api.VideoGrants(room_join=True, room=ROOM))
    .to_jwt()
)

print("TOKEN:", token)

3) LiveKit Meet — Custom tab • Server URL: e.g.

<wss://your-project.livekit.cloud>

(LiveKit Cloud) or

<ws://localhost:7880>

(local dev) • Token: paste the printed JWT • Room name: use the same

ROOM

if Meet asks 4) Ensure agent is running in dev mode before joining so it can be dispatched to the room. If you want, I can give a snippet to generate a second token for another participant or help confirm your server URL for local vs cloud. Which would you like? Sources: LiveKit CLI Setup | LiveKit Docs | Connecting to LiveKit | LiveKit docs | client-sdk-android | livekit/livekit_composite | DeepWiki

what is the custom tab? is it in the cloud.livekit.io console?

The "Custom" tab is in the LiveKit Meet web app, not in the cloud.livekit.io console. To open it: 1. Go to https://meet.livekit.io 2. Click the "Custom" tab in the Meet UI. 3. Enter your Server URL (e.g.,

<wss://your-project.livekit.cloud>

or `ws://localhost:7880`) and the JWT token you generated, then connect. This will join the room as the participant identity in your token and cause your running agent (in dev mode) to be dispatched to that room. Need me to confirm which Server URL you should use for local vs cloud?

123939.564 INFO livekit.agents registered worker {"agent_name": "sip-inbound", "id": "AW_eMWeiYZvT5Vo", "url": "wss://initialeval-bs7a562o.livekit.cloud", "region": "US East B", "protocol": 16} I registered the worker but it is not talking in the livekit meet room

Thanks — I see the agent registered successfully but isn’t speaking in the Meet room. Let’s narrow this down. Quick checklist to verify the basics • Are you joining the same room name that the agent expects? The token you use in Meet must specify the same

room

the agent will be dispatched to. • Is the agent running the warm-transfer example (warm_transfer.py) or a different example (sip-inbound)? The agent behavior depends on the job entrypoint. • Is the agent in

dev

mode when you join from Meet? It must be running before the participant connects so it can be dispatched. Troubleshooting steps 1. Confirm room name and identities ◦ Show me the room name you used in your token and the token-generating code, or paste the token payload (I can tell you the room inside it). 1. Verify Meet connection fields ◦ Server URL: use the same LiveKit URL your agent registered with (

<wss://initialeval-bs7a562o.livekit.cloud>

) or your local URL if running locally. ◦ Token: ensure it contains

room_join: true

and

room

= the target room. 1. Check agent logs after participant joins ◦ Look for a log line showing the agent received a Job or connected to a room (something like “assigned job” or “joined room”). Paste any such log lines if you see them. 1. Confirm media flow in Meet ◦ In Meet, verify your microphone is active and audio is publishing (check the participant list and local preview). ◦ Ensure the agent is publishing TTS or audio tracks — warm-transfer should publish audio when responding. 1. If you see no job dispatch in agent logs ◦ The room may be different or permissions insufficient. Share the token payload or the minimal Python code you used to generate it so I can confirm the grants. If you’d like, paste: • The room name you used • The Python token snippet (with API key/secret redacted) • Any agent log lines after you joined the Meet room I’ll check the token/room alignment and the logs and tell you the exact next step.

I used the sip-inbound as room name

Thanks — using

sip-inbound

as the room name is fine. Let’s check a few focused items to find why the agent registered but isn’t speaking. Please provide or confirm the following (small bits of info): 1. The token-generating snippet you used (redact API keys/secrets). I need to confirm the token contains

room

= "sip-inbound" and

roomJoin: true

. 2. The Server URL you put into Meet (should match the agent's registered URL:

<wss://initialeval-bs7a562o.livekit.cloud>

). 3. Any agent log lines that appear right after you join the Meet room (especially lines mentioning “job”, “assigned”, “joined”, or errors). Quick checks you can run now: • In Meet, verify you joined room

sip-inbound

(same exact string, case-sensitive). • After joining, watch agent logs for a job assignment — if you don’t see one within a few seconds, paste the logs here. • In Meet confirm your mic is publishing (you should see your thumbnail/audio activity). If Meet is muted, the agent may not receive audio to respond to. If you prefer, paste the token (JWT) here and I’ll decode it to confirm the room and grants for you. Which of the above would you like to do first?

API_KEY = os.getenv("LIVEKIT_API_KEY")
API_SECRET = os.getenv("LIVEKIT_API_SECRET")
ROOM = os.getenv("LIVEKIT_ROOM", "sip-inbound")
IDENTITY = os.getenv("LIVEKIT_IDENTITY", "tester")

token = (
    api.AccessToken(API_KEY, API_SECRET)
    .with_identity(IDENTITY)
    .with_grants(api.VideoGrants(room_join=True, room=ROOM))
    .to_jwt()
)

and this is the token snippet

Thanks — you pasted the JWT. That token only contains the Video grant (room join) and does not request an agent be dispatched to the room. To have the agent join and speak, you can do one of two things: Option A — Add agent dispatch into the token (recommended for testing) • Generate a token that includes a RoomConfiguration with a RoomAgentDispatch entry matching your agent's name (the name shown in your agent log, e.g. "sip-inbound" or the agent_name you defined). • Example (Python):

from livekit import api

API_KEY = "your-api-key"
API_SECRET = "your-api-secret"
ROOM = "sip-inbound"
IDENTITY = "tester"
AGENT_NAME = "sip-inbound"  # must match agent's registered name

token = (
    api.AccessToken(API_KEY, API_SECRET)
    .with_identity(IDENTITY)
    .with_grants(api.VideoGrants(room_join=True, room=ROOM))
    .with_room_config(
        api.RoomConfiguration(
            agents=[
                api.RoomAgentDispatch(agent_name=AGENT_NAME)
            ]
        )
    )
    .to_jwt()
)
print(token)

• Use that token in LiveKit Meet’s Custom tab with the same server URL. When the participant joins, LiveKit will dispatch the agent to the room. Option B — Manually dispatch the running agent 1. Ensure your agent process is running in dev mode: uv run agent.py dev 1. Dispatch a job to the agent: lk dispatch create --room sip-inbound --agent-name sip-inbound (Replace

sip-inbound

if your agent_name differs.) Quick checks • Make sure the agent_name used in dispatch matches the agent's registered name from the logs. • Confirm the agent is running in dev mode before joining the Meet room or before creating the dispatch. Which option would you like to try? If you want, paste the agent_name from your logs and I’ll give the exact token snippet with that name.

Is this better? eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ2aWRlbyI6eyJyb29tSm9pbiI6dHJ1ZSwicm9vbSI6InNpcC1pbmJvdW5kIiwiY2FuUHVibGlzaCI6dHJ1ZSwiY2FuU3Vic2NyaWJlIjp0cnVlLCJjYW5QdWJsaXNoRGF0YSI6dHJ1ZX0sInJvb21Db25maWciOnsiYWdlbnRzIjpbeyJhZ2VudE5hbWUiOiJNYXlhIn1dfSwic3ViIjoidGVzdGVyIiwiaXNzIjoiQVBJdWRtZ01DZFd2N040IiwibmJmIjoxNzY1OTkzNDkzLCJleHAiOjE3NjYwMTUwOTN9.lyvKWZIopANX5X7DQOpNkVgiX5

Good — the new token includes a roomConfig with an agent named "Maya", which can work, but only if a running agent is registered with that exact name. Next steps (pick one): • Verify agent name: check your agent logs for the registered agent_name (you previously showed "sip-inbound"). If the log shows "sip-inbound", regenerate the token with

agent_name="sip-inbound"

. • Or rename agent: change your agent code/config so it registers as "Maya" (must match token). Also ensure: • The agent process is running in

dev

mode before you join from Meet. • Meet uses the same Server URL your agent registered with (

<wss://initialeval-bs7a562o.livekit.cloud>

). If you want, paste the agent_name from your latest agent log (or I can generate the exact Python snippet using

"sip-inbound"

). Which would you like?

is the room called sip inbound or is it agent name sip inbound or both?

Good question — they are two different things: • Room name = the virtual meeting space participants join (e.g.,

sip-inbound

). Your token must include this in the Video grant so the participant can join that room. • Agent name = the identifier for the agent process (e.g.,

sip-inbound

or

Maya

). This is used when dispatching jobs to a specific agent. If you include a RoomConfiguration with an agent entry in the token, the agent_name there must match a running agent’s registered name for dispatch to occur. They can be the same string (common for simplicity), but they don’t have to be. For your setup to work: 1. Ensure the token’s Video grant

room

is the room you want participants to join. 2. If you rely on token-based dispatch, include a RoomConfiguration with

agent_name

that matches the agent shown in your agent logs. 3. Or start the agent in dev mode and manually dispatch it to the room (

lk dispatch create --room sip-inbound --agent-name <agent_name>

). Tell me the agent_name from your latest agent log and the room you want to use and I’ll give the exact token snippet.

import logging

from dotenv import load_dotenv

from livekit.agents import (
    Agent,
    AgentServer,
    AgentSession,
    JobContext,
    cli,
    room_io,
)
from livekit.agents.beta.workflows import WarmTransferTask
from livekit.agents.llm import ToolError, function_tool
from livekit.plugins import noise_cancellation, silero
from livekit.plugins.turn_detector.multilingual import MultilingualModel

from config import Config

logger = logging.getLogger("warm-transfer")

load_dotenv(".env.local")

# ensure the following variables/env vars are set
SIP_TRUNK_ID = Config.SIP_TRUNK_ID
SUPERVISOR_PHONE_NUMBER = Config.TRANSFER_PHONE_NUMBER
SIP_NUMBER = Config.OUTBOUND_SIP_NUMBER

class SupportAgent(Agent):
    def __init__(self) -> None:
        super().__init__(instructions=INSTRUCTIONS)

    async def on_enter(self):
        self.session.generate_reply()

    @function_tool
    async def transfer_to_human(self) -> None:
        """Called when the user asks to speak to a human agent. This will put the user on
           hold while the supervisor is connected.

        Ensure that the user has confirmed that they wanted to be transferred. Do not start transfer
        until the user has confirmed.
        Examples on when the tool should be called:
        ----
        - User: Can I speak to your supervisor?
        - Assistant: Yes of course.
        ----
        - Assistant: I'm unable to help with that, would you like to speak to a human agent?
        - User: Yes please.
        ----
        """

        <http://logger.info|logger.info>("tool called to transfer to human")
        await self.session.say(
            "Please hold while I connect you to a human agent.", allow_interruptions=False
        )
        try:
            assert SIP_TRUNK_ID is not None
            assert SUPERVISOR_PHONE_NUMBER is not None

            result = await WarmTransferTask(
                target_phone_number=SUPERVISOR_PHONE_NUMBER,
                sip_trunk_id=SIP_TRUNK_ID,
                sip_number=SIP_NUMBER,
                chat_ctx=self.chat_ctx,
                # add extra instructions for summarization
                # you can also customize the entire instructions by overriding the `get_instructions` method
                extra_instructions=SUMMARY_INSTRUCTIONS,
            )
        except ToolError as e:
            logger.error(f"failed to transfer to supervisor with tool error: {e}")
            raise e
        except Exception as e:
            logger.exception("failed to transfer to supervisor")
            raise ToolError(f"failed to transfer to supervisor with error: {e}") from e

        <http://logger.info|logger.info>(
            "transfer to supervisor successful",
            extra={"supervisor_identity": result.human_agent_identity},
        )
        await self.session.say(
            "you are on the line with my supervisor. I'll be hanging up now.",
            allow_interruptions=False,
        )
        self.session.shutdown()


server = AgentServer()


@server.rtc_session(agent_name="sip-inbound")
async def entrypoint(ctx: JobContext):
    session = AgentSession(
        vad=silero.VAD.load(),
        llm="openai/gpt-4.1-mini",
        stt="assemblyai/universal-streaming",
        tts="elevenlabs",
        turn_detection=MultilingualModel(),
    )

    support_agent = SupportAgent()

    await session.start(
        agent=support_agent,
        room=ctx.room,
        room_options=room_io.RoomOptions(
            audio_input=room_io.AudioInputOptions(
                # enable Krisp BVC noise cancellation
                noise_cancellation=noise_cancellation.BVCTelephony(),
            ),
            delete_room_on_close=False,  # keep the room open for the customer and supervisor
        ),
    )


INSTRUCTIONS = """
# Personality

You are friendly and helpful, with a welcoming personality
You're naturally curious, empathetic, and intuitive, always aiming to deeply understand the user's intent by actively listening.

# Environment

You are engaged in a live, spoken dialogue over the phone.
There are no other ways of communication with the user (no chat, text, visual, etc)

# Tone

Your responses are warm, measured, and supportive, typically 1-2 sentences to maintain a comfortable pace.
You speak with gentle, thoughtful pacing, using pauses (marked by "...") when appropriate to let emotional moments breathe.
You naturally include subtle conversational elements like "Hmm," "I see," and occasional rephrasing to sound authentic.
You actively acknowledge feelings ("That sounds really difficult...") and check in regularly ("How does that resonate with you?").
You vary your tone to match the user's emotional state, becoming calmer and more deliberate when they express distress.

# Identity

You are a customer support agent for LiveKit.

# Transferring to a human

In some cases, the user may ask to speak to a human agent. This could happen when you are unable to answer their question.
When such is requested, you would always confirm with the user before initiating the transfer.
"""


SUMMARY_INSTRUCTIONS = """
Introduce the conversation from your perspective as the AI assistant who participated in this call:

WHO you're talking to (name, role, company if mentioned)
WHY they contacted you (goal, problem, request)
WHY a human agent is requested or needed at this point
Brief summary in 100-200 characters from a first-person perspective"""


if __name__ == "__main__":
    # this example requires explicit dispatch using named agents
    # supervisor will be placed in a separate room, and we do not want it to dispatch the default agent
    cli.run_app(server)

based on this code, what is it?

From your code: • Agent name: "sip-inbound" — set by the decorator

@server.rtc_session(agent_name="sip-inbound")

. That's the name the agent registers with and must match any dispatch target or token-based agent dispatch entry. • Room name: any string you choose (you used

"sip-inbound"

in your token code). The room name is what participants join and must appear in the Video grant of the token. Practical next steps: • If you want the agent auto-dispatched when a Meet participant joins, generate a token that includes: ◦ Video grant with

room="sip-inbound"

(to join the room), and ◦ RoomConfiguration with an agent dispatch entry

agent_name="sip-inbound"

(so LiveKit routes the job to this running agent). Example Python token snippet using your agent name:

from livekit import api

token = (
    api.AccessToken(API_KEY, API_SECRET)
    .with_identity("tester")
    .with_grants(api.VideoGrants(room_join=True, room="sip-inbound"))
    .with_room_config(api.RoomConfiguration(agents=[api.RoomAgentDispatch(agent_name="sip-inbound")]))
    .to_jwt()
)

Or, keep your current token and manually dispatch while the agent is running: • Start agent:

uv run warm_transfer.py dev

• Dispatch:

lk dispatch create --room sip-inbound --agent-name sip-inbound

Tell me which option you want and I’ll provide the exact command or token snippet with your env vars filled (redacting secrets).

token = (

api.AccessToken(API_KEY, API_SECRET)

.with_identity(IDENTITY)

.with_grants(api.VideoGrants(_room_join_=True, room=ROOM))

.with_room_config(api.RoomConfiguration(agents=[

api.RoomAgentDispatch(_agent_name_='sip-inbound')

]))

.to_jwt()

)

print("TOKEN:", token)

I have this generated is this correct? when i join the meet.livekit room its not htere

You're almost correct — that token shape is right for requesting an agent dispatch, but the agent must actually be registered and running with the same agent_name, and Meet must connect to the same LiveKit server. Quick checklist and next steps to get it working: 1) Confirm the agent process is running • Run your agent in dev mode before joining Meet: uv run warm_transfer.py dev • From your earlier logs the agent registered as "sip-inbound" — ensure the running process still shows that name. 2) Confirm Meet uses the same Server URL • In Meet (Custom tab) set Server URL to the same one the agent logged (example you showed): wss://initialeval-bs7a562o.livekit.cloud 3) Confirm token contents • Your token code is correct: it includes Video grant for room join and a RoomConfiguration with agent_name="sip-inbound". 4) Join the room from Meet • Use the token you generated and Room = "sip-inbound" in Meet. Join the room after the agent is running. 5) Check agent logs after joining • Look for job assignment / join logs in the agent output (lines showing a job received or ctx.room/join). If you don’t see any job logs, dispatch didn't reach the agent. 6) If dispatch still doesn't occur, try manual dispatch • While the agent is running, run: lk dispatch create --room sip-inbound --agent-name sip-inbound • Watch the agent logs for an assigned job and room join. If you run the agent now and paste the agent log lines that appear after you join Meet (or after running the manual dispatch), I’ll tell you exactly what to look for and the next command.

chuyouchia@Chus-MacBook-Air patient-status-inbound-livekit % uv run warm_transfer.py dev 
    14:04:24.689 DEBUG  asyncio            Using selector: KqueueSelector  
    14:04:24.690 DEV    livekit.agents     Watching /Users/chuyouchia/Desktop/patient-status-inbound-livekit  
    14:04:25.424 DEBUG  asyncio            Using selector: KqueueSelector  
    14:04:25.431 INFO   livekit.agents     starting worker {"version": "1.3.8", "rtc-version": "1.0.19"}
                 INFO   livekit.agents     starting inference executor  
    14:04:25.437 INFO   livekit.agents     initializing process {"pid": 90452, "inference": true}
    14:04:27.996 INFO   livekit.agents     process initialized {"pid": 90452, "inference": true, "elapsed_time": 2.56}
    14:04:27.999 INFO   livekit.agents     HTTP server listening on :54545  
    14:04:28.338 INFO   livekit.agents     registered worker  
                                         {"agent_name": "sip-inbound", "id": "AW_sUjUju2o5yv7", "url": 
"<wss://initialeval-bs7a562o.livekit.cloud>", "region": "US East B", "protocol": 16}

This is what I see after warmup.py

Thanks — your agent is registered as

sip-inbound

and running in dev mode (logs confirm). Next steps to get it into the Meet room: 1. Ensure Meet connects to the same LiveKit URL shown in your logs: ◦ Server URL: wss://initialeval-bs7a562o.livekit.cloud 1. Use a token that: ◦ Grants

room_join=True

for room

sip-inbound

◦ Includes a RoomConfiguration dispatch for

agent_name="sip-inbound"

(your token snippet did this — good) 1. Join Meet after the agent is running (order matters). If the agent still doesn’t appear, dispatch manually while the agent is running:

lk dispatch create --room sip-inbound --agent-name sip-inbound

Watch the agent terminal for logs showing a received job / joined room. 1. What to look for in agent logs after dispatch/join: ◦ A log line about receiving a job or “assigned job” ◦ A log showing the agent joined the room or session started ◦ Any error/exception lines If you run the manual dispatch now, paste the new agent log lines you see and I’ll read them and tell you exactly what to do next.