ਜਦੋਂ ਤੁਹਾਡਾ AI Agent production ਵਿੱਚ ਫਸ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?
AI agent ਦੀਆਂ ਸਭ ਤੋਂ ਮਹਿੰਗੀਆਂ ਅਸਫਲਤਾਵਾਂ ਮਾਡਲ ਦੀਆਂ ਅਸਫਲਤਾਵਾਂ ਨਹੀਂ ਹੁੰਦੀਆਂ।
ਇਹ ਚੁੱਪਚਾਪ ਹੋਣ ਵਾਲੀਆਂ (silent) ਅਸਫਲਤਾਵਾਂ ਹਨ।
Agent ਸਹੀ ਲੱਗਦਾ ਹੈ। Workflow ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ। Tokens ਖ਼ਰਚ ਹੁੰਦੇ ਰਹਿੰਦੇ ਹਨ। ਪਰ agent ਕੋਈ ਤਰੱਕੀ ਨਹੀਂ ਕਰਦਾ।
ਮੈਂ ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਵਾਰ-ਵਾਰ ਦੇਖਿਆ ਹੈ:
- ਅਨੰਤ ਲੂਪ (Infinite loops)
- ਰੀਟ੍ਰਾਈ ਸਟੋਰਮ (Retry storms)
- ਚੁੱਪਚਾਪ ਰੁਕਾਵਟਾਂ (Silent stalls)
- ਸਫਲ ਜਵਾਬਾਂ ਦੁਆਰਾ ਛੁਪਾਈਆਂ ਗਈਆਂ ਟੂਲ ਅਸਫਲਤਾਵਾਂ (Tool failures hidden by successful responses)
- ਟੀਚੇ ਤੋਂ ਭਟਕਦੇ ਹੋਏ agents
- Agent ਦੇ ਕੰਮਾਂ ਵਿੱਚ ਕੋਈ ਸਪੱਸ਼ਟਤਾ ਨਾ ਹੋਣਾ
ਇੱਕ ਬਿਹਤਰ prompt ਇਹਨਾਂ ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰੇਗਾ।
ਤੁਹਾਨੂੰ ਇੱਕ runtime supervision layer ਦੀ ਲੋੜ ਹੈ। ਜ਼ਿਆਦਾਤਰ frameworks agents ਨੂੰ ਚਲਾਉਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦੇ ਹਨ। Production ਟੀਮਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਚਾਹੀਦੇ ਹੁੰਦੇ ਹਨ:
- ਇਹ ਕਿਉਂ ਫਸਿਆ ਹੋਇਆ ਹੈ?
- ਕੀ ਇਹ ਤਰੱਕੀ ਕਰ ਰਿਹਾ ਹੈ?
- ਕੀ ਮੈਂ ਇਸਨੂੰ ਰੋਕ (pause) ਸਕਦਾ ਹਾਂ?
- ਕੀ ਮੈਂ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ (resume) ਕਰ ਸਕਦਾ ਹਾਂ?
- ਕੀ ਮੈਂ ਇਸਨੂੰ ਬੰਦ (kill) ਕਰ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ?
ਸਿਰਫ਼ logs ਇਹਨਾਂ ਦੇ ਜਵਾਬ ਨਹੀਂ ਦਿੰਦੇ।
Supervision ਨੂੰ agent logic ਤੋਂ ਵੱਖ ਕਰੋ। Workflow ਦੇ ਅੰਦਰ guardrails ਨਾ ਰੱਖੋ। Execution ਨੂੰ ਦੇਖਣ ਲਈ ਇੱਕ ਸਮਰਪਿਤ runtime layer ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ workflows ਨੂੰ ਸਰਲ ਰੱਖਦਾ ਹੈ।
Runtime ਇਹਨਾਂ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ:
- Loop detection
- Retry management
- Budget limits
- Pause and resume
- Checkpoints
- Stop reasons
- Live telemetry
"failed" ਨੂੰ ਇੱਕ ਸਟੇਟਸ ਵਜੋਂ ਵਰਤਣਾ ਬੰਦ ਕਰੋ। ਖਾਸ ਕਾਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ:
- LOOP_DETECTED
- BUDGET_EXCEEDED
- RETRY_LIMIT_REACHED
- TOOL_FAILURE
- TIMEOUT
- USER_PAUSED
ਇਹ operators ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਸੁਧਾਰ ਕਰਨਾ ਹੈ।
Step counts loop detection ਵਿੱਚ ਅਸਫਲ ਰਹਿੰਦੇ ਹਨ। Agents ਬਿਨਾਂ ਲੂਪ ਕੀਤੇ ਗਏ ਗਲਤ ਟੀਚੇ ਦਾ ਪਿੱਛਾ ਕਰ ਸਕਦੇ ਹਨ। ਉਹ ਉਦੇਸ਼ ਤੋਂ ਦੂਰ ਜਾਣ ਲਈ ਵੀਹ ਕਦਮ ਖ਼ਰਚ ਕਰ ਦਿੰਦੇ ਹਨ।
ਇਸ ਦੀ ਬਜਾਏ ਇਹ ਪੁੱਛੋ: "ਕੀ ਅਸੀਂ ਕੁਝ ਕਦਮ ਪਹਿਲਾਂ ਨਾਲੋਂ ਟੀਚੇ ਦੇ ਨੇੜੇ ਹਾਂ?" ਇਹ ਭਟਕਣ (drift) ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਖ਼ਰਚ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਰੋਕ ਦਿੰਦਾ ਹੈ।
Pause ਅਤੇ kill ਵਿੱਚ ਅੰਤਰ ਕਰੋ:
- Pause ਸਟੇਟ (state) ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ। ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ।
- Kill ਸਭ ਕੁਝ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਜਾਰੀ ਨਹੀਂ ਰੱਖ ਸਕਦੇ।
ਹਰ ਬਾਹਰੀ ਕਾਰਵਾਈ ਜਿਵੇਂ ਕਿ API calls, browser tasks, ਜਾਂ database writes ਤੋਂ ਪਹਿਲਾਂ checkpoints ਬਣਾਓ। ਜੇਕਰ ਕੋਈ ਪ੍ਰਕਿਰਿਆ (process) ਕ੍ਰੈਸ਼ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਿਸਟਮ ਨੂੰ ਪਤਾ ਹੁੰਦਾ ਹੈ ਕਿ ਬਿਲਕੁਲ ਕੀ ਚੱਲ ਰਿਹਾ ਸੀ। ਇਹ ਚੁੱਪਚਾਪ ਹੋਣ ਵਾਲੀਆਂ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਸੁਧਾਰਨਯੋਗ (recoverable) ਬਣਾ ਦਿੰਦਾ ਹੈ।
ਅਸਫਲਤਾਵਾਂ ਦੌਰਾਨ agents ਨੂੰ tokens ਖ਼ਰਚ ਕਰਨ ਤੋਂ ਰੋਕਣ ਲਈ, ਇਹਨਾਂ ਤਿੰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ:
- Exponential backoff
- Retry budgets
- Circuit breakers
Logs ਅਤੀਤ ਦਿਖਾਉਂਦੇ ਹਨ। Operators ਨੂੰ ਵਰਤਮਾਨ ਦੇਖਣ ਦੀ ਲੋੜ ਹੈ। ਮੌਜੂਦਾ ਕਾਰਜ (task), ਕਦਮ (step), ਟੂਲ (tool), ਅਤੇ ਸਟੇਟਸ ਨੂੰ real time ਵਿੱਚ ਟ੍ਰੈਕ ਕਰੋ।
Agents ਬਣਾਉਣਾ ਆਸਾਨ ਹੈ। ਭਰੋਸੇਯੋਗ (reliable) agents ਬਣਾਉਣਾ ਮੁਸ਼ਕਲ ਹੈ। ਭਰੋਸੇਯੋਗਤਾ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਮਾਡਲ ਤੋਂ ਬਾਹਰ ਹੁੰਦੀਆਂ ਹਨ। ਉਹ ਤੁਹਾਡੇ retries, checkpoints, ਅਤੇ supervision ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ।
ਤੁਸੀਂ AI agents ਦੇ ਨਾਲ production ਵਿੱਚ ਸਭ ਤੋਂ ਔਖੀ ਅਸਫਲਤਾ ਕਿਹੜੀ ਦੇਖੀ ਹੈ?
Source: https://dev.to/milancharan/what-happens-when-your-ai-agent-gets-stuck-in-production-3327
Optional learning community: https://t.me/GyaanSetuAi