---
title: "ఏజెంట్ దశలు మరియు హ్యాండ్ఆఫ్‌లు"
description: "ఏజెంట్‌ను దాని స్వంత సూచనలు, టూల్స్ మరియు సేకరించిన విలువలతో దశలుగా విభజించండి మరియు కాల్ మధ్యలో ఏజెంట్‌ల మధ్య కాల్‌లను బదిలీ చేయండి."
---

ఒకే prompt మోడల్‌కు మొత్తం పనిని ఒకేసారి అందిస్తుంది. **దశలు** కాల్‌లోని ఒక దశను ఒకేసారి అందిస్తాయి: ప్రతి దశకు దాని స్వంత సూచనలు, స్వంత టూల్స్, ఐచ్ఛికంగా పదేపదే చెప్పాల్సిన వాక్యం, ముందుకు వెళ్లే ముందు సేకరించాల్సిన విలువలు ఉంటాయి. **హ్యాండ్ఆఫ్‌లు** మీ సంస్థలోని మరో ఏజెంట్‌కు ట్రాన్స్‌క్రిప్ట్ అలాగే ఉంచి కాల్ మధ్యలో బాధ్యత తీసుకునే అవకాశం ఇస్తాయి, కాబట్టి కాలర్ మళ్లీ తమ వివరాలను చెప్పాల్సిన అవసరం ఉండదు.

ప్రతి ఏజెంట్ ఒకే prompt‌గా ప్రారంభమవుతుంది. మీరు దశలు లేదా హ్యాండ్ఆఫ్‌లను జోడించే వరకు దానిలో ఏమీ మారదు.

## దశలా లేదా ఒకే promptా?

| దశలను ఉపయోగించాల్సిన సందర్భం | ఒకే prompt‌ను ఉంచాల్సిన సందర్భం |
| --- | --- |
| కాల్‌లో క్రమంగా జరగాల్సిన దశలు ఉన్నప్పుడు: ముందుగా ధృవీకరించాలి, తర్వాత బుక్ చేయాలి. | సంభాషణ ఓపెన్-ఎండెడ్‌గా ఉన్నప్పుడు: FAQ, రిసెప్షన్, సాధారణ సపోర్ట్. |
| ఏజెంట్ ముందుకు వెళ్లే ముందు ఒక విలువను సేకరించాల్సి ఉన్నప్పుడు. | నిర్ణీత క్రమంలో ఏదీ సేకరించాల్సిన అవసరం లేనప్పుడు. |
| "18 ఏళ్లలోపు కాలర్లను గార్డియన్‌కు పంపాలి" వంటి నియమం ఎప్పుడూ మారకూడనప్పుడు. | ప్రతి బ్రాంచ్‌కు మోడల్ నిర్ణయ సామర్థ్యం సరిపోతున్నప్పుడు. |
| కాల్‌లో నిర్ణీత సమయంలో లుకప్ అమలు కావాల్సి ఉన్నప్పుడు. | కాలర్ అడిగినప్పుడల్లా టూల్స్‌ను కాల్ చేయవచ్చినప్పుడు. |
| కాల్‌లోని ఒక భాగం, స్వంత prompt మరియు వాయిస్ ఉన్న వేరొక ఏజెంట్‌కు సంబంధించినప్పుడు. | ఒకే వ్యక్తిత్వం అన్నింటినీ నిర్వహించినప్పుడు. |

దశలు స్క్రిప్ట్ చేసిన ఫోన్ ట్రీ కాదు. ఒక దశలో మోడల్, ఒకే prompt‌తో చేసినట్లే సంభాషణను నిర్వహిస్తుంది. అది దేనిపై పని చేస్తోంది, ఏ టూల్స్‌ను ఉపయోగించగలదు, బయటకు వెళ్లే ముందు ఏమి కావాలో ఆ దశే నిర్ణయిస్తుంది.

## దశలతో ఉన్న ఏజెంట్ ఎలా రూపొందించబడుతుంది

ఏజెంట్‌కు దశలు ఉన్నప్పుడు, దాని `prompt`లో **భాగస్వామ్య సూచనలు** ఉంటాయి: ప్రతి దశకు వర్తించే వ్యక్తిత్వం మరియు నియమాలు. ప్రతి దశ వాటిపైన తన స్వంత సూచనలను జోడిస్తుంది. ప్రతి టర్న్‌లో మోడల్ భాగస్వామ్య సూచనలు, ప్రస్తుత దశ పేరు మరియు సూచనలు, ఇప్పటివరకు సేకరించిన విలువలను చూస్తుంది.

బిల్డర్‌లో, ఏజెంట్‌ను **ఒకే prompt** నుండి **దశలు**కు మార్చండి. ప్రతి దశకు దాని పేరు, సూచనలు, చెప్పాల్సిన వాక్యం, టూల్స్, సేకరించిన విలువలు మరియు ట్రాన్సిషన్‌లు ఉన్న కార్డ్, హ్యాండ్ఆఫ్‌ల పికర్, దశల రీడ్-ఓన్లీ ఫ్లో గ్రాఫ్ మీకు లభిస్తాయి. తిరిగి ఒకే prompt‌కు మార్చితే భాగస్వామ్య సూచనలు మరియు ప్రతి దశను కలిపిన ఏకీకృత prompt అందించబడుతుంది.

