> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zeroruntime.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Install a Zero Runtime SDK, set your environment, write an agent, and run it. A working real-time voice assistant in Python, JavaScript, or Go.

This builds a working voice assistant: it greets the caller, listens, and responds in
real time. The example uses Deepgram, Google Gemini, and Cartesia. Select your language
in the tabs; the steps are otherwise the same.

## Prerequisites

* A Zero Runtime address and auth token from the [dashboard](https://app.zeroruntime.ai/)
* API keys for the providers you use (Deepgram, Google, and Cartesia here)
* One of: Python 3.11+, Node.js 18+, or Go 1.26+

<Steps>
  <Step title="Install the SDK">
    <CodeGroup>
      ```bash Python theme={null}
      pip install zrt
      ```

      ```bash JavaScript theme={null}
      npm install @zrt/js-sdk
      ```

      ```bash Go theme={null}
      go get github.com/ZeroRuntimeAI/zrt-golang-sdk@latest
      ```
    </CodeGroup>
  </Step>

  <Step title="Set your environment">
    ```bash theme={null}
    export ZRT_RUNTIME_ADDRESS=us1.rt.zeroruntime.ai:443   # your Zero Runtime address
    export ZRT_AUTH_TOKEN=<your-token>

    export DEEPGRAM_API_KEY=<key>    # speech-to-text
    export GOOGLE_API_KEY=<key>      # the LLM (Gemini)
    export CARTESIA_API_KEY=<key>    # text-to-speech
    ```
  </Step>

  <Step title="Write your agent">
    <CodeGroup>
      ```python agent.py theme={null}
      import zrt
      from zrt import Agent, Pipeline, EOUConfig, InterruptConfig
      from zrt.plugins import DeepgramSTT, GoogleLLM, CartesiaTTS, SileroVAD, TurnDetector, RNNoise

      AGENT_ID = "assistant"

      pipeline = Pipeline(
          stt=DeepgramSTT(),
          llm=GoogleLLM(model="gemini-2.5-flash", max_output_tokens=8192),
          tts=CartesiaTTS(),
          vad=SileroVAD(threshold=0.4),
          turn_detector=TurnDetector(model="echo-large"),
          denoise=RNNoise(),
          eou_config=EOUConfig(mode="ADAPTIVE", min_max_speech_wait_timeout=[0.1, 0.3]),
          interrupt_config=InterruptConfig(
              interrupt_min_duration=0.5,
              interrupt_min_words=2,
              resume_on_false_interrupt=True,
          ),
      )


      class Assistant(Agent):
          def __init__(self):
              super().__init__(
                  agent_id=AGENT_ID,
                  instructions="You are a friendly voice assistant. Keep replies short.",
                  pipeline=pipeline,
              )

          async def on_enter(self):
              await self.session.say("Hi! How can I help?")

          async def on_exit(self):
              pass


      if __name__ == "__main__":
          # Pass the class itself (not an instance): serve() builds a fresh Assistant +
          # pipeline per call, which is required for correct per-call state under concurrent calls.
          zrt.serve(Assistant, on_ready=lambda: zrt.invoke(AGENT_ID, room=zrt.Room(playground=True)))
      ```
    </CodeGroup>
  </Step>

  <Step title="Run it">
    <CodeGroup>
      ```bash Python theme={null}
      python agent.py
      ```

      ```bash JavaScript theme={null}
      npx tsx agent.ts     # or compile with tsc and run node agent.js
      ```

      ```bash Go theme={null}
      go run .
      ```
    </CodeGroup>

    When the worker starts, it prints a **playground link** in your terminal. Open it in your
    browser to talk to your agent and hear it respond in real time.
  </Step>
</Steps>

## What's next

The [Plugins](/plugins/overview) section documents each stage you configured above:
[Deepgram](/plugins/stt/deepgram), [Google Gemini](/plugins/llm/google),
[Cartesia](/plugins/tts/cartesia), [Turn Detector](/plugins/turn-detection/namo),
[Silero](/plugins/vad/silero), and [RNNoise](/plugins/denoise/rnnoise). For how they fit
together, read [Pipeline](/concepts/pipeline); to understand what runs where, read
[Why Zero Runtime](/concepts/why-zero-runtime#how-it-works).