Model Registry

Google

Chat models for text and files. Use a Live model below if you need voice.

Google Live

Voice agents. Use these when the agent should listen and speak in real time.

Background tools

On a Live voice agent, a slow tool can freeze the conversation — the model goes quiet until the tool returns. Background tools fix that: the agent keeps speaking while the tool runs, then folds the result in when it arrives.

You control this with two fields on each tool: response_scheduling (run in the background, and say when to react) and blocking (hold the agent still until the tool finishes). Non-Live models ignore both.

Defaults by model

Start from the model default, then override only the tools that need different behavior.

When the agent reacts

Pick a scheduling mode for each background tool. This only matters when the tool is not blocking.

In the console

1. Open your agent and pick a Live model that supports background tools.
2. On each tool, use Run in background to choose whether the agent keeps talking while it runs.
3. For background tools, choose when the agent should react to the result (WHEN_IDLE, INTERRUPT, or SILENT).
4. On gemini-3.8-live, turn background off (blocking) only for tools that must finish before the next spoken reply.

In code (Python)

Decorate tools with response_scheduling or blocking. Do not set both on the same tool — a blocking tool has no result left to schedule.

from hikigai.agentsdk import tool

# Background: agent keeps talking; reacts at a natural pause (default on 3.8).
@tool(response_scheduling="WHEN_IDLE")
def fetch_record(patient_id: str) -> dict:
    """Pull a chart. Slow, and the agent can keep talking meanwhile."""
    return lookup(patient_id)

# Urgent: speak as soon as the result arrives.
@tool(response_scheduling="INTERRUPT")
def check_allergy(patient_id: str, drug: str) -> dict:
    """Safety check — interrupt if something is wrong."""
    return allergy_api(patient_id, drug)

# Prefetch: absorb the result quietly for later turns.
@tool(response_scheduling="SILENT")
def warm_context(patient_id: str) -> dict:
    """Load context the agent may need later."""
    return prefetch(patient_id)

# Blocking: required on gemini-3.8-live when the agent must wait.
@tool(blocking=True)
def take_payment(amount: float) -> dict:
    """Must settle before the agent says anything else."""
    return charge(amount)

In code (Node)

Same idea in TypeScript — use responseScheduling or blocking on tool().

import { tool } from '@hikigai/agent-sdk'

const fetchRecord = tool({
  responseScheduling: 'WHEN_IDLE',
  description: 'Pull a chart while the agent keeps talking.',
})(async (patientId: string) => lookup(patientId))

const takePayment = tool({
  blocking: true,
  description: 'Must settle before the agent speaks again.',
})(async (amount: number) => charge(amount))

Quick rules

• Prefer background for slow, non-critical work (lookups, EHR pulls, weather, notes).
• Prefer blocking for irreversible or gatekeeping steps (payments, identity confirmation, "are you sure?" actions).
• Start with WHEN_IDLE; use INTERRUPT only when the user needs to hear the result immediately.
• Never set blocking and response_scheduling together — the SDK rejects that combination.

Anthropic