Τι είναι ένας AI agent: πέντε κλασικοί τύποι, δύο αντίπαλοι ορισμοί

Το παλαιότερο παράδειγμα στον χώρο είναι μια ηλεκτρική σκούπα σε έναν κόσμο δύο τετραγώνων, A και B, καθένα είτε καθαρό είτε βρόμικο.¹ Επιβιώνει σε κάθε εγχειρίδιο επειδή είναι ο μικρότερος κόσμος στον οποίο ένας agent μπορεί να έχει δίκιο ή άδικο.

Το percept είναι ένα ζεύγος — πού βρίσκομαι και αν εδώ είναι βρόμικα — και οι ενέργειες είναι SUCK, LEFT και RIGHT. Ολόκληρο το πρόγραμμα είναι μία γραμμή.

type Percept = { dirty: boolean; where?: "A" | "B" };
type Action = "SUCK" | "LEFT" | "RIGHT";

const textbook = (p: Percept): Action =>
  p.dirty ? "SUCK" : p.where === "A" ? "RIGHT" : "LEFT";   

Τρέξτε το απέναντι σε κάθε αρχική διαμόρφωση του κόσμου των δύο τετραγώνων:

A dirty, B dirty, start A    -> steps=3 clean=true
A clean, B dirty, start A    -> steps=2 clean=true
A dirty, B clean, start B    -> steps=2 clean=true

Αυτός είναι ένας simple reflex agent: ενεργεί μόνο με βάση το τρέχον percept, χωρίς μνήμη για οτιδήποτε πριν από αυτό. Δεν είναι κατηγορία-παιχνίδι — ένας θερμοστάτης είναι τέτοιος, όπως και μία μεμονωμένη κλήση σε language model χωρίς συζήτηση προσαρτημένη.

Τώρα σπάστε το όπως το κάνει η πραγματικότητα. Ένα πραγματικό ρομπότ-σκούπα έχει αισθητήρα βρομιάς και προφυλακτήρα, όχι ένα τετράγωνο με ετικέτα A κάτω από το χαλί. Βγάλτε την τοποθεσία από το percept και μην αλλάξετε τίποτα άλλο:

const dirtOnly = (p: Percept): Action => (p.dirty ? "SUCK" : "RIGHT");

A dirty, B dirty, start A    -> steps=3   clean=true   still dirty=0
      t=0 at=A percept={dirty:true}  -> SUCK
      t=1 at=A percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:true}  -> SUCK

A dirty, B clean, start B    -> steps=500 clean=false  still dirty=1
      t=0 at=B percept={dirty:false} -> RIGHT
      t=1 at=B percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:false} -> RIGHT
      t=3 at=B percept={dirty:false} -> RIGHT

Το ίδιο πρόγραμμα, δύο τετράγωνα. Από μία αρχική κατάσταση τελειώνει σε τρία βήματα· από μια άλλη πέφτει στον δεξιό τοίχο πεντακόσιες φορές και θα συνέχιζε μέχρι να πεθάνει η μπαταρία. Δεν μπορεί να αντιληφθεί τη διαφορά ανάμεσα στις δύο καταστάσεις, άρα δεν μπορεί να ενεργήσει διαφορετικά σε αυτές. Οι Russell και Norvig διατυπώνουν το γενικό αποτέλεσμα σε μία γραμμή: τα άπειρα loops είναι συχνά αναπόφευκτα για simple reflex agents σε μερικώς παρατηρήσιμα περιβάλλοντα.¹

Υπάρχει μια διόρθωση που κοστίζει μία γραμμή και καθόλου μνήμη, άξια μέτρησης πριν καταφύγουμε σε κάτι πιο έξυπνο.

let seed = 12345;
const rnd = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);

const coin = (p: Percept): Action => (p.dirty ? "SUCK" : rnd() < 0.5 ? "LEFT" : "RIGHT");  

Δύο χιλιάδες εκτελέσεις ενός εξ ολοκλήρου βρόμικου διαδρόμου σε τρία μεγέθη, με έναν seeded generator παντού:

Η τυχαιοποίηση αφαιρεί εντελώς το loop. Κοστίζει όμως: οκτώ δωμάτια χρειάζονται δεκαπέντε κινήσεις αν ξέρετε τι κάνετε, και αυτός ο agent έχει μέσο όρο 68,7 και μία φορά χρειάστηκε 306. Αυτό είναι ολόκληρο το κεφάλαιο σε μικρογραφία. Κάθε δυνατότητα που προσθέτουμε αγοράζει ορθότητα σε μια περίπτωση που ο προηγούμενος agent δεν μπορούσε να χειριστεί, και τη χρεώνει σε ένα νόμισμα που πρέπει πρώτα να ονομάσετε.

Ένας agent αντιλαμβάνεται το περιβάλλον του μέσω αισθητήρων και ενεργεί μέσω ενεργοποιητών. Το agent program είναι η συνάρτηση από percepts σε ενέργειες — κάθε listing παραπάνω είναι ένα. Η ακολουθία percepts είναι όλα όσα έχουν γίνει αντιληπτά μέχρι τώρα, και ένας simple reflex agent αγνοεί όλα εκτός από το τελευταίο στοιχείο.

