https://retellai.com/?utm_source=discord&utm_medium=seo logo
Powered by
Subject: {{current_time_[timezone]}} not resolving...
# ❓・ai-evy-support
b
@AI Evy Subject: {{current_time_[timezone]}} not resolving — agent using training-cutoff date in tool calls Agent: (GPT-4.1 mini, single-prompt) Problem: Our agent's Cal.com availability checks are failing because the LLM generates start_time values in June 2024 instead of the current date. Cal.com returns {"error":"Time range is in the past"} and bookings fail. Example tool call from a live call on 2026-07-21: json { "start_time": "2024-06-06T00:00:00", "end_time": "2024-06-07T23:59:00" } What we've done: Our prompt includes The current date and time is {{current_time_America/Regina}}. in the IDENTITY section and again in our tool-call rules. The agent is published. The variable displays as a recognized token in the prompt editor. The Cal.com tool has Timezone set to America/Regina. Why we think the variable isn't resolving: The dates the model generates cluster around June 2024, which matches GPT-4.1's training cutoff. This is consistent with the model receiving no date in context and falling back to its internal default, rather than miscalculating from a provided date. This is a regression. Earlier calls (March/April 2026) produced correct start_time values in 2026. The failures began in July 2026. Questions: Is {{current_time_America/Regina}} a valid timezone string for this variable? We've seen community reports that current_time can be treated as a user-set variable and go blank when other dynamic variables are configured at the agent level. Could that apply here, and how do we check? Is there a way to bind start_time on the built-in Cal.com check-availability tool to a constant/dynamic variable so the LLM doesn't generate it at all?
a
Thanks for tagging me @bohmez. I'll look through relevant sources and get back to you shortly.
​ To learn more, see the sources I considered: [[1] Platform Changelogs | Retell AI](https://www.retellai.com/changelog) [[2] Discord message from @nocodecreative.io on 2024-12-15](https://discord.com/channels/1186424376300679209/1186462578310910112/1317840635717222432) [[3] Code tool](https://docs.retellai.com/build/single-multi-prompt/code-tool) ​
dynamic variable correctly updates the LLM's prompt when making a call." One user successfully resolved a similar issue: "I've resolved the issue by returning the time in a custom variable when the call initiates, this way the agent can work in UTC and my code can handle the timezone as needed." Question 3: Can you bind 
start_time
to a constant/dynamic variable? The built-in Cal.com tool doesn't support binding LLM-generated parameters to dynamic variables directly. However, you could use a Code Tool to calculate the correct date range and return it, or use a custom function to handle the availability check with your own date logic [(3) ]() . Action Items: 1. Replace 
{{current_time_America/Regina}}
with a custom dynamic variable (e.g., 
{{current_date_regina}}
) that you populate when creating the call 2. Update your prompt to reference this custom variable instead 3. Consider using a Code Tool or custom function to control date generation for Cal.com calls
### Answer Based on the available sources, I can address your questions about the 
{{current_time}}
system variable: Question 1: Is 
{{current_time_America/Regina}}
valid? Yes, the timezone format appears correct based on the documented pattern. The changelog indicates that 
{{current_time_[timezone]}}
supports timezone-specific formatting, with examples like 
current_time_Australia/Sydney
and 
current_time_America/New_York
[(1) ]() . Your 
America/Regina
follows this pattern. Question 2: Can 
current_time
be overridden by user-set variables? Yes, this is a known issue documented in community discussions. One user reported: "{{current_time}} has many limitations. I don't think it really works unless you happen to be in the 'right' time zone by coincidence, and the LLM is Retell LLM, not a custom one." [(2) ]() The core problem is architectural: "The client sends dynamic variables to the backend. The backend uses these dynamic variables to update the LLM's prompt on the fly." For system variables like 
{{current_time}}
, "the client doesn't need to send it to the backend. However, this raises a critical question: how would the backend know your time zone? Likely, it doesn't—the backend will default to its own time zone." Additionally, the default timezone for 
{{current_time}}
is PST , which may explain why your Regina-specific variable isn't resolving correctly. Recommended Solution: Instead of relying on 
{{current_time_America/Regina}}
, create a custom dynamic variable that you populate at call creation. As documented in the community: "To fix this, you should send the time with time zone information in a human-readable format. Additionally, you'll need to update your prompt accordingly, ensuring that your custom
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
Thanks for the follow-up, @bohmez. I'll get back to you soon.
b
@AI Evy Configurable ring/dial timeout on outbound calls? We're building a sequential escalation dialer with Retell — the agent calls contact 1, and if there's no answer it needs to move on and call contact 2, then 3, etc. For that to work, each unanswered attempt has to terminate quickly and deterministically. Questions: 1. On outbound calls placed via create-phone-call (v2) using a Retell-managed / imported number, can we configure the ring (dial) timeout — e.g. ring for 30 seconds, and if the callee doesn't answer, end the call with dial_no_answer? If so, is it a per-call API parameter, an agent setting, or a dashboard/number config — and what's the parameter name and default value? 2. We understand a rings-out or declined call returns dial_no_answer. What happens when the callee's carrier voicemail picks up before our intended timeout — does the call connect (and bill) and then rely on Voicemail Detection to bail out, or is there a way to treat "answered by a machine within X seconds" as no-answer and drop immediately? 3. For a fast escalation cascade, what's the recommended pattern to keep each unanswered leg as short and predictable as possible?
a
### Answer Here's what's documented: 1. Ring/dial timeout configuration Yes, there's a documented per-agent-configuration field for this: 
ring_duration_ms
, which appears in both the Create Voice Agent [(1) ]() and Create Phone Call agent_override [(2) ]() schemas. It's shown as an example value of 
30000
(30 seconds) in the request/response bodies [(2) ]() [(1) ]() . Since it's part of the agent configuration object, it can be set at the agent level or overridden per-call via 
agent_override.agent.ring_duration_ms
in the Create Phone Call API [(2) ]() . I don't see the default value or the exact behavior description (i.e., what happens precisely at expiration) documented in the available sources beyond the field's presence and example. 2. Voicemail arriving before your timeout The sources don't document a way to treat "answered by machine within X seconds" as equivalent to no-answer/auto-drop before the call connects. What is documented is the 
voicemail_option
object, which detects voicemail after the call connects (within the first 3 minutes) and applies a configured action — either hangup or leaving a static message [(3) ]() [(1) ]() [(2) ]() . This is a post-connection detection mechanism, not a ring-phase cutoff. I don't have documentation confirming whether a machine pickup is billed differently than a no-answer disconnect, or whether 
ring_duration_ms
interacts with voicemail detection timing.
3. Fast escalation cascade pattern The sources don't provide a specific "recommended pattern" for sequential escalation dialing. Based only on what's documented, the available building blocks are: - Setting 
ring_duration_ms
low to shorten the unanswered window [(2) ]() [(1) ]() - Configuring 
voicemail_option
with a hangup action to end quickly if voicemail is detected after connect [(3) ]() [(1) ]() [(2) ]() - Monitoring call status via [Get Call API]() polling or webhooks (call_started, call_ended, call_analyzed, call_failed) to trigger the next call in your sequence [(4) ]() I don't see a documented "escalation dialer" pattern or best-practice guide in these sources — this would need to be assembled from the general Batch calling and monitoring docs . Given the gaps here (default 
ring_duration_ms
value, exact machine-detection-before-connect behavior) , you may want to test empirically or check with support for confirmation.
​ To learn more, see the sources I considered: [[1] Create Voice Agent](https://docs.retellai.com/api-references/create-agent) [[2] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) [[3] Create Draft Agent Version](https://docs.retellai.com/api-references/create-agent-version) [[4] Make outbound calls](https://docs.retellai.com/deploy/outbound-call) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
Thanks for the follow-up, @bohmez. I'll get back to you soon.
b
@AI Evy Building a Sequential Outbound Call Waterfall After a Missed Call — Looking for Architecture Advice I'm building an inbound + outbound voice AI system and need help with the outbound piece. The flow: Client misses a call Inbound agent picks it up, summarizes the call, and sends an SMS — this part is done After the summary goes out, an outbound agent needs to work through a list of workers one by one until someone picks up The waterfall logic: Call Worker A If no answer, call Worker B If no answer, call Worker C The moment any worker picks up, stop the chain, brief them on the call summary, and end What I'm trying to figure out: Where/how to store the worker list (and what's the best approach for a client-managed list they can update themselves) How to handle the call status detection — what's the cleanest way to detect a no-answer and trigger the next call in the sequence Any recommended tools or platforms for orchestrating this kind of sequential outbound waterfall What's the best way to architect this? Open to hearing what stack others have used.
a
### Answer Based on the available sources, here's what's documented for building this waterfall: Worker list storage The sources don't document a specific storage recommendation for a client-managed worker list — this would be an external system on your end (e.g., a database or spreadsheet integration) that your orchestration layer reads from. No Retell AI-specific storage mechanism is documented for this. Detecting no-answer and triggering the next call You can trigger a phone call via the Create Phone Call API by specifying 
from_number
and 
to_number
[(1) ]() :
Copy code
javascript
const phoneCallResponse = await client.call.createPhoneCall({
 from_number: '+14157774444',
 to_number: '+12137774445',
}) ;
console.log(phoneCallResponse.agent_id) ;
For monitoring the outcome, real-time webhooks are the documented approach. The 
call_ended
event triggers when a call completes, transfers, or errors, and includes all call fields except 
call_analysis
[(2) ]() . The 
call_analyzed
event fires when analysis is complete . If a call doesn't connect (e.g., 
dial_failed
, 
dial_no_answer
, 
dial_busy
) , the 
call_started
event will not fire, but 
call_ended
and 
call_analyzed
will still be triggered . You'd inspect the 
disconnection_reason
field in the 
call_ended
payload to detect a no-answer outcome and then trigger the next call in your sequence. Sample payload structure :
Copy code
json
{
 "event": "call_ended",
 "call": {
 "call_type": "phone_call",
 "from_number": "+12137771234",
 "to_number": "+12137771235",
 "direction": "inbound",
 "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
 "agent_id": "oBeDLoLOeuAbiuaMFXRtDOLriTJ5tSxD",
 "call_status": "registered",
 "metadata": {},
 "retell_llm_dynamic_variables": {
 "customer_name": "John Doe"
 },
 "start_timestamp": 1714608475945,
 "end_timestamp": 1714608491736,
 "disconnection_reason": "user_hangup",
 "transcript": "...",
 "transcript_object": [ [Object], [Object], [Object], [Object] ],
 "transcript_with_tool_calls": [ [Object], [Object], [Object], [Object] ],
 "opt_out_sensitive_data_storage": false
 }
}
Retell also recommends using webhooks over polling for production systems, since they provide real-time updates on call status (started, ended, analyzed, failed) without the overhead of continuous API calls [(3) ]() . Alternatively, you can poll the Get Call API for transcript, recording, and call status data . For idempotency in your orchestration logic, use 
event
+ 
call_id
as a unique key for 
call_started
, 
call_ended
, and 
call_analyzed
events since they fire at most once per call [(2) ]() . Briefing the worker with the call summary You can pass the call summary into the next outbound call using 
retell_llm_dynamic_variables
, which injects key-value string pairs into your prompt/tools [(1) ]() :
Copy code
javascript
const registerCallResponse = await retell.call.createPhoneCall({
 from_number: '+14157774444', // replace with the number you purchased
 to_number: '+12137774445', // replace with the number you want to call
 // Optional: per-call agent selection and overrides
 override_agent_id: 'agent_abc123',
 override_agent_version: 0, // or omit to use latest
 agent_override: {
 agent: {
 voice_speed: 1.1,
 enable_backchannel: true,
 },

 // retell_llm or conversation_flow overrides are also supported
 },
 retell_llm_dynamic_variables: { // dynamic variables (optional, string values only)
 name: 'John Doe',
 blood_group: 'B+'
 }, 
 custom_sip_headers: { // replace with custom sip headers you want to send (optional)
 'X-Custom-Header': 'Custom Value'
 }
}) ;
console.log(registerCallResponse) ;
​ To learn more, see the sources I considered: [[1] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) [[2] Retell webhooks overview](https://docs.retellai.com/features/webhook-overview) [[3] Make outbound calls](https://docs.retellai.com/deploy/outbound-call) [[4] GHL + Make + Retell](https://community.retellai.com/t/ghl-make-retell/806) ​
[(3) ]() You'd inject your call summary as one of these variables so the agent can brief whichever worker answers. Orchestration platform The sources don't document a specific recommended orchestration platform for chaining these calls sequentially and reacting to webhook events. One community-sourced report (not official documentation) describes a similar pattern using Make.com as the orchestration layer — Make receives a webhook, aggregates data, and calls the Retell API directly to start calls with injected variables, then receives Retell's output via a second webhook to continue the chain [(4) ]() . Note this community post also flags that variable injection must happen at call creation time, and recommends locking prompts against generating data (like dates) that isn't explicitly provided, to avoid hallucination-type issues . That said, this is a third-party forum report, not verified against official documentation, so treat the exact API endpoint and payload shape shown there with some caution — the officially documented endpoint for creating phone calls is the one shown above [(1) ]() . For CPS (calls-per-second) limits when running these outbound legs, defaults and maximums vary by provider — Twilio defaults to 1 CPS (max 5) , Telnyx defaults to 1 CPS (max 16) , and Custom Telephony defaults to 1 CPS (max 150) [(3) ]() . I don't have documentation confirming a specific "waterfall" or "escalation" feature built into Retell itself — this pattern needs to be built by your own orchestration layer using the webhook/API primitives above.
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
PreviousNext
Powered by