"agent" என்ற சொல் தனது பொருளை இழந்து வருகிறது. இப்போது எந்தவொரு தயாரிப்பு அறிவிப்பையும் பார்த்தால், ஒவ்வொரு AI அம்சமும் தான் ஒரு 'agent' என்று உரிமை கோருகிறது. மின்னஞ்சல் வரைவுகளை உருவாக்கும் ஒரு எளிமையான விட்ஜெட் (widget)? அது ஒரு Agent. உங்கள் அறிவுத் தளத்தைப் (knowledge base) படிக்கும் ஒரு சப்போர்ட் பாட் (support bot)? அதுவும் ஒரு Agent. ஒரு API-ஐ அழைத்து JSON-ஐத் திருப்பித் தரும் ஒரு ஸ்கிரிப்ட் (script)? அதுவும் ஒரு Agent தான். இது வெறும் கவனக்குறைவான சந்தைப்படுத்தல் மட்டுமல்ல; இது ஆபத்தான வடிவமைப்பு (design). எல்லாவற்றையும் 'agent' என்று அழைக்கும்போது, நீங்கள் உண்மையில் எதை உருவாக்குகிறீர்கள் என்பதைப் புரிந்துகொள்வதை நிறுத்திவிடுகிறீர்கள். வேலையைத் தீர்மானிப்பதற்கு முன்பே சிக்கலான கட்டமைப்புகளை (architectures) நோக்கித் திரும்புகிறீர்கள். இதன் விளைவாக உடையக்கூடிய குறியீடுகள் (brittle code), கட்டுக்கடங்காத டோக்கன் செலவுகள் (runaway token costs) மற்றும் உங்களால் விளக்கவோ அல்லது மீண்டும் உருவாக்கவோ முடியாத வகையில் செயல்படும் அமைப்புகள் உருவாகின்றன.

சாட்போட்கள் (Chatbots) காத்திருக்கின்றன, அவை செயல்படுவதில்லை

சாட்போட்கள் மிக எளிமையான நிலையில் உள்ளன. அவை எதிர்வினை ஆற்றக்கூடியவை (reactive). ஒரு பயனர் கேள்வியைத் தட்டச்சு செய்கிறார், மாடல் ஒரு பதிலை உருவாக்குகிறது, மற்றொரு மனிதத் தூண்டுதல் (prompt) வரும் வரை உரையாடல் அங்கேயே முடிந்துவிடுகிறது. இந்த அமைப்புகள் உங்கள் காலெண்டரைச் சரிபார்க்கவோ, தரவுத்தளப் பதிவைப் (database record) புதுப்பிக்கவோ அல்லது விளக்கத்திற்காகக் காத்திருக்கவோ முடிவெடுப்பதில்லை. ஒரு SaaS விலைப் பக்கத்தில் உள்ள உட்பொதிக்கப்பட்ட உதவி விட்ஜெட்டை (help widget) எடுத்துக் கொள்ளுங்கள். அது பில்லிங் சுழற்சிகள் மற்றும் அம்ச வரம்புகள் பற்றிய கேள்விகளுக்குப் பதிலளிக்கிறது. அது ஒரு வாடிக்கையாளருக்குப் பணத்தைத் திரும்பத் தருவதோ, திட்டத்தை மேம்படுத்துவதோ அல்லது சந்தேகத்திற்கிடமான கணக்கைக் கண்டறிவதோ இல்லை. அதற்கு எந்தக் கருவிகளும் இல்லை, சாட் விண்டோவைத் தாண்டி நிலையான நிலையும் (persistent state) இல்லை, பொருத்தமான ஒரு வாக்கியத்தை உருவாக்குவதைத் தவிர வேறு எந்த இலக்கும் இல்லை. அதுதான் ஒரு சாட்போட். அது பதிலளிக்கிறது; ஆனால் செயல்படுவதில்லை.

அசிஸ்டன்ட்கள் (Assistants) ஒரு குறிப்பிட்ட எல்லைக்குள் உதவுகின்றன