Η ορθολογικότητα είναι η λέξη που τα περισσότερα άρθρα παρεξηγούν, και αν την καταλάβετε σωστά, το υπόλοιπο αυτού του κεφαλαίου γίνεται χρήσιμο. Ένας agent δεν είναι ορθολογικός ή ανορθολογικός από μόνος του. Οι Russell και Norvig ορίζουν έναν ορθολογικό agent ως εκείνον που, για κάθε δυνατή ακολουθία percepts, επιλέγει την ενέργεια που αναμένεται να μεγιστοποιήσει το μέτρο απόδοσής του, δεδομένων των στοιχείων αυτής της ακολουθίας και όποιας ενσωματωμένης γνώσης έχει.¹ Το μέτρο απόδοσης δεν βρίσκεται μέσα στον agent: ανήκει στον σχεδιαστή, και η ορθολογικότητα ορίζεται μόνο σε σχέση με αυτό.

Η προδιαγραφή γράφεται συμβατικά ως τέσσερα πράγματα, PEAS: μέτρο απόδοσης, περιβάλλον, ενεργοποιητές, αισθητήρες.

Παρατηρήστε ποια σειρά είναι η παράταιρη. Σχεδόν κάθε ομάδα που φτιάχνει agents το 2026 γράφει τα E, A και S — τα schemas των εργαλείων, τις ενσωματώσεις, τη μορφή μηνυμάτων — επειδή ο κώδικας δεν θα τρέξει χωρίς αυτά. Σχεδόν κανείς δεν γράφει το P. Χωρίς αυτό, το «ο agent μας τα πάει καλά» δεν έχει νόημα που να μπορεί να ελέγξει κανείς, και το «ορθολογικός» δεν μπορεί να εφαρμοστεί καθόλου στο σύστημα, μόνο σε μια επίδειξη. Το Κεφάλαιο 29 αφορά τη μετατροπή του P σε αριθμό, και γι’ αυτό υπάρχει.

    ┌───────────────────────── the environment ─────────────────────────┐
    │                                                                   │
    │   ┌──────────────────────── the agent ─────────────────────┐      │
    │   │                                                        │      │
 ───┼──►│  sensors  ──►  the agent program  ──►  actuators  ─────┼──────┼──►
percept │                                                        │    action
    │   └────────────────────────────────────────────────────────┘      │
    └───────────────────────────────────────────────────────────────────┘
                                   ▲
              the performance measure lives out here, in the head of
              whoever built the thing, and the agent cannot change it

Τα περιβάλλοντα εργασιών ταξινομούνται επιπλέον σε επτά άξονες, πέντε από τους οποίους αποφασίζουν το μεγαλύτερο μέρος της δυσκολίας εδώ: πλήρως ή μερικώς παρατηρήσιμα, ντετερμινιστικά ή όχι, επεισοδιακά ή ακολουθιακά, στατικά ή δυναμικά, γνωστά ή άγνωστα.¹ Ένας agent που μιλά με πραγματικά εργαλεία πάνω από πραγματικό δίκτυο βρίσκεται στη δύσκολη γωνία και των πέντε — μη ντετερμινιστικός ακόμη και σε temperature μηδέν (Κεφάλαιο 17) και, το υποτιμημένο, άγνωστος, επειδή δεν έχετε αξιόπιστο μοντέλο για το τι κάνουν τα ίδια σας τα εργαλεία στον κόσμο. Γι’ αυτό το loop του Κεφαλαίου 23 χρειάζεται error handling περισσότερο από planning.

Τα πραγματικά πατώματα δεν είναι μονοδιάστατα, οπότε προάγετε τον κόσμο σε κάτοψη. Οι διέσεις είναι τοίχοι, οι αστερίσκοι είναι βρομιά και το ρομπότ ξεκινά στον μεσαίο θάλαμο:

        col  0 1 2 3 4 5 6
      row 0  * . . # . . *
      row 1  . # . # . # .
      row 2  . # . S . # .        S = the robot starts here
      row 3  . # . # . # .
      row 4  * . . # . . *

Η προφανής αναβάθμιση είναι η μνήμη. Ο agent κρατά έναν χάρτη: κάθε τετράγωνο στο οποίο έχει σταθεί και κάθε τετράγωνο όπου ενεργοποιήθηκε ο προφυλακτήρας. Ο κανόνας του είναι να μπαίνει σε ένα γειτονικό τετράγωνο που δεν έχει επισκεφθεί — δεξιά, μετά κάτω, μετά αριστερά, μετά πάνω — και να κάνει πίσω όταν τα πάντα γύρω του είναι γνωστά. Αυτός είναι ένας model-based reflex agent: διατηρεί εσωτερική κατάσταση από το ιστορικό των percepts, ώστε να μπορεί να ενεργεί με βάση όσα δεν μπορεί να δει αυτή τη στιγμή.

Είναι πραγματική βελτίωση, και πάλι δεν αρκεί:

5,000 steps allowed -> steps=5,000  distinct squares visited=13/25  still dirty=2/4

Πέντε χιλιάδες κινήσεις, το μισό πάτωμα δεν το είδε ποτέ. Ο χάρτης είναι σωστός και οι κανόνες είναι σωστοί. Αυτό που δεν μπορεί να κάνει ο agent είναι να χρησιμοποιήσει τον χάρτη για να πάει κάπου: οι κανόνες του απαντούν μόνο στο «σε ποιον από τους τέσσερις γείτονές μου πρέπει να πατήσω», οπότε όταν ξεμείνει από μη επισκεμμένα τετράγωνα δίπλα του, δεν έχει τρόπο να εκφράσει τη σκέψη υπάρχει ένα μη επισκεμμένο τετράγωνο οκτώ κινήσεις μακριά και θα ήθελα να στέκομαι πάνω του. Ξέρει πού βρίσκεται. Δεν ξέρει πού θέλει να είναι.