API ద్వారా, `steps` మరియు `handoffs` అనేవి [agent](/api-reference/agents)లోని ఫీల్డ్‌లు. ప్రతి ఏజెంట్ ఫీల్డ్‌లాగే, `PATCH` వాటిని డ్రాఫ్ట్‌లో స్టేజ్ చేస్తుంది; `POST /v1/agents/{agent_id}/deploy` వాటిని లైవ్ చేస్తుంది. `"steps": null` పంపితే ఏజెంట్ తిరిగి ఒకే prompt‌కు మారుతుంది. టెస్ట్ కాల్‌లు మరియు **మాట్లాడండి** డ్రాఫ్ట్‌ను అమలు చేస్తాయి.

<Tip>
  [కోపైలట్](/te/guides/ask-the-copilot) వివరణ ఆధారంగా దశలను రూపొందించగలదు
  ("బుకింగ్‌కు ముందు పుట్టిన తేదీని ధృవీకరించే దశను జోడించండి") మరియు ఇతర
  దశలను తాకకుండా ఒక దశను సవరించగలదు.
</Tip>

### దశ ఫీల్డ్‌లు

| ఫీల్డ్ | అర్థం |
| --- | --- |
| `id` | అవసరం. అక్షరంతో ప్రారంభమయ్యే చిన్న అక్షరాలు, అంకెలు మరియు అండర్‌స్కోర్‌లు, గరిష్ఠంగా 40 అక్షరాలు. ఏజెంట్‌లో ప్రత్యేకంగా ఉండాలి. |
| `name` | అవసరమైన డిస్‌ప్లే పేరు, 1 నుండి 80 అక్షరాలు. |
| `instructions` | అవసరం, గరిష్ఠంగా 20,000 అక్షరాలు. `prompt` లాగా `{{var}}` [కాల్ వేరియబుల్స్](/te/guides/call-variables)కు మద్దతు ఇస్తుంది. |
| `say` | దశలోకి ప్రవేశించినప్పుడు పదేపదే చెప్పాల్సిన ఐచ్ఛిక వాక్యం, గరిష్ఠంగా 1,000 అక్షరాలు. `{{var}}`కు మద్దతు ఇస్తుంది. |
| `tools` | `null` దశకు ఏజెంట్‌కు జోడించిన ప్రతి టూల్‌ను అందిస్తుంది. జాబితా దశను పేర్ల ద్వారా ఆ టూల్స్‌కే పరిమితం చేస్తుంది. `end_call`, `transfer_call` వంటి అంతర్నిర్మిత చర్యలు ప్రతి దశలో ఏజెంట్ సెట్టింగ్‌లను అనుసరిస్తాయి. |
| `collect` | దశ సేకరించే గరిష్ఠంగా 20 విలువలు. ప్రతి దానికి `name`, `type`, `description`, మరియు `required` (డిఫాల్ట్‌గా `true`) ఉంటాయి. |
| `on_enter_tool` | ఐచ్ఛిక టూల్ పేరు; దశలోకి ప్రవేశించినప్పుడు స్వయంచాలకంగా కాల్ చేయబడుతుంది. [Webhook దశలు](#webhook-steps) చూడండి. |
| `transitions` | దశ తర్వాత వెళ్లగల స్థానాల క్రమబద్ధ జాబితా. [ట్రాన్సిషన్‌లు](#transitions) చూడండి. |
| `global_when` | ఐచ్ఛికం. ఏ దశ నుంచైనా దశను చేరుకోగలిగేలా చేస్తుంది. [గ్లోబల్ దశలు](#global-steps) చూడండి. |
| `voice` | ఈ దశకు ఐచ్ఛిక వాయిస్ id. ఏజెంట్ కస్టమ్ వాయిస్ కాన్ఫిగరేషన్‌ను ఉపయోగించినప్పుడు ఇది విస్మరించబడుతుంది. |

గ్రాఫ్ స్వయంగా `{"start_step": "<step id>", "steps": [...]}`. కాల్
`start_step`లో ప్రారంభమవుతుంది.

## మార్పులు

ప్రతి మార్పులో `to`, ఒక దశ ID, మరియు కిందివాటిలో ఖచ్చితంగా ఒకటి ఉంటాయి:

- **`when`**: సాధారణ భాషలో ఉంటుంది, మరియు **మోడల్ నిర్ణయిస్తుంది**. ఏజెంట్‌కు
  అంతర్నిర్మిత `go_to_step` టూల్ లభిస్తుంది; ఇది వెళ్లగల దశలను జాబితా చేస్తుంది,
  ప్రతి `when` దానిని ఎంచుకోవడానికి కారణంగా ఉంటుంది.
- **`condition`**: సేకరించిన విలువలపై నియమం, మరియు **కోడ్ నిర్ణయిస్తుంది**. మోడల్
  దానిని దాటవేయలేదు లేదా మాటలతో తప్పించుకోలేదు.
- **`"always": true`**: తనిఖీ లేకుండా ముందుకు వెళ్లండి. కోడ్ ముందుగా నిర్ణయిస్తుంది:
  దశలోకి ప్రవేశించిన వెంటనే లేదా దానికి అవసరమైన విలువలు సేకరించిన తర్వాత, మోడల్
  `when` ఎంచుకోకముందే, సరిపోలే మొదటి `condition` లేదా `always` మార్పు అమలవుతుంది.
  కాబట్టి `always`ను షరతుల తర్వాత వాటి ప్రత్యామ్నాయంగా ఉంచండి లేదా ఒక దశను నేరుగా
  తదుపరి దశకు అనుసంధానించడానికి దానినే ఉంచండి. `always` ఉన్న దశ ఎప్పుడూ
  `when` ఎంపిక కోసం వేచి ఉండదు.

ఒక `condition` ఇలా ఉంటుంది: `{"value": <collected name or dotted path>, "op": <op>, "target": <literal>}`:

| `op` | విలువ నిజమయ్యే సందర్భం |
| --- | --- |
| `eq`, `ne` | `target`కు సమానం అవుతుంది లేదా సమానం కాదు |
| `lt`, `lte`, `gt`, `gte` | `target` కంటే తక్కువగా, గరిష్ఠంగా, ఎక్కువగా లేదా కనిష్ఠంగా ఉంటుంది |
| `in`, `not_in` | `target` జాబితాలోని విలువల్లో ఒకటి అవుతుంది లేదా కాదు |
| `exists`, `missing` | సేకరించబడింది లేదా సేకరించబడలేదు (`target` లేదు) |

`eq`, `ne`, `in`, `not_in` ఖాళీలను తొలగించిన తర్వాత అక్షర పరిమాణాన్ని పరిగణించకుండా
వచనాన్ని పోలుస్తాయి. సంఖ్యలు సంఖ్యలుగా, తేదీలు `YYYY-MM-DD` స్ట్రింగ్‌లుగా
పోల్చబడతాయి. ఎప్పుడూ సేకరించని విలువ, `missing` మినహా ప్రతి opను తప్పుగా చేస్తుంది.

`when` మరియు `global_when`ను చెప్పాల్సిన మాటలా కాకుండా, ఉదాహరణకు "కాల్ చేసిన వ్యక్తి
అపాయింట్‌మెంట్ బుక్ చేయాలనుకుంటున్నారు" వంటి షరతుగా రాయండి. ఏజెంట్ వాటిని అంతర్గత
రూటింగ్ గమనికలుగా చూస్తుంది; వాటిని ఎప్పుడూ చదవకూడదని లేదా దశలను మారుస్తున్నట్లు
చెప్పకూడదని సూచించబడుతుంది.

మోడల్ `go_to_step`ను కాల్ చేసినప్పుడు:

1. దశలోని ప్రతి `required` విలువ తప్పనిసరిగా ఉండాలి. ఏదైనా లేకపోతే, అది ఏదో
   మోడల్‌కు తెలియజేయబడుతుంది మరియు కాల్ చేసిన వ్యక్తిని అడుగుతుంది.
2. విలువలు నిల్వ చేయబడతాయి.
3. `condition` మరియు `always` మార్పులు క్రమంలో తనిఖీ చేయబడతాయి. మొదటి సరిపోలిక
   అమలవుతుంది.
4. లేకపోతే, మోడల్ ఎంచుకున్న దశకు ఏజెంట్ వెళ్తుంది.
5. ఏదీ సరిపోలకపోతే మరియు మోడల్ ఏ దశను పేర్కొనకపోతే, ఏజెంట్ ఉన్నచోటే ఉంటుంది.

[గ్లోబల్ దశకు](#global-steps) వెళ్లడం మినహాయింపు: కాల్ చేసిన వ్యక్తి విషయం మార్చారు,
కాబట్టి ప్రస్తుత దశకు అవసరమైన విలువలు ఇంకా లేకపోయినా, ఆ దశ షరతులను తనిఖీ చేయకముందే
అక్కడికి వెళ్తుంది.

దశలోకి ప్రవేశించిన ప్రతిసారీ `condition` మరియు `always` మార్పులు కూడా
తనిఖీ చేయబడతాయి, కాబట్టి కోడ్ నిర్ణయించే దశల వరుస ఒకేసారి అమలవుతుంది. ఈ వరుస
కింది సందర్భాల్లో ఆగుతుంది:

- ఈ అమలులో ఇప్పటికే సందర్శించిన దశ వద్ద;
- 8 జంప్‌ల తర్వాత;
- `on_enter_tool` ఉన్న దశ మినహా, ఇంకా సేకరించాల్సిన అవసరమైన విలువలు ఉన్న దశ వద్ద
  (వెబ్‌హుక్ దశ ఎల్లప్పుడూ తన ఫలితం ఆధారంగా రూట్ అవుతుంది).

వరుస ఆగిన దశలోని `say` లైన్ మాత్రమే మాట్లాడబడుతుంది.

మార్పులు లేని దశ **చివరిది**. ఏజెంట్ అక్కడ ముగించి, తన సాధారణ అంతర్నిర్మిత చర్యలతో
కాల్‌ను ముగిస్తుంది లేదా బదిలీ చేస్తుంది.

## విలువల సేకరణ

ఒక దశకు అవసరమైన వాటిని `collect`లో జాబితా చేయండి. మోడల్ `go_to_step`ను కాల్
చేసినప్పుడు విలువలను పంపుతుంది, అవి మిగిలిన కాల్ అంతటా అందుబాటులో ఉంటాయి.

| `type` | కలిగి ఉంటుంది |
| --- | --- |
| `string` | ఏదైనా వచనం |
| `number` | ఒక సంఖ్య |
| `boolean` | `true` లేదా `false` |
| `date` | `YYYY-MM-DD` రూపంలోని తేదీ |

సేకరించిన విలువలు కాల్ కంటెంట్‌లో భాగం. అవి ట్రాన్స్‌క్రిప్ట్ పక్కన కాల్‌లో కనిపిస్తాయి
మరియు అదే నిల్వ, తొలగింపు, గోప్యీకరణ నియమాలను అనుసరిస్తాయి. ఏజెంట్ కాల్ రికార్డింగ్‌ను
ఆఫ్ చేసినప్పుడు, సేకరించిన విలువలు నిల్వ చేయబడవు లేదా వెబ్‌హుక్‌లకు పంపబడవు; దశ
టైమ్‌లైన్ మాత్రం ఉంటుంది. [కాల్‌లో దీన్ని ఎక్కడ చూడాలి](#where-to-see-it-on-a-call) చూడండి.

## చెప్పే పంక్తులు

ఏజెంట్ దశలోకి ప్రవేశించినప్పుడు `say`లో ఉన్నది రాసినట్లుగానే మాట్లాడబడుతుంది. ఆ పంక్తి ఇప్పుడే చెప్పబడిందని తెలుసుకుని, మోడల్ అదే ప్రతిస్పందనలో కొత్త దశను కొనసాగిస్తుంది కాబట్టి దానిని మళ్లీ చెప్పదు. అభివాదాలు, తప్పనిసరి వెల్లడింపులు, స్థిరమైన పదజాలం కోసం `say`ను ఉపయోగించండి; మిగిలిన ప్రతిస్పందనను మోడల్‌కు వదిలేయండి.

సమ్మతి ప్రకటన ఏదైనా ఉన్న తర్వాత, ఏజెంట్ ముందుగా మాట్లాడితే ప్రారంభ దశలోని `say` ఏజెంట్ ప్రారంభ పంక్తి అవుతుంది. కాలర్ ముందుగా మాట్లాడితే, అది వ్యక్తికి ఇచ్చే ఏజెంట్ మొదటి ప్రతిస్పందనను ప్రారంభిస్తుంది; IVR లేదా వాయిస్‌మెయిల్ అభివాదాన్ని కాదు.

`__previous__` లేదా హ్యాండ్-బ్యాక్ ద్వారా కాల్ దశకు తిరిగి వచ్చినప్పుడు, ఆ దశలోని `say` మళ్లీ మాట్లాడబడదు. వినిపించాల్సిన విధంగానే రాయండి: వాయిస్ తప్పుగా చదివే అవకాశం ఉన్న వాటిని పూర్తిగా స్పెల్ చేయండి. చెప్పే పంక్తులు `{{var}}` కాల్ వేరియబుల్స్‌కు మద్దతు ఇస్తాయి, కానీ సేకరించిన విలువలకు కాదు.

## Webhook దశలు

`on_enter_tool`ను ఏజెంట్ టూల్స్‌లో ఒకదానికి సెట్ చేయండి; మోడల్ కోసం వేచి ఉండకుండా, దశలోకి ప్రవేశించిన వెంటనే అది అమలవుతుంది. దాని ఆర్గ్యుమెంట్లు టూల్ పారామీటర్ పేర్లతో సరిపోలే పేర్లు ఉన్న సేకరించిన విలువలు. ఫలితం 4 KBకు కుదించి, `<tool>_result` అనే పేరుతో సేకరించిన విలువగా నిల్వ చేయబడుతుంది. దశలోని `condition` మరియు `always` ట్రాన్సిషన్‌లు వెంటనే తనిఖీ చేయబడతాయి కాబట్టి, లుకప్ తన ఫలితం ఆధారంగా కాల్‌ను స్వయంగా రూట్ చేయగలదు.

నిల్వ చేసిన విలువలో రెండు ఫీల్డ్‌లు ఉంటాయి:

| ఫీల్డ్ | కలిగి ఉండేది |
| --- | --- |
| `status` | మీ ఎండ్‌పాయింట్ తిరిగి ఇచ్చిన HTTP స్టేటస్ కోడ్. |
| `response` | ప్రతిస్పందన బాడీ. |

బాడీ ఫీల్డ్ ఆధారంగా రూట్ చేయడానికి `lookup_account_result.response.<field>`ను, స్టేటస్ కోడ్ ఆధారంగా రూట్ చేయడానికి `lookup_account_result.status`ను ఉపయోగించండి.

లుకప్ గరిష్ఠంగా 8 సెకన్ల వరకు లేదా టూల్ స్వంత టైమ్‌అవుట్ అంతకంటే తక్కువగా ఉంటే అంత వరకు అమలవుతుంది. దీనికి 3 సెకన్ల కంటే ఎక్కువ సమయం పడితే, కాలర్ నిశ్శబ్దంలో ఉండకుండా ఏజెంట్ ఒక చిన్న పంక్తి చెబుతుంది. మీ ఎండ్‌పాయింట్ 400 లేదా అంతకంటే ఎక్కువ స్టేటస్‌ను తిరిగి ఇస్తే లేదా సమయానికి ప్రతిస్పందించకపోతే, ప్రస్తుతం దాన్ని తనిఖీ చేయలేకపోయామని ఏజెంట్ కాలర్‌కు తెలిపి, చేయగలిగిన దానితో కొనసాగుతుంది.

## గ్లోబల్ దశలు

`global_when` ఉన్న దశను, ఆ వివరణ వర్తించినప్పుడల్లా ఏ దశ నుంచైనా చేరుకోవచ్చు. `when` మాదిరిగానే, దీనిని మోడల్ నిర్ణయిస్తుంది. కాలర్ ఎప్పుడైనా ప్రస్తావించగల అంశాల కోసం దీనిని ఉపయోగించండి: బిల్లింగ్ ప్రశ్నలు, మనిషితో మాట్లాడాలనే అభ్యర్థన, ఫిర్యాదు.

గ్లోబల్ దశలో `"to": "__previous__"` ఉన్న ట్రాన్సిషన్, కాల్‌ను అంతకుముందు సక్రియంగా ఉన్న దశకు తిరిగి పంపుతుంది; కాబట్టి కాలర్ వదిలిన చోట నుంచే కొనసాగించగలరు. దశ పునఃప్రారంభమవుతుంది: దాని `on_enter_tool` మళ్లీ అమలవదు, దాని `say` పునరావృతం కాదు, మరియు ఏజెంట్ దానిని మొదటి నుంచి ప్రారంభించకుండా కొనసాగిస్తుంది.

## హ్యాండ్ఆఫ్లు

`handoffs` మీ సంస్థలో కాల్‌ను స్వీకరించగల ఇతర ఏజెంట్లను జాబితా చేస్తుంది:

```json
[{"agent_id": 413, "when": "The caller asks about billing or a refund"}]
```

ఏజెంట్‌కు ఆ ఏజెంట్లు మరియు కారణాలతో అంతర్నిర్మిత `hand_off` టూల్ లభిస్తుంది. ట్రాన్సిషన్‌ల మాదిరిగానే, ప్రతి `when` అంతర్గత రూటింగ్ గమనిక మాత్రమే; దాన్ని ఎప్పుడూ చదివి వినిపించరు.

హ్యాండ్ఆఫ్ చేసినప్పుడు, ఏజెంట్ తన స్వరంలో కాలర్ ఎక్కడికి వెళ్తున్నారో తెలిపే ఒక చిన్న వాక్యం చెబుతుంది, ఉదాహరణకు "సరే, మిమ్మల్ని మా బిల్లింగ్ బృందానికి పంపుతాను". ఆ తర్వాత లక్ష్య ఏజెంట్ యొక్క prompt, స్టెప్స్, టూల్స్ మరియు స్వరం బాధ్యత తీసుకుంటాయి; కాల్ అదే ట్రాన్స్‌క్రిప్ట్‌తో కొనసాగుతుంది. కొత్త ఏజెంట్ క్లుప్తంగా తనను పరిచయం చేసుకుని కాలర్ చివరి అభ్యర్థనకు సమాధానం ఇస్తుంది; బదిలీ గురించి ప్రకటించదు. ఆ సమయం నుంచి లక్ష్య ఏజెంట్ నాలెడ్జ్ బేస్ అందుబాటులో ఉంటుంది.

కాల్ మొదటిసారి ఏజెంట్‌ను చేరుకున్నప్పుడు, అది ఆ ఏజెంట్ యొక్క `start_step`లో ప్రారంభమవుతుంది: స్టెప్ యొక్క `on_enter_tool` నడుస్తుంది మరియు దాని `say` మాట్లాడబడుతుంది. కాల్ ఇప్పటికే సందర్శించిన ఏజెంట్‌కు తిరిగి హ్యాండ్ఆఫ్ అయినప్పుడు, ఆ ఏజెంట్ `on_enter_tool`ను నడపకుండా, తన `say`ను మళ్లీ చెప్పకుండా లేదా తనను మళ్లీ పరిచయం చేసుకోకుండా, అది ఉన్న స్టెప్ నుంచే కొనసాగుతుంది. సేకరించిన విలువలు కాల్‌లోని ప్రతి ఏజెంట్‌తో పంచుకోబడతాయి.

- లక్ష్యం అదే సంస్థలోని ఏజెంట్ అయి ఉండాలి మరియు ఏజెంట్ తనకే హ్యాండ్ఆఫ్ చేయలేదు.
- కాల్ స్థాయిలోని ప్రతిదీ సమాధానం ఇచ్చిన ఏజెంట్‌తోనే ఉంటుంది: ప్రొడక్ట్, భాషలు, ముందుగా ఎవరు మాట్లాడతారు, వాయిస్‌మెయిల్, సమ్మతి ప్రకటన మరియు ఇతర ప్రతి కాల్ సెట్టింగ్.
- లక్ష్య ఏజెంట్లు మరింత ముందుకు, అలాగే వెనుకకు హ్యాండ్ఆఫ్ చేయగలరు. ఒక కాల్ గరిష్ఠంగా 8 ఏజెంట్లను చేరగలదు.
- టెస్ట్ కాల్ మీరు పరీక్షించే ఏజెంట్ డ్రాఫ్ట్‌ను నడుపుతుంది. అది హ్యాండ్ఆఫ్ చేసే ఏజెంట్లు తమ డిప్లాయ్ చేసిన వెర్షన్‌లను నడుపుతారు.
- రెండు ఏజెంట్లకు ఒకే పేరుతో వేర్వేరు నిర్వచనాలున్న టూల్ ఉంటే, కాల్ కోసం ఒకటి మాత్రమే ఉంచబడుతుంది మరియు సమాధానం ఇచ్చిన ఏజెంట్‌దే ఎల్లప్పుడూ గెలుస్తుంది. మీరు సేవ్ చేసినప్పుడు బిల్డర్ మిమ్మల్ని హెచ్చరిస్తుంది.
- ఏజెంట్‌కు స్టెప్స్ లేకుండానే హ్యాండ్ఆఫ్లు ఉండవచ్చు. దాని మొత్తం prompt యథాతథంగా ఉపయోగించబడుతుంది.

`go_to_step` మరియు `hand_off` స్టెప్స్ లేదా హ్యాండ్ఆఫ్లు ఉన్న ఏజెంట్లలో రిజర్వ్ చేయబడ్డాయి, కాబట్టి మీ స్వంత టూల్స్ ఆ పేర్లను ఉపయోగించలేవు.

## కాల్‌లో దీన్ని ఎక్కడ చూడాలి

**కాల్ చరిత్ర**లో కాల్‌ను తెరవండి. ట్రాన్స్‌క్రిప్ట్ పక్కన ఉన్న స్టెప్ టైమ్‌లైన్ కాల్ ప్రవేశించిన ప్రతి స్టెప్‌ను మరియు కారణాన్ని చూపుతుంది; దానితో పాటు సేకరించిన విలువలు జాబితా చేయబడతాయి.

[కాల్ ఆబ్జెక్ట్](/api-reference/calls#retrieve-a-call) మరియు కాల్-పూర్తయిన వెబ్‌హుక్
([`telephony.complete` / `web.complete`](/te/webhooks/call-complete)) ఒకే డేటాను
`steps_trace` మరియు `collected_values`గా కలిగి ఉంటాయి. స్టెప్స్ లేని కాల్‌లలో రెండూ ఉండవు.

```json
"steps_trace": [
  {"t_ms": 0, "agent": "a412", "step": "greet", "via": "start"},
  {"t_ms": 51230, "agent": "a412", "step": "verify", "via": "model"},
  {"t_ms": 98410, "agent": "a412", "step": "minor", "via": "condition"}
],
"collected_values": {"full_name": "Dana Reyes", "dob": "2010-04-02", "age": 15}
```

`agent` అంటే `a` తర్వాత ఏజెంట్ ఐడి. `via` కాల్‌ను ఏది తరలించిందో చెబుతుంది:

| `via` | అర్థం |
| --- | --- |
| `start` | కాల్ ఈ స్టెప్‌లో ప్రారంభమైంది. |
| `model` | మోడల్ `go_to_step`, ఒక `when` లేదా ఒక `global_when` ద్వారా స్టెప్‌ను ఎంచుకుంది. |
| `condition` | ఒక `condition` లేదా `always` ట్రాన్సిషన్ సరిపోయింది. |
| `on_enter` | వెబ్‌హుక్ స్టెప్ ఫలితంపై ఒక ట్రాన్సిషన్ సరిపోయింది. |
| `handoff` | మరొక ఏజెంట్ బాధ్యత తీసుకుంది. |

## స్టెప్స్ ఎక్కడ నడుస్తాయి

ప్రతి ఏజెంట్‌లో (మరియు పాత ఉత్పత్తి విలువల్లో), ఇన్‌బౌండ్, అవుట్‌బౌండ్, క్యాంపెయిన్ కాల్‌లు, పరీక్ష కాల్‌లు, అలాగే వెబ్ మరియు విడ్జెట్ కాల్‌లలో దశలు స్థానికంగా అమలవుతాయి.

మిగతా అన్ని చోట్ల కూడా ఏజెంట్ పనిచేస్తుంది, కానీ నిర్మాణం లేకుండా: షేర్డ్ సూచనలు మరియు ప్రతి స్టెప్‌ను క్రమంగా కలిపిన ఫ్లాటెన్ చేసిన prompt‌ను నడుపుతుంది. ఇందులో ఇవి ఉంటాయి:

- సేవ్ చేసిన ఏజెంట్ కోసం సెషన్‌లతో సహా [Realtime](/te/guides/use-with-openai-realtime) సెషన్‌లు;
- [డైనమిక్ కాల్ కాన్ఫిగ్](/te/guides/dynamic-call-config) వెబ్‌హుక్ తిరిగి ఇచ్చే ఇన్‌లైన్ కాన్ఫిగరేషన్‌లు. `agent_id`ను తిరిగి ఇచ్చే వెబ్‌హుక్ ఆ ఏజెంట్ స్టెప్స్‌ను ఉపయోగిస్తుంది.

## పరిమితులు

| పరిమితి | విలువ |
| --- | --- |
| ప్రతి ఏజెంట్‌కు దశలు | 100 |
| ప్రతి దశకు సేకరించిన విలువలు | 20 |
| ప్రతి ఏజెంట్‌కు హ్యాండ్ఆఫ్ లక్ష్యాలు | 8 |
| ఒక కాల్‌లో చేరుకోగల ఏజెంట్లు | 8 |
| `steps` JSON పరిమాణం | 200 KB |
| దశ `instructions` | 20,000 అక్షరాలు |
| `say` లైన్ | 1,000 అక్షరాలు |
| నిల్వ చేసిన `on_enter_tool` ఫలితం | 4 KB |

నియమాన్ని ఉల్లంఘించే సేవ్, చెడు ఫీల్డ్ మార్గంతో పాటు `400`ని అందిస్తుంది,
ఉదాహరణకు `steps.steps[2].transitions[0].to`. `tools` మరియు
`on_enter_tool`లోని టూల్ పేర్లు ఏజెంట్‌కు జత చేసిన టూల్స్ అయి ఉండాలి.

ప్రతి దశకు భాషలు, మోడల్‌ను దాటవేసే స్క్రిప్టెడ్ దశలు, మరియు say లైన్లలోని
సేకరించిన విలువలకు మద్దతు లేదు.

## దిగుమతి చేసిన ఏజెంట్లు

Retell, Bland, Vapi లేదా ElevenLabs నుండి [దిగుమతి చేయడం](/te/guides/import-agents)
వల్ల బహుళ-prompt ఏజెంట్లు, ఫ్లోలు, పాత్‌వేలు మరియు వర్క్‌ఫ్లోలు దశలుగా, అలాగే
స్క్వాడ్‌లు మరియు ఏజెంట్ బదిలీలు దిగుమతి చేసిన ఏజెంట్ల మధ్య హ్యాండ్ఆఫ్‌లుగా
మారతాయి. మీరు దిగుమతి చేయడానికి ముందు సమీక్ష పేజీ రెండింటినీ చూపుతుంది.

## ఉదాహరణ: దంత చికిత్స వివరాల సేకరణ

క్రమంగా మూడు దశలు: అభివాదం, రోగి వివరాల సేకరణ, బుకింగ్.

```json
{
  "prompt": "You are Ava, the front desk assistant at Acme Dental. Be warm and brief. Ask one question at a time.",
  "steps": {
    "start_step": "greet",
    "steps": [
      {
        "id": "greet",
        "name": "Greeting",
        "instructions": "Greet the caller and ask how you can help.",
        "say": "Thanks for calling Acme Dental, this is Ava. How can I help you today?",
        "tools": null,
        "collect": [],
        "transitions": [
          {"to": "details", "when": "The caller wants to book an appointment"}
        ]
      },
      {
        "id": "details",
        "name": "Patient details",
        "instructions": "Ask for the caller's full name, date of birth and the reason for the visit. Read the date of birth back and ask the caller to confirm it.",
        "tools": null,
        "collect": [
          {"name": "full_name", "type": "string", "description": "Caller's full name", "required": true},
          {"name": "dob", "type": "date", "description": "Date of birth", "required": true},
          {"name": "reason", "type": "string", "description": "Reason for the visit", "required": true},
          {"name": "new_patient", "type": "boolean", "description": "First visit to the practice", "required": false}
        ],
        "transitions": [
          {"to": "book", "when": "The caller has confirmed their details"}
        ]
      },
      {
        "id": "book",
        "name": "Book",
        "instructions": "Offer the two earliest open slots from book_slot and book the one the caller picks. Confirm the date and time, then say goodbye and end the call.",
        "tools": ["book_slot"],
        "collect": [],
        "transitions": []
      }
    ]
  }
}
```

దీన్ని `PATCH /v1/agents/{agent_id}`తో స్టేజ్ చేయండి, **మాట్లాడండి**తో ప్రయత్నించి,
ఆపై డిప్లాయ్ చేయండి. పేరు, పుట్టిన తేదీ మరియు కారణం సేకరించే వరకు `details` దశ
బుకింగ్‌కు బదిలీ చేయలేదు; `new_patient` ఐచ్ఛికం.

## ఉదాహరణ: వయస్సు-పరిమితి ఉన్న శాఖ

మోడల్ ఎవరితోనైనా మాట్లాడగలదు, కానీ ఎవరి కోసం బుకింగ్ చేయాలో కోడ్ నిర్ణయిస్తుంది.
వయస్సును సేకరించి, మోడల్ స్వంత ఎంపికను పరిగణించే ముందు దాని ఆధారంగా రూట్ చేయండి.

```json
{
  "id": "verify",
  "name": "Verify age",
  "instructions": "Ask for the caller's age.",
  "tools": null,
  "collect": [
    {"name": "age", "type": "number", "description": "Caller's age in years", "required": true}
  ],
  "transitions": [
    {"to": "guardian", "condition": {"value": "age", "op": "lt", "target": 18}},
    {"to": "book", "when": "The caller has given their age"}
  ]
}
```

పదిహేను అని చెప్పే కాలర్, మోడల్ ఏది నిర్ణయించినా `guardian`కు వెళ్తారు.
మిగతా అందరూ `book`కు వెళ్తారు. గ్రాఫ్‌లో వేరే చోట రెండూ సాధారణ దశలే.

## ఉదాహరణ: ఖాతా శోధన వెబ్‌హుక్ దశ

కాల్ చేసినవారు ఖాతా నంబర్ ఇస్తారు, తదుపరి దశలోకి ప్రవేశించినప్పుడు శోధన నడుస్తుంది,
దాని ఫలితం మార్గాన్ని ఎంచుకుంటుంది. సంక్షిప్తత కోసం `not_found`, `collections`, మరియు `support`
దశలను చూపలేదు.

```json
[
  {
    "id": "identify",
    "name": "Identify",
    "instructions": "Ask for the caller's account number and read it back digit by digit.",
    "tools": null,
    "collect": [
      {"name": "account_number", "type": "string", "description": "Account number", "required": true}
    ],
    "transitions": [
      {"to": "lookup", "when": "The caller has confirmed their account number"}
    ]
  },
  {
    "id": "lookup",
    "name": "Look up account",
    "instructions": "Tell the caller what you found on their account and ask how you can help.",
    "tools": ["lookup_account"],
    "collect": [],
    "on_enter_tool": "lookup_account",
    "transitions": [
      {"to": "not_found", "condition": {"value": "lookup_account_result.response.found", "op": "eq", "target": false}},
      {"to": "collections", "condition": {"value": "lookup_account_result.response.account_status", "op": "in", "target": ["past_due", "suspended"]}},
      {"to": "support", "when": "The caller needs help with an active account"}
    ]
  }
]
```

దాని పారామీటర్‌కు ఆ పేరు ఉన్నందున `lookup_account`, `account_number`ను స్వీకరిస్తుంది.
ప్రతిస్పందన బాడీలో `"found": false` ఉంటే, కాల్ `not_found`కు వెళ్తుంది.
దాని `account_status` `past_due` లేదా `suspended` అయితే, అది
`collections`కు వెళ్తుంది. సక్రియ ఖాతా `lookup`లోనే ఉంటుంది, అక్కడ మోడల్ సహాయం చేసి
`support`కు కొనసాగుతుంది. విఫలమైన శోధనను ప్రత్యేక దశకు పంపడానికి, ముందుగా
స్థితిపై షరతులను జోడించండి: ఎర్రర్ ప్రతిస్పందన దాని స్థితి కోడ్‌ను నిల్వ చేస్తుంది, కాబట్టి
`{"value": "lookup_account_result.status", "op": "gte", "target": 400}`
దానిని గుర్తిస్తుంది; అలాగే టైమ్‌అవుట్ లేదా సమాధానం లేకపోవడం వల్ల `"error"` నిల్వ అవుతుంది, కాబట్టి
`{"value": "lookup_account_result.status", "op": "eq", "target": "error"}`
దానిని గుర్తిస్తుంది.

## ఉదాహరణ: ఫ్రంట్ డెస్క్ నుండి బిల్లింగ్‌కు

రెండు ఏజెంట్లు. ఫ్రంట్ డెస్క్ (ఏజెంట్ `412`) ప్రతి కాల్‌కు సమాధానం ఇస్తుంది మరియు బిల్లింగ్
ప్రశ్నలను దాని స్వంత prompt, టూల్స్ మరియు వాయిస్ ఉన్న బిల్లింగ్ ఏజెంట్‌కు (ఏజెంట్ `413`) అందజేస్తుంది.

ఫ్రంట్ డెస్క్‌లో:

```json
{
  "handoffs": [
    {"agent_id": 413, "when": "The caller asks about a bill, a payment or a refund"}
  ]
}
```

కాల్ చేసినవారిని తిరిగి అందజేయడానికి వీలుగా బిల్లింగ్ ఏజెంట్‌లో:

```json
{
  "handoffs": [
    {"agent_id": 412, "when": "The billing question is resolved and the caller needs something else"}
  ]
}
```

ఫ్రంట్ డెస్క్ "మిమ్మల్ని మా బిల్లింగ్ బృందానికి కలుపుతాను" వంటి చిన్న వాక్యం చెబుతుంది, మరియు బిల్లింగ్
ఏజెంట్ తనను పరిచయం చేసుకుని ఫ్రంట్ డెస్క్ వదిలిన చోటే సంభాషణను కొనసాగిస్తుంది.
బిల్లింగ్ తిరిగి అందజేసినప్పుడు, ఫ్రంట్ డెస్క్ కాల్ చేసినవారిని మళ్లీ పలకరించకుండా
అది ఉన్న చోటే కొనసాగిస్తుంది. కాల్‌కు సంబంధించిన ఉత్పత్తి,
భాషలు, సమ్మతి ప్రకటన మరియు ఇతర కాల్ సెట్టింగ్‌లు ఫ్రంట్ డెస్క్‌తోనే ఉంటాయి,
ఎందుకంటే అది సమాధానం ఇచ్చింది.

బిల్లింగ్‌కు దాని స్వంత సూచనలు మాత్రమే అవసరమై, దాని స్వంత ఏజెంట్ అవసరం లేకపోతే,
బదులుగా ఫ్రంట్ డెస్క్‌లో గ్లోబల్ దశను ఉపయోగించండి. ప్రశ్నకు సమాధానం ఇచ్చినప్పుడు,
కాల్ చేసినవారు ఉన్న దశకే కాల్ తిరిగి వెళ్తుంది:

```json
{
  "id": "billing",
  "name": "Billing questions",
  "instructions": "Answer questions about bills and payments. Offer to send a payment link by email.",
  "tools": null,
  "collect": [],
  "transitions": [
    {"to": "__previous__", "when": "The billing question is answered"}
  ],
  "global_when": "The caller asks about a bill or payment at any point"
}
```

## తదుపరి దశలు

<CardGroup cols={2}>
  <Card title="Prompting మార్గదర్శిని" icon="pen" href="/te/guides/prompting">
    ఫోన్‌లో సమర్థవంతంగా పనిచేసే భాగస్వామ్య సూచనలు మరియు దశల సూచనలు రాయండి.
  </Card>
  <Card title="టూల్ ఇంటిగ్రేషన్ నిర్మించండి" icon="code" href="/te/guides/build-tool-integration">
    మీ దశలు మరియు webhook దశలు పిలిచే టూల్స్‌ను సృష్టించండి.
  </Card>
  <Card title="మీ ఏజెంట్లను పరీక్షించండి" icon="flask" href="/te/guides/test-agents">
    డిప్లాయ్ చేసే ముందు ప్రతి బ్రాంచ్‌పై ఒకే సన్నివేశాలను అమలు చేయండి.
  </Card>
  <Card title="ఏజెంట్స్ API" icon="robot" href="/api-reference/agents">
    ప్రతి ఏజెంట్ ఫీల్డ్, డ్రాఫ్ట్ మరియు డిప్లాయ్.
  </Card>
</CardGroup>