அசிஸ்டன்ட்கள் செயல்பாட்டுத் திறனை (agency) அதிகரிக்காமல் நுணுக்கத்தைச் சேர்க்கின்றன. அவை ஒரு குறிப்பிட்ட பாத்திரத்தை (persona) ஏற்க சிஸ்டம் ப்ராம்ப்ட்களைப் (system prompts) பயன்படுத்துகின்றன. நீண்ட உரையாடல்களின் போது அவை சூழலை (context) நினைவில் கொள்கின்றன. நீங்கள் பதிவேற்றிய ஒரு ஆவணத்தைச் சுருக்கலாம் அல்லது உங்கள் பத்தியை வேறு தொனியில் மாற்றி எழுதலாம். உங்கள் இலக்கணத்தைச் சரிபார்த்து, தெளிவான சொற்றொடர்களைப் பரிந்துரைக்கும் ஒரு எழுத்து உதவியாளர் (writing assistant) பயனுள்ளதாக இருக்கும். நீங்கள் பிரிட்டிஷ் எழுத்து முறையை விரும்புகிறீர்கள் என்பதை அது நினைவில் கொள்ளும். ஆனால் அது உங்களுக்காகச் செயல்படாது. அது உங்கள் எடிட்டருக்கு மின்னஞ்சல் அனுப்பவோ, காலக்கெடுவை நிர்ணயிக்கவோ அல்லது தானாகவே இணையத்தைத் தேடவோ முடிவெடுப்பதில்லை. நீங்கள் வழங்கும் விண்டோவிற்குள் மட்டுமே அது உதவுகிறது. அது காரை ஓட்டுவதில்லை; நீங்கள் சக்கரம் பிடித்துக் கொண்டிருக்கும்போது சிறந்த பாதையை மட்டும் பரிந்துரைக்கிறது.

பணிப்பாய்வுகள் (Workflows) நீங்கள் வரைந்த வரைபடத்தைப் பின்பற்றுகின்றன

பெரும்பாலான உற்பத்தி AI அமைப்புகள் (production AI systems) உண்மையில் இருக்கும் இடைப்பட்ட நிலையில் பணிப்பாய்வுகள் உள்ளன. இங்கே, பாதையை நீங்களே வரையறுக்கிறீர்கள். நீங்கள் தொடர்ச்சியான படிகளை உருவாக்குகிறீர்கள்: இன்வாய்ஸ் தேதியைப் பிரித்தெடுப்பது, விற்பனையாளர் ஐடியைத் (vendor ID) தேடுவது, கொள்முதல் ஆணையுடன் (purchase order) தொகையை ஒப்பிடுவது, கணக்கியல் விரிதாளைப் (accounting spreadsheet) புதுப்பிப்பது, எண்கள் பொருந்தவில்லை என்றால் நிதித் துறைக்குத் தகவல் அனுப்புவது. மாடல் இன்வாய்ஸைப் படிக்கலாம் அல்லது முரண்பாட்டை வகைப்படுத்தலாம், ஆனால் அது உங்கள் வரைபடத்தையே (graph) பின்பற்றுகிறது. நீங்கள் வரைபடத்தை வரைந்திருப்பதால், என்ன நடக்கும் என்பதை நீங்கள் துல்லியமாகத் தெரிந்து வைத்திருப்பீர்கள்.

பணிப்பாய்வுகளைச் சோதனை செய்வது எளிது. ஒவ்வொரு படியையும் தனித்தனியாகச் சோதனை (unit-test) செய்யலாம். ஒவ்வொரு முனையிலும் (node) உள்ளீடுகள் மற்றும் வெளியீடுகளைப் பதிவு (log) செய்யலாம். ஏதேனும் முறிந்துபோனால், தெளிவற்ற சிந்தனைச் சங்கிலியில் (opaque chain of thought) தேட வேண்டிய அவசியமின்றி எந்தப் பிரிவு தோல்வியடைந்தது என்பதை நீங்கள் அறிந்து கொள்ளலாம். அமைப்பு உங்களை திசைதிருப்பாமல் இருப்பதால், அதன் செயல்பாட்டைக் கவனிப்பது (observability) எளிதானது. உங்கள் வணிகச் செயல்முறை தெளிவான விதிகள் மற்றும் அறியப்பட்ட விதிவிலக்குகளைக் கொண்டிருந்தால், ஒரு பணிப்பாய்வு பொதுவாகச் சிறந்தது. இயந்திரத்திற்குத் திட்டங்கள் (intentions) இருப்பதாகக் கற்பனை செய்யாமல், நீங்கள் வேகம், நம்பகத்தன்மை மற்றும் குறைந்த செலவைப் பெறுகிறீர்கள்.

ஏஜென்ட்கள் (Agents) பாதையைத் தேர்ந்தெடுக்கின்றன

ஏஜென்ட்கள் வேறுபட்டவை. அவை இயங்குதன்மை கொண்டவை (dynamic). நீங்கள் அவற்றுக்கு ஒரு இலக்கைக் கொடுத்தால், அதை எப்படி அடைவது என்பதை அவைவே கண்டறியும். ஒரு ஏஜென்ட் ஒரு பணியைப் பெறுகிறது, என்ன நடக்க வேண்டும் என்று பகுப்பாய்வு செய்கிறது, கருவிகளைத் தேர்ந்தெடுக்கிறது, செயல்படுகிறது, முடிவைக் கவனிக்கிறது, பின்னர் அடுத்து என்ன செய்ய வேண்டும் என்று முடிவெடுக்கிறது. அந்தச் சுழற்சி—சிந்திப்பது, செயல்படுவது, கவனிப்பது, மீண்டும் சிந்திப்பது—தான் ஒரு ஏஜென்ட்டை மற்ற அனைத்து வகைகளிலிருந்தும் வேறுபடுத்துகிறது.