Ένας goal-based agent κρατά, πάνω από το μοντέλο του για τον κόσμο, μια περιγραφή της κατάστασης που θέλει να προκαλέσει, και επιλέγει ενέργειες αναζητώντας σε ακολουθίες τους μέχρι να βρει μία που τελειώνει εκεί. Οι στόχοι μετατρέπουν την επιλογή ενέργειας από αναζήτηση σε πίνακα σε αναζήτηση σε χώρο λύσεων.

Ο στόχος είναι «να μην απομείνει κανένα βρόμικο τετράγωνο». Η αναζήτηση είναι ένα breadth-first περπάτημα μέχρι το κοντινότερο βρόμικο τετράγωνο, και η διαδρομή που επιστρέφει είναι το σχέδιο.

goal-based (fewest moves)      -> moves=27  battery=52  still dirty=0
      from 2,3 -> 4,6 via 5 moves:  2,3 2,4 3,4 4,4 4,5 4,6
      from 4,6 -> 0,6 via 4 moves:  4,6 3,6 2,6 1,6 0,6
      from 0,6 -> 4,0 via 10 moves: 0,6 0,5 0,4 1,4 2,4 2,3 2,2 3,2 4,2 4,1 4,0
      from 4,0 -> 0,0 via 4 moves:  4,0 3,0 2,0 1,0 0,0

Είκοσι επτά κινήσεις, πάτωμα καθαρό. Αλλά κοιτάξτε τη στήλη μπαταρίας και το τελευταίο σκέλος του σχεδίου. Η στήλη 0 έχει χαλί: η διάσχιση ενός τετραγώνου με χαλί κοστίζει έξι μονάδες μπαταρίας, ενός πλακιδίου μία. Ο agent γύρισε σπίτι ανεβαίνοντας τη στήλη 0 επειδή αυτό είναι τέσσερις κινήσεις αντί για οκτώ, και αυτές οι τέσσερις κινήσεις σε χαλί κόστισαν 24, ενώ η παράκαμψη των οκτώ κινήσεων θα είχε κοστίσει 13.

Δεν μπορεί να κάνει αλλιώς. Ένας στόχος είναι δυαδικός έλεγχος: το πάτωμα είναι καθαρό ή δεν είναι. Κάθε σχέδιο που τελειώνει με καθαρό πάτωμα τον ικανοποιεί εξίσου, οπότε όταν πετυχαίνουν πολλά, ο agent δεν έχει τίποτα για να διαλέξει ανάμεσά τους. Για να προτιμήσει μία επιτυχία από μια άλλη χρειάζεται έναν αριθμό πάνω στα outcomes, και αυτός ο αριθμός είναι μια συνάρτηση utility. Ένας agent που τη μεγιστοποιεί είναι ένας utility-based agent.

Η αλλαγή στον κώδικα είναι ένας όρος μέσα στην αναζήτηση. Το breadth-first search μετρά κινήσεις· κάντε το να μετρά κόστος και έχετε τον αλγόριθμο του Dijkstra και έναν διαφορετικό agent:

const nd = dist.get(k)! + (byCost ? cell.cost : 1);   // <- the entire difference

goal-based    (fewest moves)   -> moves=27  battery=52  still dirty=0
utility-based (cheapest route) -> moves=31  battery=41  still dirty=0
      from 4,0 -> 0,0 via 8 moves: 4,0 4,1 4,2 3,2 2,2 1,2 0,2 0,1 0,0

Τέσσερις επιπλέον κινήσεις, έντεκα λιγότερες μονάδες μπαταρίας: είκοσι ένα τοις εκατό φθηνότερα. Ίδιος στόχος, ίδιος χάρτης, ίδιος κώδικας εκτός από έναν όρο. Οι δύο agents διαφέρουν μόνο στο σε τι προσπαθούν να είναι καλοί, και παίρνουν διαφορετικές διαδρομές για το σπίτι.

Αυτό είναι επίσης το πρώτο σημείο όπου ο agent χρειάζεται κάτι που δεν μπορεί να παράγει. Κάποιος πρέπει να αποφασίσει πόσο αξίζει μια μονάδα μπαταρίας σε σχέση με μια κίνηση. Η utility είναι το μέτρο απόδοσης γραμμένο σε μορφή με την οποία ο agent μπορεί να υπολογίσει, και το να τη γράψει είναι δουλειά του σχεδιαστή. Όταν οι άνθρωποι λένε ότι ένας agent «βελτιστοποίησε το λάθος πράγμα», σχεδόν ποτέ δεν εννοούν bug. Εννοούν ότι αυτή η γραμμή γράφτηκε απρόσεκτα.

Τώρα αφήστε τη βρομιά να επιστρέψει. Τέσσερα δωμάτια ξαναβρομίζουν με τέσσερις διαφορετικούς ρυθμούς, και ο agent δεν τους μαθαίνει ποτέ ρητά. Επισκέπτεται ένα δωμάτιο ανά tick και βλέπει μόνο αυτό το δωμάτιο. Το μέτρο απόδοσης είναι room-ticks που πέρασαν βρόμικα σε 4.000 ticks — όσο χαμηλότερα, τόσο καλύτερα.

