### Answer The sources don't describe a built-in mechanism to get real-time logs at each transition showing the agent's current node, reasoning, or function calls during a live conversation flow. However, here's what the documentation does mention for visibility: - **Dashboard testing**: When testing in the dashboard (both audio and text) , you can see which node is highlighted to find the current node, so you can observe how and when transitions happen. [(1) ]() - **Post-call analysis**: Retell AI offers comprehensive monitoring tools including post-call analysis, sentiment tracking, and task completion status to assess agent performance. [(2) ]() For detailed logging of transitions, node states, and function calls during or after calls, you may need to: 1. Use webhooks to capture call events and data pushed to your external systems 2. Review call transcripts and recordings via the dashboard or API I don't have specific documentation on configuring per-transition logging. You might want to reach out to support for more advanced debugging options: Check out these potentially useful sources: - [Conversation Flow Overview]() - [Node Overview]() - [Contact Sales]() Would you like me to try to provide a general answer based on common patterns for this type of logging?

​ To learn more, see the sources I considered: [[1] Step 3: Add transition conditions](https://docs.retellai.com/build/conversation-flow/transition-condition) [[2] Training & Customizing AI Voice Agents | Retell AI](https://www.retellai.com/blog/training-and-customizing-voice-agents-with-retell-ai) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

​ To learn more, see the sources I considered: [[1] Update Call](https://docs.retellai.com/api-references/update-call) ​

### Answer Based on the available sources, there is a way to see the current node during a call via the API. The call object includes a field called

collected_dynamic_variables

which contains

last_node_name

. [(1) ]() For example, in the call response:

json
"collected_dynamic_variables": {
  "last_node_name": "Test node"
}

This means you can use the Get Call or Update Call API endpoints to retrieve the call object and check the

last_node_name

field to see which node the conversation is currently at or was last at. However, the sources don't document a real-time streaming or webhook mechanism that pushes node transition events as they happen. You would need to poll the API to check the current state. Check out these potentially useful sources: - [Update Call]() - [Node Overview]() - [Contact Sales]() Would you like a general answer on common patterns for real-time event streaming in similar systems?

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer The

collected_dynamic_variables

field is described as "Dynamic variables collected from the call" and is available after the call ends. [(1) ]() , [(2) ]() The documentation shows this example structure:

json
"collected_dynamic_variables": {
  "last_node_name": "Test node"
}

[(1) ]() , [(2) ]() Unfortunately, the sources only explicitly document

last_node_name

as an example of what appears in

collected_dynamic_variables

. The documentation doesn't provide a comprehensive list of all possible fields that can be collected. The contents of

collected_dynamic_variables

depend on what dynamic variables you define and collect within your Conversation Flow nodes. Any variables you configure to be collected during the conversation would appear here. For chats, the same field exists with the same behavior—dynamic variables collected from the chat, only available after the chat ends. [(3) ]() , [(4) ]() Check out these potentially useful sources: - [Get Call]() - [Node Overview]() - [Contact Sales]() Would you like a general answer on how dynamic variable collection typically works in conversation flow systems?

​ To learn more, see the sources I considered: [[1] Update Call](https://docs.retellai.com/api-references/update-call) [[2] Get Call](https://docs.retellai.com/api-references/get-call) [[3] Get Chat](https://docs.retellai.com/api-references/get-chat) [[4] List Chat](https://docs.retellai.com/api-references/list-chat) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer Based on the available sources, I cannot definitively answer whether

last_node_name

is automatically populated by default or requires manual configuration. The documentation only shows

last_node_name

as an example value within `collected_dynamic_variables`: [(1) ]() , [(2) ]()

json
"collected_dynamic_variables": {
  "last_node_name": "Test node"
}

[(1) ]() , [(2) ]() The sources describe

collected_dynamic_variables

as "Dynamic variables collected from the call. Only available after the call ends." However, the documentation does not explicitly state: - Whether

last_node_name

is a system-provided default field - Whether you need to configure it manually in your Conversation Flow - How the value gets assigned This detail about whether it's automatic or requires setup isn't covered in the API reference documentation I have access to. Check out these potentially useful sources: - [Node Overview]() - [Conversation Flow Overview]() - [Contact Sales]() Would you like me to try to provide a general answer based on common patterns for dynamic variable collection in conversation systems?

​ To learn more, see the sources I considered: [[1] Update Call](https://docs.retellai.com/api-references/update-call) [[2] Get Call](https://docs.retellai.com/api-references/get-call) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer Yes, you can make functions trigger with certainty at transitions using Function Nodes in Conversation Flow. [(1) ]() A Function Node calls a function (pre-built or custom) **when entering the node**—it's not dependent on the AI deciding to call it. Key behaviors you can control: - **Wait for Result**: When enabled, the agent waits for the function to finish executing before attempting to transition to any other node. This guarantees that when you reach the next node, the result is already ready to be used. - **Speak During Execution**: When enabled, you can configure the agent to say something like "Let me check that for you" while the function executes. **Transition timing depends on your settings**: - If

wait for result

is off and

speak during execution

is **off**: the agent transitions immediately after the function gets invoked (right upon entering the node) - If

wait for result

is **on**: the agent transitions once the function result is ready So the function call itself is deterministic—it fires when the node is entered. The AI doesn't decide whether to call it; that's guaranteed by the flow structure. You control the flow by connecting nodes and setting transition conditions. To tell the user the result, attach a Conversation Node after the Function Node since Function Nodes aren't intended for conversation.

​ To learn more, see the sources I considered: [[1] Function Node Overview](https://docs.retellai.com/build/conversation-flow/function-node) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer Function Nodes are a feature of Conversation Flow agents, not multi-prompt (stateful multi-prompt) agents. [(1) ]() The available sources describe Function Nodes specifically in the context of Conversation Flow, where you visually build nodes and connect them with transitions. For multi-prompt agents (also called stateful multi-prompt agents) , the architecture is different—you define states with their own prompts linked by conditional edges, and functions are handled through tool calling / function calling rather than dedicated Function Nodes. [(2) ]() The changelog mentions that multi-prompt agents use "pre-defined tool calling abilities such as Call Transfer, Ending Calls, and Appointment Booking" and "custom tools for more tailored actions." So the key difference: - **Conversation Flow**: Uses Function Nodes that trigger deterministically when entering a node [(1) ]() - **Multi-prompt agents**: Use tool/function calling where the LLM decides when to invoke functions based on your configuration If you need the deterministic function triggering behavior that Function Nodes provide, Conversation Flow would be the better fit for your use case.

​ To learn more, see the sources I considered: [[1] Function Node Overview](https://docs.retellai.com/build/conversation-flow/function-node) [[2] Platform Changelogs | Retell AI](https://www.retellai.com/changelog) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer Yes, in Conversation Flow you can have both deterministic function calls and AI-decided tool calls. [(1) ]() Deterministic execution happens via **Function Nodes**—the function triggers automatically when entering the node, not based on AI decision. AI-decided tool calls are available through the MCP Node, which lets you integrate with Model Context Protocol tools. The MCP Node allows your voice agents to call HTTP-based services, trigger workflows, and fetch live data—and the agent can dynamically adapt the conversation based on responses. [(2) ]() The available node types in Conversation Flow include: [(1) ]() Action Nodes: - **Function Node**: Execute custom functions and API calls (deterministic on node entry) - **SMS Node**: Send SMS messages during the call - **MCP Node**: Integrate with Model Context Protocol tools The MCP feature specifically enables agents to "Call any HTTP-based service (Zapier, custom APIs, CRMs) " and "Dynamically adapt the conversation based on structured responses." [(2) ]() So you have flexibility: use Function Nodes for guaranteed execution at specific points in your flow, or use MCP Nodes for more dynamic tool integration where the agent can decide how to use the results.

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

​ To learn more, see the sources I considered: [[1] Node Overview](https://docs.retellai.com/build/conversation-flow/node) [[2] Platform Changelogs | Retell AI](https://www.retellai.com/changelog) ​

Thanks for the follow-up, @punk8357. I'll get back to you soon.

​ To learn more, see the sources I considered: [[1] Function Node Overview](https://docs.retellai.com/build/conversation-flow/function-node) [[2] Call Transfer Node](https://docs.retellai.com/build/conversation-flow/call-transfer-node) [[3] Conversation Node](https://docs.retellai.com/build/conversation-flow/conversation-node) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

​ To learn more, see the sources I considered: [[1] Function Node Overview](https://docs.retellai.com/build/conversation-flow/function-node) [[2] Platform Changelogs | Retell AI](https://www.retellai.com/changelog) [[3] Discord message from @jonobeet on 2026-01-11](https://discord.com/channels/1186424376300679209/1294891368505937952/1459795507697291488) ​

### Answer Yes, you can pass data from a Function Node to subsequent nodes using Response Variables. [(1) ]() When configuring a custom function, you can map the function's returned data to dynamic variables. These variables then become available for use in later nodes in your flow. [(2) ]() The changelog describes this capability: "Your agents can now extract and store dynamic variables live and mid-conversation, with reliably and accurately retrieved information." How it works: - Your function returns data (e.g., a JSON object with customer info) - In the function configuration, you map response fields to dynamic variables - Those variables are then accessible in subsequent Conversation Nodes or other nodes via

{{variable_name}}

syntax Important limitation to be aware of: Based on community reports, there's a known limitation where full JSON objects from one function node aren't always reliably reused as arguments in later function calls. The workaround is to persist data in flow/global state or flatten the object, and explicitly bind that variable in the later function's parameter mapping rather than relying on the LLM to pass it. [(3) ]() For telling the user the result, attach a Conversation Node after the Function Node—since Function Nodes aren't intended for having conversations with the user, you'll need that separate node to communicate the data back. [(1) ]()

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer --- Yes, that's correct. Your function returns data, and you map that data to dynamic variables through Response Variables in the function configuration. The agent doesn't need to "extract" anything—the data is directly provided and stored in those variables for use in the next node. [(1) ]() For the Conversation Node that follows, you reference those variables using

{{variable_name}}

syntax, and the agent can use that data when speaking to the user. [(2) ]() The Function Node is designed to execute and pass results forward—it's not intended for having a conversation with the user. That's why you attach a Conversation Node afterward to communicate the data back to the user.

​ To learn more, see the sources I considered: [[1] Custom Function](https://docs.retellai.com/build/conversation-flow/custom-function) [[2] Function Node Overview](https://docs.retellai.com/build/conversation-flow/function-node) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.

### Answer You can delete an existing agent using the Delete Agent API endpoint, then create a new one with the same configuration. [(1) ]() To delete an agent:

javascript
import Retell from 'retell-sdk';
const client = new Retell({
  apiKey: 'YOUR_RETELL_API_KEY',
}) ;
await client.agent.delete('oBeDLoLOeuAbiuaMFXRtDOLriTJ5tSxD') ;

The endpoint is: - DELETE

/delete-agent/{agent_id}

Required parameters: - agent_id (string, required) : Unique id of the agent to be deleted. Deletes all versions of the agent. Authorization: Include your API key in the header as

"Bearer YOUR_API_KEY"

A successful deletion returns a 204 No Content response. After deleting, you can call the Create Agent endpoint to make a new agent. Note that the Create Agent API will generate a new `agent_id`—there isn't a direct "overwrite" or "update in place" option via Create Agent. If you need to preserve the same

agent_id

, you'd want to use the Update Agent endpoint instead. Check out these potentially useful sources: - [Delete Agent]() - [Update Agent]()

​ To learn more, see the sources I considered: [[1] Delete Agent](https://docs.retellai.com/api-references/delete-agent) ​

Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.