ਇੱਕ AI ਏਜੰਟ ਆਮ ਚੈਟਬੋਟ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ?

Question

Accepted Answer

ਇੱਕ ਆਮ **ਚੈਟਬੋਟ** ਸਿਰਫ਼ ਪਾਠ ਜਵਾਬ ਦਿੰਦਾ ਹੈ — ਤੁਸੀਂ ਪੁੱਛਦੇ ਹੋ, ਇਹ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਤਬਦੀਲੀ ਉੱਥੇ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਇੱਕ **ਏਜੰਟ** ਇੱਕ ਲੂਪ ਚਲਾਉਂਦਾ ਹੈ: ਇਹ **ਟੂਲਸ** ਨੂੰ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ ਕਰਮ ਕਰਨ ਲਈ, ਨਤੀਜਿਆਂ ਨੂੰ ਦੇਖ ਸਕਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਲਕਸ਼ ਵੱਲ ਪਰਿਵਰਤਨ ਕਰ ਸਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇੱਕ ਸਥਿਤੀ ਪੂਰੀ ਨਹੀਂ ਹੋ ਜਾਂਦੀ। ਅੰਤਰ ਕਰਦਾ ਹੈ, ਸਿਰਫ਼ ਬਦਲ ਨਹੀਂ।

## ਏਜੰਟ ਲੂਪ

```text
Goal → [think → call a tool → observe result → think again] → repeat → stop when done
```

ਹਰ ਪੜਾਅ 'ਤੇ ਏਜੰਟ ਇਸ ਗੱਲ ਦੀ ਬੁਨਿਆਦ 'ਤੇ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਅਗਲਾ ਕੀ ਕਰਨਾ ਹੈ ਜੋ ਇਸ ਨੇ ਸਿੱਖਿਆ ਹੈ, ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰਨ ਦੀ ਬਜਾਏ ਬੰਦ ਕਰਦਾ ਹੈ।

## ਠੋਸ ਏਜੰਟ ਕਰਮ

ਏਜੰਟ ਦੇ "ਟੂਲਸ" ਇਸ ਨੂੰ ਦੁਨੀਆ 'ਤੇ ਕੰਮ ਕਰਨ ਦਿੰਦੇ ਹਨ:

- **ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ** — ਇੱਕ ਸਰੋਤ ਫਾਈਲ ਖੋਲ੍ਹਣਾ, ਇਸ ਨੂੰ ਸੋਧਣਾ, ਤਬਦੀਲੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ।
- **ਕਮਾਂਡ ਚਲਾਉਣਾ** — ਇੱਕ ਬਿਲਡ ਚਲਾਉਣਾ, ਟੈਸਟ ਸੁਈਟ ਚਲਾਉਣਾ, ਇੱਕ ਪੈਕੇਜ ਸਥਾਪਤ ਕਰਨਾ।
- **ਖੋਜ ਕਰਨਾ** — ਕੋडবेस grep ਕਰਨਾ, ਇੱਕ ਡੇਟਾਬੇਸ ਨੂੰ ਸਵਾਲ ਪੁੱਛਣਾ, ਕੁਝ ਲੱਭਣਾ।
- **APIs ਨੂੰ ਕਾਲ ਕਰਨਾ** — ਇੱਕ ਬਾਹਰੀ ਸੇਵਾ ਹਿੱਟ ਕਰਨਾ ਅਤੇ ਜਵਾਬ ਦਾ ਉਪਯੋਗ ਕਰਨਾ।

## ਉਦਾਹਰਨ

```text
Goal: "Fix the failing test."
  1. Run the test suite        → observe: test_login fails
  2. Read the failing test     → observe: it expects a 200, got 500
  3. Search for the handler    → observe: missing null check
  4. Edit the handler file     → write the fix
  5. Run the test suite again  → observe: all pass
  → stopping condition met: tests green, done
```

ਇੱਕ ਚੈਟਬੋਟ ਸਿਰਫ਼ ਸੰਭਵ ਮੁਸ਼ਕਲ ਹਲ ਨੂੰ *ਬਿਆਨ* ਕਰ ਸਕਦਾ ਸੀ; ਏਜੰਟ ਅਸਲ ਵਿੱਚ ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ ਅਤੇ ਖੁਦ ਟੈਸਟ ਚਲਾ ਕੇ ਨਤੀਜਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ।

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

ਏਜੰਟ ਲੂਪ ਨੂੰ ਸਮਝਣਾ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਏਜੰਟ ਅਸਲ ਬਹੁ-ਪੜਾਵੀ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹਨ — debugging, refactoring, ਅਨੁਸੰਧਾਨ — ਸਿਰਫ਼ ਇਸ ਨੂੰ ਬਿਆਨ ਕਰਨ ਦੀ ਬਜਾਏ। ਟੂਲ-ਕਾਲ-ਅਵਲੋਕਨ-ਪੁਨਰ ਚੱਕਰ, ਇੱਕ ਸਪਸ਼ਟ ਸਥਿਤੀ ਦੇ ਨਾਲ, ਇਹ ਹੈ ਜੋ ਇੱਕ ਭਾਸ਼ਾ ਮਾਡਲ ਨੂੰ ਇੱਕ ਸੰਭਾਸ਼ੀ ਪਾਠ ਜੇਨਰੇਟਰ ਤੋਂ ਕੁਝ ਜੋ ਅਸਲ ਵਿੱਚ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।