Ένας learning agent, στη διάσπαση του εγχειριδίου, είναι οποιοδήποτε από τα παραπάνω συν τρία μέρη: ένα learning element που αλλάζει τον agent, ένας critic που του λέει πώς τα πάει ο agent απέναντι σε ένα σταθερό πρότυπο απόδοσης, και ένας problem generator που προτείνει ενέργειες άξιες δοκιμής για όσα θα δίδασκαν.¹ Τρεις πολιτικές στο ίδιο περιβάλλον. Η πρώτη δεν μαθαίνει· η δεύτερη και η τρίτη μαθαίνουν το ίδιο πράγμα και το χρησιμοποιούν διαφορετικά.

Οι κρυφοί ρυθμοί ήταν 0,35 για την κουζίνα, 0,05 για το χολ, 0,02 για το γραφείο και 0,01 για τη σοφίτα — και ο learner A τους βρήκε. Ταυτοποίησε σωστά την κουζίνα ως το πιο βρόμικο δωμάτιο του σπιτιού, μετά πήγαινε στην κουζίνα σε κάθε tick για το υπόλοιπο της προσομοίωσης ενώ τα άλλα τρία έμεναν βρόμικα για πάντα. Είναι πέντε φορές χειρότερος από το να μη μάθει καθόλου, και δεν είναι χαλασμένος.

Το μάθημα είναι αυτό της ενότητας για την utility. Ο learner A μεγιστοποίησε «την πιθανότητα το δωμάτιο που πρόκειται να επισκεφθώ να είναι βρόμικο». Το μέτρο απόδοσης ήταν «room-ticks που πέρασαν βρόμικα». Διαφορετικοί αριθμοί· ο δεύτερος είναι αυτό που βαθμολογούσε ο critic, και κανείς δεν το είπε στον agent. Ο learner B πολλαπλασιάζει τον ίδιο μαθημένο ρυθμό με τον χρόνο από την τελευταία επίσκεψη — τη βρομιά που περιμένει να βρει αντί για την πιθανότητα να βρει οποιαδήποτε — και κερδίζει την περιπολία από την οποία ξεκίνησε.

Μία λεπτομέρεια υλοποίησης αποφάσισε το αποτέλεσμα. Στην πρώτη έκδοση του learner B, ένα δωμάτιο όπου δεν είχε εμφανιστεί βρομιά σε τρεις επισκέψεις έπαιρνε ρυθμό ακριβώς μηδέν — και το μηδέν επί οτιδήποτε είναι μηδέν, άρα δεν το επισκεπτόταν ποτέ ξανά και η εκτίμηση δεν μπορούσε ποτέ να διορθωθεί. Η εξομάλυνση του κλάσματος, επιτυχίες συν ένα προς δοκιμές συν δύο, μετέτρεψε το 11.895 σε 1.576. Το «δεν παρατηρήθηκε ακόμη» και το «μετρήθηκε και βγήκε μηδέν» είναι διαφορετικοί ισχυρισμοί, και ένα σύστημα που τους αποθηκεύει στο ίδιο πεδίο παίρνει αποφάσεις που δεν μπορεί να αναιρέσει.

  1  simple reflex    percept ────────────────────────────────► rules ────► action
  2  model-based      percept ──► [state] ──────────────────► rules ────► action
  3  goal-based       percept ──► [state] ──► [goal] ──────► search ───► action
  4  utility-based    percept ──► [state] ──► [goal] ──► [U] ──► argmax ► action
  5  learning         all of the above, plus [critic] ──► changes the parts above

Και οι πέντε βρίσκονται σήμερα στην παραγωγή με άλλο όνομα.

Δύο σειρές είναι πιο κοντά από μια αναλογία, με τρόπο που κοστίζει χρήματα.

Το chat είναι ένας model-based reflex agent του οποίου το μοντέλο δεν είναι εσωτερικό. Στο εγχειρίδιο η κατάσταση είναι μια μεταβλητή μέσα στο agent program. Σε ένα chat είναι το transcript: ζει στη δική σας πλευρά, ξαναστέλνεται ολόκληρο σε κάθε κλήση και ξαναχτίζεται από το μηδέν μέσα στο μοντέλο κάθε φορά. Αυτός είναι ο τετραγωνικός λογαριασμός του Κεφαλαίου 16, και είναι το ίδιο αντικείμενο που το εγχειρίδιο σχεδίασε ως κουτί με ετικέτα «state». Εδώ είναι η διαφορά, μετρημένη σε μία follow-up ερώτηση με και χωρίς τα δύο μηνύματα πριν από αυτή:

with the transcript      prompt=67  "The current temperature in Lisbon, Portugal is 15°C."
without the transcript   prompt=29  "Lisbon is the capital of Portugal, not a city in Portugal."

Το ίδιο μοντέλο, οι ίδιες τρεις λέξεις user input, και το δεύτερο είναι το ρομπότ διαδρόμου που πέφτει στον τοίχο. Δεν υπήρχαν εργαλεία σε εκείνη την εκτέλεση, άρα το 15 είναι επινοημένο — αλλά η κατάσταση είναι αυτό που κάνει το follow-up να σημαίνει οτιδήποτε. Την ξαναχτίζετε κάθε φορά και πληρώνετε 2,3× τα input tokens γι’ αυτή σε μια συζήτηση δύο γύρων. Το Κεφάλαιο 16 μέτρησε πού φτάνει αυτός ο πολλαπλασιαστής στον τεσσαρακοστό γύρο.