பணத்தைத் திரும்பப் பெறுதல் கோரிக்கைகளைக் கையாளும் ஒரு அமைப்பைக் கருதுங்கள். ஒரு பணிப்பாய்வு மூன்று நிபந்தனைகளைச் சரிபார்த்து, நிலையான விதிகளின் அடிப்படையில் ஒப்புதல் அளிக்கலாம் அல்லது மறுக்கலாம். ஆனால், "மோடியைத் தடுத்தபடி இந்தத் திரும்பப் பெறுதலை நியாயமாகச் செய்" என்ற இலக்கு கொடுக்கப்பட்டால், ஒரு ஏஜென்ட் வாடிக்கையாளரின் கொள்முதல் வரலாற்றைக் கேட்கலாம், அந்தப் தயாரிப்பு வகையின் திரும்பப் பெறும் கொள்கையைச் சரிபார்க்கலாம், சமீபத்திய கணக்குச் செயல்பாடுகளைத் தேடலாம், முறை வழக்கத்திற்கு மாறாகத் தெரிந்தால் மேனுவல் ஆய்விற்காக ஒரு சப்போர்ட் டிக்கெட்டை உருவாக்கலாம், பின்னர் தனது முடிவை விளக்கி ஒரு மின்னஞ்சல் வரைவை உருவாக்கலாம். அந்த வழக்கின் தன்மையைப் பொறுத்து எந்தக் கருவிகளை எந்த வரிசையில் பயன்படுத்த வேண்டும் என்பதை அதுவே தேர்ந்தெடுத்தது.

ஒரு ஏஜென்ட் என்பது ஒரு முழுமையான அமைப்பு, வெறும் மாடல் மட்டுமல்ல

ஒரு ஏஜென்ட் என்பது சாட் விண்டோவில் இயங்கும் ஒரு மாடல் மட்டுமல்ல. அது ஒரு முழுமையான அமைப்பு. அது இவற்றை ஒருங்கிணைக்கிறது:

  • Models to reason and generate language
  • Instructions that constrain its operating space
  • Tools with strict schemas for interacting with the outside world
  • Context about the current task and environment
  • State so it remembers where it is in a multi-step process
  • Validations to check inputs before they enter a tool and outputs before they reach a user
  • Limits on budget, steps, or scope to prevent runaway behavior
  • Observability so you can reconstruct why it chose path A instead of path B

If your system lacks most of these, you do not have an agent. You have a model with extra API calls.

Autonomy Without Control Is Just Risk

If your agent can query your production database, create records in your CRM, or send messages to users, it can also corrupt data, duplicate entries, or spam customers. A good agent architecture assumes failure. It asks for permission before destructive actions. It runs validations before committing results. It exposes its reasoning so a human can intervene when costs or stakes run high.

If you skip these limits because the demo looked exciting, you will spend your weekends debugging why the agent created four hundred support tickets overnight or refunded an order it should not have touched. The unpredictability you feared in black-box systems becomes real the moment you hand the AI both a goal and an unsupervised set of tools.

Start With the Problem, Not the Technology

Do not start with the agent. Start with the pain. Sometimes the fix is a better prompt. Sometimes it is a deterministic function in your existing backend. Sometimes it is a workflow with one AI step and five traditional API calls.

Only reach for agents when the task genuinely requires:

  • Multiple steps that depend on each other
  • Dynamic decision-making between those steps
  • Interaction with external tools
  • Reasoning over intermediate results that you cannot fully map ahead of time

If the path is known, build a workflow. If the interaction is simple, build a chatbot or an assistant. Do not add agency because the word sounds modern.

Build Maturity, Not Complexity

When an agent truly is the right fit, build it in layers. Start with a single tool and a hardcoded decision. Add tests that verify the tool is called with correct arguments. Add logging so you can see the full trace. Add state management so the system knows where it left off. Add validations at every boundary. Add observability dashboards so your team can watch behavior in real time. Finally, carefully add autonomy—the freedom to choose between options. Do not do this in reverse. Autonomy layered on top of chaos produces expensive accidents.

The Real Takeaway

Words shape systems. Reserve the term "agent" for architectures that earn it: goal-directed, tool-using, and dynamically adaptive, but wrapped in strict limits and human oversight. Everything else is a chatbot, an assistant, or a workflow. Build the simplest thing that solves the problem. Your production logs, your finance team, and your future self will thank you.

Source: https://dev.to/leandrolayerle/no-todo-chatbot-es-un-agente-de-ia-3oec

Join the GyaanSetu learning community: https://t.me/GyaanSetuAi