ಮ್ಯಾಟ್ ಶೂಮರ್ ತನ್ನ ಕಂಪ್ಯೂಟರ್ ಮುಂದೆ ಕುಳಿತು ತನ್ನ AI ಏಜೆಂಟ್ಗೆ ಒಂದು ಸರಳ ಸೂಚನೆಯನ್ನು ನೀಡಿದರು: ಫೈಲ್ಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸು (clean up the files). ಅವರು ಈ ಕೆಲಸವನ್ನು ನೂರಾರು ಬಾರಿ ಯಾವುದೇ ತೊಂದರೆಯಿಲ್ಲದೆ ಮಾಡಿದ್ದರು. ಆದರೆ ಈ ಬಾರಿ, ಒಂದು ಪಾತ್ ರೆಸಲ್ಯೂಶನ್ ಎರರ್ (path resolution error) ಸಾಮಾನ್ಯ housekeeping ಕೆಲಸವನ್ನು ದೊಡ್ಡ ವಿನಾಶವಾಗಿ ಪರಿವರ್ತಿಸಿತು. ವರ್ಷಗಳ ಕಾಲ ಸಂಗ್ರಹಿಸಿದ ಕೋಡ್, ದಾಖಲೆಗಳು ಮತ್ತು ಫೋಟೋಗಳು ಕ್ಷಣಾರ್ಧದಲ್ಲಿ ಮಾಯವಾದವು.
ಇದು ಕೇವಲ ಕಾಲ್ಪನಿಕ ಅಪಾಯವಲ್ಲ. ಇದು ನಿಜವಾದ ಡೆವಲಪರ್ಗೆ ಮತ್ತು ಅವರ ನಿಜವಾದ ಯಂತ್ರದಲ್ಲಿ ಸಂಭವಿಸಿದೆ. ಆ ಏಜೆಂಟ್ ವಿಫಲವಾಗುವವರೆಗೂ ಅದರ ಕಾರ್ಯಕ್ಷಮತೆ ಅತ್ಯಂತ ಭದ್ರವಾಗಿ ಕಂಡಿತ್ತು. ಫೈಲ್ಗಳನ್ನು ಬರೆಯಬಲ್ಲ, ಟರ್ಮಿನಲ್ ಕಮಾಂಡ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಲ್ಲ ಮತ್ತು ಸಬ್-ಏಜೆಂಟ್ಗಳನ್ನು (subagents) ಸೃಷ್ಟಿಸಬಲ್ಲ AI ಏಜೆಂಟ್ಗಳು ಈಗ IDEಗಳು, ಚಾಟ್ ಇಂಟರ್ಫೇಸ್ಗಳು ಮತ್ತು ಆಟೊಮೇಷನ್ ಪೈಪ್ಲೈನ್ಗಳಲ್ಲಿ ಅಳವಡಿಸಲ್ಪಟ್ಟಿವೆ. ಅವುಗಳಿಗೆ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ಗಳ ನೇರ ಪ್ರವೇಶವನ್ನು ನೀಡಲಾಗಿದ್ದು, ಆ ನಂಬಿಕೆಯೇ ಅಪಾಯದ ಮೂಲವಾಗಿದೆ. ಶೂಮರ್ ಅವರ ಯಂತ್ರವನ್ನು ನಾಶಪಡಿಸಿದ ಅದೇ ರೀತಿಯ ವೈಫಲ್ಯಗಳು, ಟೂಲ್ ಪ್ರವೇಶವಿರುವ ಪ್ರತಿಯೊಂದು ಏಜೆಂಟ್ನಲ್ಲೂ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಅವು ಏಕೆ ವಿಫಲವಾಗುತ್ತವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ಹೇಗೆ ನಿಯಂತ್ರಿಸಬೇಕು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಈಗ ಈ ಪರಿಕರಗಳನ್ನು ಬಳಸುವ ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಒಂದು ಮೂಲಭೂತ ಅಸ್ತಿತ್ವದ ಕೌಶಲವಾಗಿದೆ.
ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಫೈಲ್ಸಿಸ್ಟಮ್ ಅನ್ನು ಎದುರಿಸಿದಾಗ
AI ಏಜೆಂಟ್ಗಳು ಯೋಚಿಸುವುದಿಲ್ಲ. ಅವು ಕೇವಲ ಪ್ಯಾಟರ್ನ್ಗಳನ್ನು (patterns) ಹೊಂದಿಸುತ್ತವೆ. ನೀವು “clean up files” ಎಂದು ಹೇಳಿದಾಗ, ಮಾಡೆಲ್ ತನ್ನ ತರಬೇತಿ ನೆನಪಿನ ಶಕ್ತಿಯಲ್ಲಿ (training memory) ಸಾವಿರಾರು ಸಮಾನವಾದ ಸಂವಹನಗಳನ್ನು ಹುಡುಕುತ್ತದೆ ಮತ್ತು ಅಂಕಿಅಂಶಗಳ ಪ್ರಕಾರ ಆ ಪ್ಯಾಟರ್ನ್ಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಕಮಾಂಡ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಒಂದು ವೇಳೆ ಸೂಚನೆಯು ಬಿಲ್ಡ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿದ್ದ ತಾತ್ಕಾಲಿಕ ಫೈಲ್ಗಳನ್ನು ಅಳಿಸುವುದಾಗಿದ್ದರೆ, ಅದು rm -rf /tmp/build-cache/* ನಂತಹ ಕಮಾಂಡ್ ಅನ್ನು ಸೃಷ್ಟಿಸಬಹುದು. ಇದು ನೋಡಲು ಸಮಂಜಸವಾಗಿ ಕಾಣುತ್ತದೆ ಏಕೆಂದರೆ ಮಾಡೆಲ್ ಇದುವರೆಗೆ ನೋಡಿದ ಇತರ ಎಲ್ಲಾ ಕ್ಲೀನಪ್ ಕಮಾಂಡ್ಗಳಂತೆಯೇ ಇದು ಇರುತ್ತದೆ.
ಆದರೆ $HOME ನಂತಹ ವೇರಿಯೇಬಲ್ (variable) ಸರಿಯಾಗಿ ರೆಸಲ್ವ್ ಆಗದಿದ್ದಾಗ ಏನಾಗುತ್ತದೆ? ಒಬ್ಬ ಮನುಷ್ಯ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ಪಾತ್ ಅನ್ನು ನೋಡಿ, ಸ್ವಲ್ಪ ಸಮಯ ನಿಂತು ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುತ್ತಾನೆ. ಆದರೆ ಏಜೆಂಟ್ ಆ ಪ್ಯಾಟರ್ನ್ ಇನ್ನೂ ಹೊಂದಿಕೆಯಾಗುತ್ತಿದೆ ಎಂದು ಭಾವಿಸಿ 'ಎಂಟರ್' ಒತ್ತುತ್ತದೆ. ಶೂಮರ್ ಅವರ ವಿಷಯದಲ್ಲಿ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಫೋಲ್ಡರ್ ಅನ್ನು ಮಾತ್ರ ಅಳಿಸಬೇಕಿದ್ದ ಕಮಾಂಡ್, ಬದಲಾಗಿ ಬಳಕೆದಾರರ ಡೈರೆಕ್ಟರಿಯ ಮೂಲವನ್ನು (root of the user directory) ಗುರಿಯಾಗಿಸಿಕೊಂಡಿತು. ಪಾತ್ ವಿಚಿತ್ರವಾಗಿ ಕಾಣುತ್ತಿದೆ ಎಂದು ಏಜೆಂಟ್ ಯೋಚಿಸಿ ನಿಲ್ಲಲಿಲ್ಲ. ಅದು ಗುರಿಯನ್ನು ಪರಿಶೀಲಿಸಲಿಲ್ಲ. ಕೇವಲ “clean up” ಎಂಬ ಪ್ಯಾಟರ್ನ್ಗೆ ಕಮಾಂಡ್ ಹೊಂದಿಕೆಯಾಯಿತು ಎಂಬ ಕಾರಣಕ್ಕೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿತು.
ಇದು ಲಾರ್ಜ್ ಲ್ಯಾಂಗ್ವೇಜ್ ಮಾಡೆಲ್ಗಳು ಮತ್ತು ಸಿಸ್ಟಮ್ ಅಡ್ಮಿನಿಸ್ಟ್ರೇಷನ್ ನಡುವಿನ ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸವಾಗಿದೆ. ನಿಜವಾದ ತರ್ಕವು (reasoning) ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು, ಕಲ್ಪನೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಎಡ್ಜ್ ಕೇಸ್ಗಳನ್ನು (edge cases) ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಆದರೆ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಎಂದರೆ ಅಂಕಿಅಂಶಗಳ ಪ್ರಕಾರ ಸರಿಯಾದ ಉತ್ತರಕ್ಕೆ ಹೋಲಿಕೆಯಾಗುವ ಪಠ್ಯವನ್ನು ಸೃಷ್ಟಿಸುವುದು ಮಾತ್ರ. ಆ ಉತ್ತರವು 'ರಿಕರ್ಸಿವ್ ಡಿಲೀಟ್ ಫ್ಲಾಗ್' (recursive delete flag) ಹೊಂದಿರುವ ಟರ್ಮಿನಲ್ ಕಮಾಂಡ್ ಆಗಿದ್ದಾಗ, ಕೇವಲ ಅಂಕಿಅಂಶಗಳ ಹೋಲಿಕೆ ಸಾಕಾಗುವುದಿಲ್ಲ.
ಸಬ್-ಏಜೆಂಟ್ನ ಅಂಧಾಕಾರದ ಬಿಂದು
ಅನೇಕ ಆಧುನಿಕ ಏಜೆಂಟ್ ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಸಬ್-ಏಜೆಂಟ್ಗಳಿಗೆ ಕೆಲಸಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡುವ ಮುಖ್ಯ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅನ್ನು (main orchestrator) ಬಳಸುತ್ತವೆ. ಪೇರೆಂಟ್ ಏಜೆಂಟ್ಗೆ ಕಟ್ಟುನಿಟ್ಟಾದ ಸೂಚನೆಗಳಿರಬಹುದು: ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಎಂದಿಗೂ ಮುಟ್ಟಬೇಡ, ಅಳಿಸುವ ಮೊದಲು ಯಾವಾಗಲೂ ಕೇಳು, ಆಡಿಟ್ ಲಾಗ್ ಅನ್ನು ನಿರ್ವಹಿಸು ಇತ್ಯಾದಿ. ನಂತರ ಅದು “clean up old logs” ಎಂಬ ಸಣ್ಣ ಪ್ರಾಂಪ್ಟ್ನೊಂದಿಗೆ ಕೆಲಸಗಾರನನ್ನು (worker) ಸೃಷ್ಟಿಸುತ್ತದೆ.
ಆ ಸಬ್-ಏಜೆಂಟ್ ಹೆಚ್ಚಾಗಿ ಪ್ರತ್ಯೇಕವಾಗಿ (in a silo) ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಅದು ಪೇರೆಂಟ್ ಏಜೆಂಟ್ನ ಟೂಲ್ಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆಯೇ ಹೊರತು, ಅದರ ಸುರಕ್ಷತಾ ಸಂಸ್ಕೃತಿಯನ್ನಲ್ಲ. ಮುಖ್ಯ ಏಜೆಂಟ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಇರಿಸಿದ್ದ ನಿರ್ಬಂಧಗಳು, ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಸಮಯದಲ್ಲಿ ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲ್ಪಡುತ್ತವೆ ಅಥವಾ ಸಂಪೂರ್ಣವಾಗಿ ಬಿಟ್ಟುಬಿಡಲ್ಪಡುತ್ತವೆ. ಸಬ್-ಏಜೆಂಟ್ಗೆ ಒಂದು ಕೆಲಸ ಮತ್ತು ಟೂಲ್ಕಿಟ್ ಸಿಗುತ್ತದೆ, ಆದರೆ ಗಾರ್ಡ್ರೈಲ್ಗಳನ್ನು (guardrails) ಸ್ಥಾಪಿಸಲು ಬೇಕಾದ ಗಂಟೆಗಟ್ಟಲೆ ಎಚ್ಚರಿಕೆಯ ಪ್ರಾಂಪ್ಟಿಂಗ್ ಸಿಗುವುದಿಲ್ಲ.
ಇದರ ಪರಿಣಾಮವು ಒಂದು ರೀತಿಯ ಸಾಂಸ್ಥಿಕ ಸ್ಮರಣಾಹೀನತೆಯಾಗಿದೆ (organizational amnesia). ಪೇರೆಂಟ್ ಏಜೆಂಟ್ನ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿರುವ ಸುರಕ್ಷತಾ ನಿಯಮವು ಸಬ್-ಏಜೆಂಟ್ಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಎಂದೇನೋ! ಇದು ವಿಶೇಷವಾಗಿ ಅಪಾಯಕಾರಿಯಾಗಿದೆ ಏಕೆಂದರೆ ಸಬ್-ಏಜೆಂಟ್ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಪುನರಾವರ್ತಿತ ಮತ್ತು ಕಡಿಮೆ ಪ್ರಾಮುಖ್ಯತೆಯ ಕೆಲಸಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಆಪರೇಟರ್ಗಳು ಅವುಗಳನ್ನು ಸೂಕ್ಷ್ಮವಾಗಿ ಗಮನಿಸುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತಾರೆ. ಲಾಗ್ ಕ್ಲೀನಪ್ ಕೆಲಸವು ಪ್ರೊಡಕ್ಷನ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅಳಿಸುವವರೆಗೂ ಯಾರೂ ಅದನ್ನು ಗಮನಿಸುವುದಿಲ್ಲ.
ನಿರ್ಣಾಯಕತೆಯ ಅಪಾಯ
AI ಏಜೆಂಟ್ಗಳಲ್ಲಿ ಗರಿಷ್ಠ ಸ್ವಾಯತ್ತತೆಯತ್ತ (maximum autonomy) ಒಂದು ವಿನ್ಯಾಸದ ಪ್ರವೃತ್ತಿ ಇದೆ. ಈ ದೃಷ್ಟಿಕೋನದ ಪ್ರಕಾರ, ಆದರ್ಶ ಏಜೆಂಟ್ವು ಕ್ಷುಲ್ಲಕ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಬಳಕೆದಾರರಿಗೆ ತೊಂದರೆ ನೀಡುವುದಿಲ್ಲ. ಅದು ನಿರ್ಣಾಯಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಟೂಲ್ ಕರೆಗಳನ್ನು (tool calls) ಜೋಡಿಸುತ್ತದೆ ಮತ್ತು ವಿರಾಮವಿಲ್ಲದೆ ಬಹು ಹಂತದ ಕೆಲಸಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.
ಆ ನಿರ್ಣಾಯಕತೆಯೇ ಈ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಅಸುರಕ್ಷಿತವಾಗಿಸುತ್ತದೆ. “act decisively” ಎಂದು ಪ್ರೋಗ್ರಾಂ ಮಾಡಲಾದ ಮಾಡೆಲ್ ತನ್ನ ಕೆಲಸವನ್ನು ಮರುಪರಿಶೀಲಿಸುವುದಿಲ್ಲ. ಒಂದು ಕಮಾಂಡ್ ವಿನಾಶಕಾರಿಯೆಂದು ಕಂಡಾಗ ಅದು ನಿಲ್ಲುವುದಿಲ್ಲ. ಅದು ಹಿಂಜರಿತವನ್ನು ಒಂದು ವೈಶಿಷ್ಟ್ಯದ ಬದಲಾಗಿ ದೋಷವಾಗಿ (bug) ಪರಿಗಣಿಸುತ್ತದೆ. ಮಾಡೆಲ್ ಸರಿಯಾದಾಗ ಇದು ಮ್ಯಾಜಿಕ್ನಂತೆ ಅನಿಸುತ್ತದೆ. ಆದರೆ ಅದು ತಪ್ಪಾದಾಗ, ಅದು ಅತೀವ ವಿನಾಶಕಾರಿಯಾಗಿ ಕಾಣುತ್ತದೆ. ಒಂದು ಕೆಟ್ಟ ಕಮಾಂಡ್ ಅನ್ನು ನಿಧಾನಗೊಳಿಸಲು ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಯಾವುದೇ ನೈಸರ್ಗಿಕ ಅಡೆತಡೆಗಳಿಲ್ಲ.
Shumer ನ ಏಜೆಂಟ್ ನೂರಾರು ಬಾರಿ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಿದೆ. ಆ ಯಶಸ್ವಿ ದಾಖಲೆಯು ಸುಳ್ಳು ಭದ್ರತೆಯ ಭಾವನೆಯನ್ನು ಮೂಡಿಸಿತು. ಆದರೆ ನೂರೊಂದನೇ ಪ್ರಯೋಗವು ಮಾದರಿಯನ್ನು ಮುರಿಯುವ ಒಂದು ಸಾಂಖ್ಯಿಕ ಅಸಂಗತತೆಯಾಗಿದ್ದರೆ (statistical outlier), ನೂರಾರು ಪ್ರಯೋಗಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆಗೆ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ. ಸಿಸ್ಟಮ್ ಸುರಕ್ಷತೆಯಲ್ಲಿ, ವೈಫಲ್ಯದ ವಿಧಾನವು ಕ್ರಮೇಣ ಮತ್ತು ದೃಶ್ಯವಾಗಿದ್ದರೆ ಮಾತ್ರ ಹಿಂದಿನ ಕಾರ್ಯಕ್ಷಮತೆಯು ಮುಖ್ಯವಾಗುತ್ತದೆ. AI ಏಜೆಂಟ್ ವೈಫಲ್ಯಗಳು ಹಠಾತ್, ಮೌನ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿರುತ್ತವೆ. "ಇದು ನೂರಾರು ಬಾರಿ ಕೆಲಸ ಮಾಡಿದೆ" ಎಂಬುದು ಸುರಕ್ಷತಾ ದಾಖಲೆಯಲ್ಲ. ಇದು ಅಂತಿಮವಾಗಿ ಮುಗಿದುಹೋಗುವ ಅದೃಷ್ಟದ ವಿವರಣೆಯಾಗಿದೆ.
ನೈಜ ರಕ್ಷಣೆಯನ್ನು ನಿರ್ಮಿಸುವುದು ಹೇಗೆ
ಮಾದರಿಯು ಸುರಕ್ಷತಾ ಪದರವಾಗದಿದ್ದರೆ