Το Reflexion είναι ένας learning agent που αλλάζει το input του αντί για το πρόγραμμά του. Στη διάσπαση του εγχειριδίου το learning element τροποποιεί το performance element. Το Reflexion αφήνει τα weights ήσυχα και γράφει αναστοχαστικό κείμενο σε ένα episodic buffer που διαβάζει η επόμενη προσπάθεια.³ Το learning element είναι ένα prompt, η μνήμη μια γραμμή βάσης δεδομένων, το performance element ένα παγωμένο μοντέλο — και το διάγραμμα είναι του εγχειριδίου, αμετάβλητο.

Και εδώ είναι το ειλικρινές όριο της αντιστοίχισης. Οι πέντε τύποι ταξινομούν το agent program. Το 2026 αυτό το πρόγραμμα είναι κομμένο στη μέση: ένα μέρος του είναι ο κώδικάς σας, ένα μέρος του βρίσκεται μέσα σε weights που δεν εκπαιδεύσατε. Όταν ένα μοντέλο αποφασίζει μόνο του να καλέσει ένα εργαλείο, ο έλεγχος στόχου βρίσκεται στο πρόγραμμά σας ή στο μοντέλο; Η ταξινομία δεν έχει απάντηση, επειδή όταν γράφτηκε δεν υπήρχε πουθενά αλλού για να βρίσκεται — και αυτή η ερώτηση είναι ακριβώς το σημείο όπου οι δύο σύγχρονοι ορισμοί χωρίζουν.

Οι ορισμοί είναι επιχειρήματα για συμπεριφορά, και είναι πολύ πιο εύκολο να κριθούν με ένα trace μπροστά σας.

Το παρακάτω loop στέλνει τη συζήτηση σε ένα μοντέλο· αν η απάντηση περιέχει κλήση εργαλείου, εκτελεί το εργαλείο, προσαρτά το αποτέλεσμα και ξαναστέλνει όλο το πράγμα. Τρέχει απέναντι σε ένα τοπικό Qwen2.5-0.5B-Instruct πίσω από endpoint σε σχήμα OpenAI σε αυτό το μηχάνημα — η ραφή από το Κεφάλαιο 14, οπότε το loop ούτε ξέρει ούτε νοιάζεται τι βρίσκεται πίσω από τη θύρα.

const BASE = process.env.LLM_BASE_URL ?? "http://127.0.0.1:8799/v1";

async function loop(question: string, maxTurns = 6) {
  const messages: Msg[] = [
    { role: "system", content: SYSTEM },
    { role: "user", content: question },
  ];

  for (let turn = 1; turn <= maxTurns; turn++) {
    const reply = await call(messages, TOOLS);
    const calls = reply.choices[0].message.tool_calls ?? [];
    messages.push(reply.choices[0].message);

    if (!calls.length) return messages;                      

    for (const c of calls) {
      const out = runTool(c.function.name, JSON.parse(c.function.arguments));
      messages.push({ role: "tool", name: c.function.name, content: out });
    }
  }
  throw new Error("turn cap reached");                       
}

Δύο γραμμές κουβαλούν όλη την ιδέα, και οι δύο είναι σημειωμένες· τα υπόλοιπα είναι λογιστική. Και οι τρεις συμπεριφορές φαίνονται σε μία εκτέλεση. Όταν του ζητείται κάτι που μπορεί να κάνει μόνο του, το μοντέλο απαντά. Όταν του ζητείται κάτι που δεν μπορεί, καλεί:

