පහුගිය අවුරුදු දෙක පමණ කාලෙ පුරාම "coding agent" කියන වචනෙන් අදහස් කළේ සාපේක්ෂව සරල දෙයක්. chat interface එකකින් එතුණු autocomplete engine එකක්, ඉඳහිට shell command එකක් දුවවන්න හරි file එකක් කියවන්න හරි පුළුවන් එකක්. ඒ නිර්වචනය දැන් කල් ඉකුත්වෙලා. Anthropic, OpenAI, Google වගේ ප්රමුඛයින්ගෙත්, වර්ධනය වෙන startup පොකුරකගෙත් සිස්ටම් දැන් මුළුමනින්ම වෙනස් කාණ්ඩයකට පැනලා. ඒවා වැඩ සැලසුම් කරනවා, විශේෂිත sub-agents කිහිපයකට කාර්යයන් කඩකරගන්නවා, තමන්ගේම output තක්සේරු කරගන්නවා, verification අසාර්ථක උනොත් ප්රවේශය නැවත සකස් කරගන්නවා. තරගය දැන් model එකේ ගුණාත්මකභාවය ගැන නෙවෙයි, system architecture එක ගැන.
මුල් කාලෙ coding assistants ඉල්ලීමක් ආවොත් සලකලා බැලුවේ stateless prediction ප්රශ්නයක් විදිහට. prompt එකයි ටිකක් අවට context එකයි දුන්නම, ඊළඟට එන්න වැඩිම ඉඩ තියෙන tokens ටික හදනවා. කෙටි completions වලට මේක හොඳට වැඩ කළා, ඒත් සංගත පියවර කිහිපයකට වඩා ඕන වුණ වැඩකදී ක්රමයෙන් ගොඩදානවා. අලුත් පරම්පරාව වැඩ කරන්නේ මුළුමනින්ම වෙනස් loop එකකින්: plan, act, observe, critique, repeat.
සාමාන්ය නවීන agent run එකක් පටන් ගන්නේ planner කෙනෙක්ගෙන්. එයා ඉල්ලීම sub-goals වලට කඩාගන්නවා. හැම sub-goal එකක්ම executor කෙනෙක්ට බාරදෙනවා. ඒ executor ට files කියවන්න, tests run කරන්න, linters පාවිච්චි කරන්න, වෙනත් tools call කරන්න පුළුවන්. ක්රියාත්මක කරපු එක ඉවර වුණාම, වෙනම evaluator කෙනෙක් ප්රතිඵලය මුල් specification එකට සසඳලා බලනවා. evaluator output එක ප්රතික්ෂේප කළොත්, සංශෝධිත context එකකින් loop එක නැවත පටන් ගන්නවා. මේ වගේ වෙන වෙනම roles වලට බෙදීම — බොහෝ විට වෙනස් prompts විදිහට හෝ සමහර වෙලාවට වෙනස් models විදිහටම — තමයි multi-agent orchestration එක සරල prompt chaining එකෙන් වෙන් කරන්නේ.
මේ වෙනස්කම් අතරෙ වැඩිම බලපෑමක් කරපු දේ තමයි self-evaluation එක. ඒක දැන් පර්යේෂණ කුතුහලයක් නෙවෙයි, product feature එකක්. agent එකක් code එකක් ලිව්වම, දැන් සාමාන්යයෙන්ම ඒ code එක run කරනවා, error output එක parse කරනවා, ඒක අලුත් input එකක් විදිහට සලකනවා. Test suites, type checkers, static analyzers ඔක්කොම ලාභ external graders විදිහට වැඩ කරනවා. මේ loop එක තුළ agent එක machine-learning අර්ථයෙන් කිසිම දෙයක් ඉගෙනගන්නේ නැහැ, ඒත් කලින් සිස්ටම් මග ඇරපු feedback එක පාවිච්චි කරලා solution space එක explore කරනවා.
මේ loop එකේ සරල කරපු අනුවාදයක් මෙහෙමයි:
Verification එක pass උනොත් හරි, budget එක ඉවර වුණොත් හරි recursion එක නවතිනවා. Production systems වලට caching, parallelism, rollback වගේ දේවල් එකතුවෙනවා, ඒත් මූලික ව්යුහය නම් vendor වෙනස් උනත් ටිකක් දුරට සමානයි.
Raw model capability එක දැන් සංකෝචනය වෙලා. ඉහළින්ම ඉන්න frontier models තුන හතර අතර standard coding benchmarks වල පරතරය කොච්චර කුඩාද කියනවා නම්, benchmark scores දැන් මිලදී ගැනීමේ තීරණ අරගන්න ප්රමාණවත් නැහැ. නිෂ්පාදන වෙන්කරන දේ දැන්, ඒ වටේට හදලා තියෙන system එක long-horizon tasks හසුරුවන විදිහ: context management, tool invocation latency, parallel sub-agents කලමනාකරණය, අර්ධ අසාර්ථකවීම් වලින් යළි නැගිටින හැකියාව — මේවා.
Anthropic තමන්ගේ අවධානය යොමු කරලා තියෙන්නේ වෙන වෙනම contexts වල වැඩ කරලා සංක්ෂිප්ත සාරාංශ නැවත එවන sub-agents කෙරෙහි. OpenAI sessions පහු වුණත් රැඳී පවතින persistent task environments වලට ආයෝජනය කරලා. Google තමන්ගේම developer tooling එකත්, විශාල context retrieval එකත් සමඟ integration එකට තල්ලුවෙලා. හැම ප්රවේශයක්ම පිළිබිඹු කරන්නේ වැදගත්ම bottleneck එක මොකක්ද කියන කාරණාව ගැන ඒ ඒ සමාගමේ pundit කල්පනාව. underlying model එකේ ගුණාත්මකභාවය සමාන වුණත්, මේ වෙනස්කම් නිසා user experience එක පැහැදිලිවම වෙනස්.
මේ tools තමන්ගේ ඇත්ත වැඩවලට ඈඳගන්න බලන කාටත් ප්රතිවිපාක තුනක් එනවා. පළවෙනියට, prompt එක කොච්චර දක්ෂකමින් ලිව්වද කියන එකට වඩා, specification එකේ ගුණාත්මකභාවය වැදගත්. තමන්ම තක්සේරු කරගන්න agents කෙනෙක්ට තක්සේරු කරගන්න සංයුක්ත දෙයක් ඕන. නොපැහැදිලි කාර්ය නොපැහැදිලි verification ගෙනදෙනවා, ඒකෙන් drift එක ගේනවා. නිර්වචිත acceptance criteria — අවිධිමත්ව හරි — ලියන එක ප්රතිඵල සැලකිය යුතු මට්ටමකින් වැඩිදියුණු කරනවා.
දෙවනියට, agent එකට පේන tool surfaces ඔක්කොම ගිවිසුමේ කොටසක්. agent එක කොච්චර දක්ෂද කියන එක තීරණය වෙන්නේ එයාට call කරන්න පුළුවන් tools වලින්. පිරිසිදු CLI එකක්, typed API එකක්, හරි deterministic test command එකක් එළියට දුන්නම agent එකට පරීක්ෂා කරගන්න පුළුවන් foothold ලැබෙනවා. GUI එකක් විතරක් හරි අඩුවෙන් specify කරපු script එකක් විතරක් හරි දුන්නම agent එකට වැඩ කරන්න සිද්ධ වෙන්නේ අනුමාන කරගෙන.
තුන්වැනියට, cost සහ latency profile එකම වෙනස් වෙලා. දැන් එක user request එකකින් models multiple agents හරහා call ගණන් දුසිම් ගණනක් trigger වෙන්න පුළුවන්. Chat වලට ඕන තරම් මදි පුංචි කියලා හිතුණ token budgets orchestration වලට ටයිට්. මේ tools විශාල පරිමාණයෙන් භාවිතා කරන teams use case එක model කරන්න ඕන individual completions පදනමින් නෙවෙයි, agent runs පදනමින්.
ගමන්මග පෙන්වන්නේ දිගුකාලීන state තියාගන්න පුළුවන්, ආයතන සීමාවන් හරහා වෙනත් agents එක්ක සම්බන්ධීකරණය වෙන්න පුළුවන්, මිනිත්තු නෙවෙයි පැය ගණන් යන වැඩ භාර ගන්න පුළුවන් agents දිහාට. මේක සිද්ධවෙයිද කියන එක නෙවෙයි ප්රශ්නේ. ඇත්ත ප්රශ්න මේවා: කාර්යය දිගුවෙද්දි reliability එක scale වෙන්නේ කොහොමද? specifications තමයි අපැහැදිලි නම් verification එක රැඳෙයිද? මනුෂ්ය reviewers ලා සහ automated critics අතර වගකීම් teams බෙදන්නේ කොහොමද? Autocomplete යුගය ප්රයෝජනවත් tools හැදුවා. Orchestration යුගය හදන්නේ ඊට වඩා junior collaborator කෙනෙක්ට ළං දෙයක් — ඒකට ඕන වෙන සියලුම අධීක්ෂණ බර එක්කම.
Chamith Dilshan
Editor in Chief
C2Labs හි නිර්මාතෘ. AI, විද්යාව, සහ තාක්ෂණය ගැන සිංහල සහ ඉංග්රීසි භාෂාවෙන් ලියයි.