=== a question the model cannot answer, one tool available
  turn 1  prompt= 187  out= 21  finish=tool_calls  CALL get_temperature({"city": "Oslo"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
  turn 2  prompt= 238  out= 12  finish=stop        TEXT "The current temperature in Oslo is 4
                                                        degrees Celsius."
  => model calls=2  prompt tokens=425  output=33  wall=6,257 ms
  => stopped by: the model produced text instead of a call

Και σταματά — η τρίτη συμπεριφορά, και η πιο εύκολη να χάσετε, επειδή μοιάζει σαν να μη συμβαίνει τίποτα. Το loop τελειώνει επειδή ο γύρος 2 επέστρεψε χωρίς κλήση εργαλείου. Κανείς δεν το αποφάσισε αυτό· το μοντέλο το έκανε, εκπέμποντας πεζό λόγο. Η συνθήκη τερματισμού αυτού του προγράμματος είναι το σημάδι μιας απουσίας.

Δύο ακόμη εκτελέσεις αξίζουν τον χώρο. Όταν του ζητείται να συγκρίνει δύο πόλεις, το μοντέλο εκδίδει και τις δύο κλήσεις εργαλείων σε έναν γύρο, παίρνει πίσω και τις δύο μετρήσεις και κάνει λάθος τη σύγκριση:

  turn 1  prompt= 188  out= 43  finish=tool_calls  CALL get_temperature({"city": "Oslo"}),
                                                        get_temperature({"city": "Lisbon"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
          tool  get_temperature -> {"city":"Lisbon","celsius":19}
  turn 2  prompt= 284  out= 13  finish=stop        TEXT "Oslo is currently warmer than Lisbon
                                                        at 4°C."

Τα εργαλεία λειτούργησαν. Η παράλληλη κλήση λειτούργησε. Το loop λειτούργησε. Η απάντηση είναι ψευδής, με τους δύο σωστούς αριθμούς να κάθονται στο transcript. Το να τυλίξετε ένα μοντέλο σε loop δεν το κάνει να συλλογίζεται· δίνει σε ένα μοντέλο που κάνει λάθος τη δυνατότητα να ενεργήσει πάνω στο λάθος του — που είναι το Κεφάλαιο 30 εκ των προτέρων, και το μισό Κεφάλαιο 29.

Τώρα διαγράψτε το σημειωμένο return και αφήστε το loop να τρέξει μέχρι το όριό του. Ίδια ερώτηση, ίδιο μοντέλο:

  turn 1  prompt= 187  out= 21  CALL get_temperature({"city": "Oslo"})
  turn 2  prompt= 238  out= 12  TEXT "The current temperature in Oslo is 4 degrees Celsius."
  turn 3  prompt= 261  out= 30  TEXT "Could you please specify the exact location you're..."
  turn 4  prompt= 302  out= 14  TEXT "Sure! Could you tell me which city you're interested in?"
  turn 5  prompt= 327  out= 35  TEXT "I'm sorry, but I need more details to provide an..."
  turn 6  prompt= 373  out= 12  TEXT "Which city would you like to know the temperature for?"
  => model calls=6  prompt tokens=1,688  output=124  wall=25,261 ms  stopped by: turn cap

Τέσσερις φορές τα input tokens, τέσσερις φορές ο πραγματικός χρόνος, και ένα τέλος στο οποίο ο agent έχει ξεχάσει τι ρωτήθηκε και ανακρίνει τον χρήστη για μια ερώτηση που εκείνος απάντησε στον πρώτο γύρο. Η σωστή απάντηση ήταν στην οθόνη στον γύρο 2, και κάθε γύρος μετά από αυτόν έκανε το transcript χειρότερο.

Άρα ένας agent δεν είναι loop. Είναι loop συν έναν κανόνα για να βγει από αυτό, και αυτός έχει ακριβώς έναν τέτοιο κανόνα. Το Κεφάλαιο 23 βρίσκει πέντε, και δείχνει τι σπάει όταν λείπει ο καθένας.

Και οι δύο παρατίθενται αντί να παραφραστούν, επειδή οι παραφράσεις είναι εκεί όπου κατασκευάζεται η σύγχυση.

Ο πρώτος ορισμός βάζει το όριο στο ποιος ελέγχει τη ροή. Το Building effective agents της Anthropic ονομάζει την ασάφεια και αποφασίζει πάνω της:

«Στην Anthropic, κατηγοριοποιούμε όλες αυτές τις παραλλαγές ως agentic systems, αλλά χαράζουμε μια σημαντική αρχιτεκτονική διάκριση ανάμεσα σε workflows και agents: Workflows είναι συστήματα όπου LLMs και εργαλεία ενορχηστρώνονται μέσω προκαθορισμένων διαδρομών κώδικα. Agents, από την άλλη, είναι συστήματα όπου LLMs κατευθύνουν δυναμικά τις δικές τους διαδικασίες και χρήση εργαλείων, διατηρώντας τον έλεγχο του πώς ολοκληρώνουν εργασίες.»⁴

Το τεστ είναι μια ερώτηση για τον πηγαίο σας κώδικα: ποιος διάλεξε το επόμενο βήμα; Ένα switch στο πρόγραμμά σας: workflow. Το μοντέλο: agent. Το ίδιο έγγραφο λέει ότι οι agents «είναι συνήθως απλώς LLMs που χρησιμοποιούν εργαλεία με βάση environmental feedback σε loop» — που είναι ακριβώς το listing παραπάνω.

Ο δεύτερος ορισμός βάζει το όριο στην ανεξαρτησία από τον χρήστη. Το A practical guide to building agents της OpenAI ανοίγει τη σελίδα ορισμού του έτσι:

«Ενώ το συμβατικό λογισμικό επιτρέπει στους χρήστες να απλοποιούν και να αυτοματοποιούν workflows, οι agents μπορούν να εκτελούν τα ίδια workflows για λογαριασμό των χρηστών με υψηλό βαθμό ανεξαρτησίας. Agents είναι συστήματα που ολοκληρώνουν ανεξάρτητα εργασίες για λογαριασμό σας.»⁵

Δύο προτάσεις αργότερα, στην ίδια σελίδα, αποκλείει:

«Εφαρμογές που ενσωματώνουν LLMs αλλά δεν τα χρησιμοποιούν για να ελέγξουν την εκτέλεση workflow — σκεφτείτε απλά chatbots, single-turn LLMs ή sentiment classifiers — δεν είναι agents.»⁵

Διαβάστε αυτά τα αποσπάσματα με τη σειρά. Οι εναρκτήριες προτάσεις χαράζουν τη γραμμή στην ανεξαρτησία: πηγαίνει αυτό το πράγμα και τελειώνει τη δουλειά χωρίς εμένα; Η τέταρτη τη χαράζει στον έλεγχο της εκτέλεσης, που είναι ακριβώς η γραμμή της Anthropic. Διαφορετικά τεστ, ίδια σελίδα, και υπάρχουν πραγματικά συστήματα στα οποία διαφωνούν.

Από κάτω υπάρχει σύγκρουση λεξιλογίου, και προκαλεί καβγάδες σε πραγματικές συναντήσεις. Στο πρώτο έγγραφο ένα workflow είναι αρχιτεκτονική, και είναι το πράγμα που δεν είναι agent. Στο δεύτερο ένα workflow είναι «μια ακολουθία βημάτων που πρέπει να εκτελεστούν για να επιτευχθεί ο στόχος του χρήστη» — η ίδια η δουλειά, που κάθε agent έχει μία. Το «αντικαταστήσαμε το workflow με έναν agent» είναι συνεκτικό με τον πρώτο ορισμό και σχεδόν άνευ νοήματος με τον δεύτερο.

Τρία συστήματα που υπάρχουν το 2026, κάτω και από τους δύο ορισμούς.

Δύο από τα τρία αλλάζουν πλευρά. Αυτό δεν είναι αποτυχία κανενός εγγράφου. Είναι προειδοποίηση για ένα είδος συνάντησης όπου δύο άνθρωποι που συμφωνούν πλήρως για το τι κάνει ένα σύστημα περνούν μία ώρα διαφωνώντας για το πώς να το ονομάσουν.

Οι ορισμοί συγκρούονται επειδή ο καθένας συμπτύσσει δύο ανεξάρτητες ερωτήσεις σε μία λέξη. Χωρίστε τες και η διαφωνία γίνεται πίνακας, που είναι πιο χρήσιμος από μια ετυμηγορία.

Κάθε ορισμός αμφισβητεί διαφορετικό κελί, και τα άλλα δύο δεν αμφισβητούνται καθόλου. Άρα όταν η ετικέτα έχει σημασία — σε σύμβαση, risk review, postmortem — οι δύο προτάσεις που αξίζει να γραφτούν δεν είναι «είναι agent» αλλά ποιος διάλεξε το επόμενο βήμα και ποιος παρακολουθούσε. Και οι δύο απαντώνται διαβάζοντας κώδικα, καμία δεν χρειάζεται τον ορισμό κανενός, και μαζί κουβαλούν κάθε συνέπεια που υποκαθιστούσε η ετικέτα.

Τίποτα από αυτά δεν είναι νέο. Οι Wooldridge και Jennings επισκόπησαν τις ανταγωνιστικές σημασίες του «agent» το 1995·⁶ οι Franklin και Graesser έθεσαν την ερώτηση αυτού του κεφαλαίου το 1996, συγκέντρωσαν τους ορισμούς που κυκλοφορούσαν και διαπίστωσαν ότι διαφωνούσαν.⁷ Μια επισκόπηση του 2023 εξακολουθεί να ορίζει τους agents από τις πρώτες αρχές — «τεχνητές οντότητες που αισθάνονται το περιβάλλον τους, παίρνουν αποφάσεις και αναλαμβάνουν ενέργειες»⁸ — επειδή δεν υπήρχε κάτι συμφωνημένο για να παρατεθεί, και το CoALA περιγράφει μέρη αντί να χαράζει όριο.⁹ Τριάντα χρόνια άρνησης συμφωνίας λένε ότι η λέξη κάνει περισσότερες από μία δουλειές.

Τώρα η συνέπεια που φτάνει πριν από τη φιλοσοφία, δηλαδή ο λογαριασμός.

Κάθε μέτρηση εδώ έχει το ίδιο σχήμα. Η μεμονωμένη κλήση κόστισε 39 input tokens· η ίδια ερώτηση με ένα εργαλείο κόστισε 420 σε δύο κλήσεις· το loop χωρίς τον κανόνα τερματισμού του κόστισε 1.688 σε έξι. Η αύξηση είναι χειρότερη από γραμμική, επειδή ο γύρος n κουβαλά κάθε προηγούμενο γύρο μαζί του: η στήλη prompt εκείνης της εκτέλεσης έξι γύρων γράφει 187, 238, 261, 302, 327, 373. Το Κεφάλαιο 16 παρήγαγε ότι το σύνολο είναι $\Theta(n^2)$ και προσάρμοσε την καμπύλη σε μια πραγματική συζήτηση. Ένας agent μετατρέπει κάθε εργασία σε εκείνη τη συζήτηση, είτε τη βλέπει ποτέ άνθρωπος είτε όχι.

Αν αυτά τα μετρημένα token counts είχαν πάει σε εμπορικό endpoint με τις τιμές που διάβασε το Κεφάλαιο 16 στις 6 Σεπτεμβρίου 2026 — $2.00 ανά εκατομμύριο input tokens και $12.00 ανά εκατομμύριο output — οι τέσσερις εκτελέσεις τιμολογούνται έτσι:

Η δεύτερη σειρά απέναντι στην πρώτη είναι ο αριθμός που πρέπει να κρατήσετε. Επτάμισι φορές το κόστος, για χειρότερη απάντηση σε μια ερώτηση που το μοντέλο ήδη ήξερε. Τίποτα δεν ήταν λάθος ρυθμισμένο: υπήρχε ένα εργαλείο, άρα το μοντέλο το χρησιμοποίησε — και το εύρημα του Κεφαλαίου 18, ότι αυτό που πονά είναι η τιμή ενός καταλόγου και όχι η ακρίβειά του, έχει εδώ τη φθηνότερη επίδειξή του με κατάλογο ενός.

Γι’ αυτό το χρήσιμο μισό και των δύο εγγράφων είναι το μισό που αφορά το να μην το χτίσετε. Της Anthropic είναι ευθύ: βρείτε την απλούστερη δυνατή λύση και προσθέστε πολυπλοκότητα μόνο όταν χρειάζεται, κάτι που «μπορεί να σημαίνει να μη φτιάξετε καθόλου agentic systems», αφού τα agentic systems «ανταλλάσσουν latency και κόστος με καλύτερη απόδοση εργασίας» και «για πολλές εφαρμογές, η βελτιστοποίηση μεμονωμένων LLM calls με retrieval και in-context examples είναι συνήθως αρκετή».⁴ Η περίπτωση υπέρ ενός agent είναι στενή: ανοιχτά προβλήματα όπου δεν μπορείτε να προβλέψετε τον αριθμό βημάτων και δεν μπορείτε να hardcode μια διαδρομή, σε περιβάλλον που εμπιστεύεστε, αποδεχόμενοι «υψηλότερα κόστη και την πιθανότητα συσσωρευόμενων λαθών».⁴ Η οθόνη της OpenAI είναι το είδωλο στον καθρέφτη — σύνθετη κρίση, μη συντηρήσιμα σύνολα κανόνων, αδόμητα δεδομένα — και καταλήγει το ίδιο: «διαφορετικά, μια ντετερμινιστική λύση μπορεί να αρκεί».⁵

Άρα, στην ταξινομία αυτού του κεφαλαίου: ένας σταθερός αριθμός βημάτων σε σταθερή σειρά είναι pipeline, και το να το ονομάσετε agent δεν θα το κάνει γρηγορότερο. Αν ο αριθμός βημάτων εξαρτάται από όσα βρίσκετε στη διαδρομή, θέλετε loop — και αγοράζετε αυτή την ευελιξία με N κλήσεις, τετραγωνικό transcript και ένα σύστημα που μπορεί να κάνει λάθος N φορές αντί για μία.

Τώρα έχετε την ταξινομία, και τους δύο σύγχρονους ορισμούς, τους δύο άξονες που τους κάνουν συμβατούς, και ένα μικρό loop που απαντά, καλεί και σταματά.

Εκείνο το loop έχει έναν τρόπο να τελειώσει: το μοντέλο σταματά να ζητά εργαλεία. Το Κεφάλαιο 23 το σπάει επίτηδες, επτά φορές, και κάθε σπάσιμο προσθέτει ένα κομμάτι. Μια αδύνατη εργασία, και δεν τελειώνει ποτέ — turn cap. Μια νύχτα λειτουργίας, και έρχεται ο λογαριασμός — budget σε δολάρια. Ένα εργαλείο που αποτυγχάνει — ένα σφάλμα πάνω στο οποίο μπορεί να ενεργήσει το μοντέλο. Η ίδια κλήση δύο φορές — idempotency key. Ένα αρχείο που δεν έπρεπε να αγγίξει — ανθρώπινη έγκριση. Μια επανεκκίνηση στη μέση — session persistence. Ένα εργαλείο που χρειάζεται τρία λεπτά σιωπής — πρόοδος και ακύρωση. Αυτό που βγαίνει είναι ένα harness, το αρχείο πάνω στο οποίο τρέχει το υπόλοιπο αυτού του μαθήματος.

Που αφήνει την ερώτηση για την οποία στην πραγματικότητα αφορούσε η αμφισβητούμενη διαγώνιος αυτού του κεφαλαίου. Ένα loop που αποφασίζει το δικό του επόμενο βήμα πρέπει να αποφασίσει πότε θα σταματήσει, και μόλις είδαμε τι συμβαίνει όταν δεν μπορεί: έξι γύροι, τέσσερις φορές ο λογαριασμός, και ένας agent που ανακρίνει τον χρήστη για μια ερώτηση που είχε ήδη απαντήσει. Το σταμάτημα δεν είναι μία συνθήκη. Πόσες υπάρχουν, και ποια ενεργοποιείται πρώτη;

Το LLM Powered Autonomous Agents της Lilian Weng (2023) είναι η πιο γνωστή διάσπαση ενός language agent σε planning, memory και χρήση εργαλείων, και είναι το σωστό επόμενο ανάγνωσμα μαζί με τα δύο έγγραφα των vendors· τα τρία συστατικά του είναι τα Κεφάλαια 23, 24 και 18 αυτού του μαθήματος, με αυτή τη σειρά.

Κάθε αριθμός σε αυτό το κεφάλαιο παράχθηκε σε αυτό το μηχάνημα και τίποτα δεν εκτιμήθηκε. Ο διάδρομος, η κάτοψη, οι τέσσερις agents που την περπατούν και οι τρεις πολιτικές περιπολίας είναι η TypeScript παραπάνω, εκτελεσμένη σε Node 22· οι αριθμοί του randomized agent είναι μέσοι όροι σε 2.000 seeded εκτελέσεις η καθεμία και οι αριθμοί περιπολίας είναι single seeded εκτελέσεις 4.000 ticks. Τα model traces προέρχονται από Qwen2.5-0.5B-Instruct σε float32 σε CPU με greedy decoding, σερβιρισμένο πάνω από loopback από ένα μικρό τοπικό Python endpoint που φορτώνει τα weights και μιλά το σχήμα OpenAI chat-completions — η ραφή ξανά, με τα tensors στην πλευρά της Python και το loop στην πλευρά της TypeScript — άρα τα token counts είναι του tokenizer αυτού του μοντέλου και τα latencies αυτού του μηχανήματος. Οι μόνοι αριθμοί που ελήφθησαν από αλλού είναι οι δύο τιμές στον πίνακα κόστους, που είναι οι χρεώσεις που το Κεφάλαιο 16 διάβασε από τη σελίδα τιμολόγησης της OpenAI στις 6 Σεπτεμβρίου 2026, εφαρμοσμένες εδώ σε τοπικά μετρημένα token counts ως παράδειγμα και όχι ως παρατηρημένο τιμολόγιο.