איך ללמוד פיתוח סוכני AI מאפס: מדריך מעשי

המסלול בשישה שלבים

כדי ללמוד סוכני AI מאפס, עבדו לפי סדר ששת השלבים הבאים: מושגי יסוד, הלולאה הראשונה שלכם, כלים, זיכרון, תכנון לולאות, ובטיחות. בכל שלב עליכם לבנות פרויקט קטן במו ידיכם. דילוג על שלבים הוא הסיבה הנפוצה ביותר לעצירה בתהליך הלמידה, כיוון שספריות עבודה (frameworks) מסתירות בדיוק את החלקים שחשוב להבין.

סוכן AI הוא לולאה סביב מודל שפה, המורשית להפעיל כלים. משפט זה הוא תמצית הנושא כולו. כל מה שבא אחריו הוא פירוט על המרכיבים בתוך הלולאה, על הגישה של הכלים למשאבים, ועל הדרך לעצור את הלולאה במקרה של תקלה. אם אתם מסוגלים להסביר את הלולאה לאדם אחר, סימן שלמדתם את הנושא. אם אתם יודעים רק לציין שמות של ספריות עבודה, לא למדתם.

התוכנית להלן מניחה שאתם לומדים דרך בנייה. קראו שלב, בנו את הפרויקט הקטן, גרמו לו לקרוס בכוונה, ורק אז המשיכו הלאה. שלב שרק קראתם עליו הוא שלב שלא ביצעתם.

מה באמת נדרש לפני שלב 1

רשימת הדרישות המוקדמות הכנה היא קצרה, ואף קצרה יותר ממה שרוב דפי הקורסים מציעים.

• אתם מסוגלים לקרוא ולכתוב ב-Python או ב-TypeScript ברמה של סקריפט בן חמישים שורות.
• אתם מרגישים בנוח ב-Linux shell: התקנת חבילה, עריכת קובץ, קריאת לוג.
• יש לכם API key עבור מודל מאוחסן, או מכונה שמסוגלת להריץ מודל מקומי.

זו הרשימה המלאה. אינכם זקוקים לתאוריה של למידת מכונה, ואינכם צריכים לאמן מודל. שום דבר בעבודה עם סוכנים (agents) לא כולל חישובי gradients או נתוני אימון. כרטיס גרפי רלוונטי רק אם תחליטו להריץ את המודל בעצמכם, מיומנות נפרדת שתוכלו לרכוש מאוחר יותר מתוך אירוח Ollama על גבי VPS להרצה עצמית של LLM.

מה שאנשים נוטים להמעיט בערכו הוא החלק של ה-shell. סוכנים נכשלים בגלל הרשאות, נתיבים, משתני סביבה ותהליכים שקורסים בשקט. אם stack trace שקשור ל-PATH או ל-file mode גורם לכם לסגור את הטרמינל, הקדישו סוף שבוע ללימוד יסודות Linux תחילה. זה יחסוך לכם חודש של עבודה בהמשך.

שלב 1: מהו סוכן (agent), ומה הוא לא

התחילו בקריאת API אחת ללא לולאה. שלחו prompt, הדפיסו את התשובה ובדקו את ספירת ה-tokens בתגובה. כעת אתם מבינים מהי יחידת העלות ומהי יחידת ה-latency.

לאחר מכן למדו שימוש בכלים (tool use), שזהו הרעיון החדש היחיד בתחום כולו. אתם מתארים פונקציה למודל כשם, תיאור ו-schema בפורמט JSON עבור הקלטים שלה. המודל לא מריץ דבר. הוא משיב בבקשה מובנית: קרא ל-run_command עם הארגומנטים האלה. הקוד שלכם מריץ את הפונקציה, שולח את הפלט בחזרה כהודעה, ושואל את המודל שוב. המודל הוא מתכנן שקורא טקסט וכותב טקסט. הקוד שלכם הוא הגורם המבצע.

צ'אט-בוט מסיים את פעולתו לאחר תשובה אחת. סוכן חוזר על חילופי הדברים האלה עד שהמודל מפסיק לבקש כלים. החזרה הזו היא כל ההבדל, וזו הסיבה לכך שגם אופני הכשל שונים. צ'אט-בוט נותן תשובה שגויה פעם אחת. סוכן פועל על בסיס תשובה שגויה מספר פעמים לפני שמישהו מבחין בכך.

שלב 2: כתיבת הלולאה בעצמכם, פעם אחת

אל תתחילו עם framework. כתבו כ-30 שורות של Python כדי שהמבנה של הדבר יהיה שלכם.

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

הריצו זאת עם python3 agent.py. הרצה תקינה מדפיסה פסקה אחת המציינת את מערכות הקבצים שלכם ואת השטח הפנוי בהן, כיוון שהמודל ביקש את df -h, הקוד שלכם הריץ זאת, והמעבר השני הפך את הטבלה למשפט. אם לא מודפס דבר, הלולאה הסתיימה לפני שהגיע בלוק טקסט. הוסיפו את print(response.stop_reason) בתוך הלולאה וצפו בערכים משתנים.

כעת, גרמו לשבירה מכוונת. מחקו את השורה tool_use_id וקראו את השגיאה, כיוון שתוצאת כלי ללא מזהה תואם נדחית על ידי ה-API, וזוהי שגיאת המתחילים הנפוצה ביותר שקיימת. שאלו שאלה הדורשת שתי פקודות וצפו בלולאה רצה פעמיים. שאלו משהו בלתי אפשרי וצפו בה מוותרת או רצה לנצח.

אזהרה אחת לגבי דוגמה זו. היא מעבירה פלט של מודל ישירות ל-shell עם shell=True, דבר המקובל במכונת ניסויים שניתן להקים מחדש, אך שגוי בכל מקום אחר. שלב 6 מתקן זאת. המושגים שמתחת ללולאה מכוסים בהרחבה ב-בניית סוכן AI משלכם על גבי VPS.

שלב 3: כלים שלא היו ברשות הסוכן מלכתחילה

הכלי run_command שלכם עובד, אך סוכן אמיתי זקוק לכלים שחורגים מגבולות המערכת המקומית: מערכת כרטיסים (ticket system), מסד נתונים או מאגר קוד. כתיבת מעטפת (wrapper) ייעודית לכל שירות, עבור כל סוכן, אינה ניתנת להרחבה.

התקן Model Context Protocol (MCP) הוא הפתרון שהתעשייה אימצה. שרת MCP חושף קבוצת כלים באמצעות פרוטוקול תעבורה סטנדרטי, וכל סוכן התומך ב־MCP יכול להשתמש בהם ללא צורך בקוד גישור מותאם אישית. שרת מערכת הקבצים (filesystem server) לדוגמה מופעל בפקודה אחת:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

פעולה זו דורשת התקנה של Node, וארגומנט הספרייה הוא הנתיב היחיד שהשרת יגש אליו. זהו מודל האבטחה על קצה המזלג: השרת הוא שקובע את הגבולות, לא המודל. הפנו לקוח (client) אל השרת, והסוכן שלכם יקבל יכולות קריאה וכתיבה של קבצים שלא נדרשתם לכתוב בעצמכם. הרצה תקינה של שרתים אלו, תחת חשבון שירות ועם בחירת אמצעי התעבורה המתאימים, מוסברת ב־הרצת שרתי MCP על גבי VPS עבור סוכני פיתוח מבוססי AI.

הלקח משלב זה הוא שתכנון הכלים הוא העבודה האמיתית. תיאור מעורפל גורם למודל לנחש. כלי שמחזיר ארבעים אלף תווים מרעיל את חלון ההקשר (context window). כלי שיש לו הרשאת מחיקה, סופו למחוק דברים.

שלב 4: זיכרון, שהוא ברובו פשוט קבצים

מתחילים נוטים לפנות בשלב זה למסד נתונים וקטורי (vector database). אל תעשו זאת, לפחות לא כרגע.

לסוכן (agent) אין זיכרון בין קריאות. אתם שולחים מחדש את כל השיחה בכל פעם, וזו הסיבה שסשן ארוך עולה יותר לכל תור מאשר סשן קצר. לכן, הזיכרון מתחלק לשתי בעיות. הראשונה היא מה שנכנס לחלון ההקשר (context window) ברגע זה, ואת זה אתם מנהלים באמצעות סיכום, קיצוץ פלט ישן של כלים, ושמירה במטמון (caching) של הקידומת הקבועה ב-prompt שלכם, כך שאתם משלמים רק חלק קטן מהעלות עבורה. השנייה היא מה ששורד אתחול, וזהו האחסון.

עבור הבעיה השנייה, קובץ markdown פשוט שהסוכן יכול לקרוא ולכתוב עדיף על מסד נתונים וקטורי עבור כמעט כל פרויקט ראשון. תנו לו קובץ אחד, הגדירו לו את הפורמט, והורו לו לקרוא את הקובץ לפני תחילת העבודה ולעדכן אותו כשהוא לומד משהו חדש. אתם מקבלים את רוב התועלת, ותוכלו לפתוח את הקובץ ולראות מה הסוכן שלכם "חושב". פנו לשימוש ב-embeddings ובשליפת מידע (retrieval) רק כאשר ההערות מפסיקות להיכנס לחלון ההקשר, ולא לפני כן.

שלב 5: הלולאה היא המוצר

בשלב זה אתם מסוגלים ליצור סוכן שעובד בזמן שאתם צופים בו. שלב 5 עוסק בהפיכתו לעובד גם כשאינכם צופים בו.

ארבע שאלות קובעות אם בטוח להשאיר סוכן ללא השגחה: מה מפעיל אותו, כדי שלא ירוץ ללא צורך; מהו גבול הגזרה שבו הוא פועל, כדי שכל טעות תישאר מוגבלת; כיצד מאומתת התוצאה, שכן סוכן שבודק את עבודת עצמו תמיד עובר; ואיזה תקציב עוצר אותו, במונחים של tokens או זמן שעון. תכנון מכוון של ארבעת אלו הוא המשמעת המתוארת ב-הנדסת לולאות, ומה הגדרה זו כוללת.

התרגיל: קחו את הסוכן משלב 2, תנו לו משימה הדורשת ארבעה או חמישה שלבים, והוסיפו מגבלה קשיחה על מספר האיטרציות. לאחר מכן, הסירו את המגבלה וצפו במה לולאה ללא הגבלה עושה לחשבון ה-tokens שלכם. בצעו זאת פעם אחת בתקציב קטן, כדי שלעולם לא תעשו זאת בטעות בתקציב גדול.

שלב 6: בטיחות, סודות ועלויות

שלב זה אינו אופציונלי, והוא מופיע אחרון רק משום שלא ניתן לחוש בסיכון עד שלא בונים משהו שעובד.

הריצו את ה-agent כמשתמש ללא הרשאות (unprivileged user), לעולם לא כ-root ולעולם לא תחת חשבון המשתמש שלכם, כך שרדיוס הפגיעה יוגבל לספרייה ולא למכונה כולה. הרחיקו אישורים (credentials) מהישג ידו של המודל, שכן כל מידע שנמצא ב-context window עלול להיפלט החוצה באמצעות קריאה לכלי (tool call). הפתרון הוא שימוש ב-tokens בעלי הרשאות מצומצמות וזמן חיים קצר מאחורי helper, כפי שמתואר ב-שמירה על סודות מחוץ ל-AI agents שלכם. הציבו תקרה קשיחה להוצאות, כיוון שלולאה שרצה ללא השגחה מחייבת על כל איטרציה מבלי שאיש יפקח עליה. המגבלות ומנגנוני ה-batching ששומרים על שפיות התהליך מפורטים ב-בקרת עלויות של AI agent ב-VPS שפועל ללא הפסקה.

נושא העלויות ראוי למספר קונקרטי אחד. נכון ליולי 2026, Claude Opus 5 מחייב ב-$5 למיליון input tokens וב-$25 למיליון output tokens, ו-agent פטפטן ששולח שוב ושוב שיחה הולכת וגדלה יכול להעביר כמה מאות אלפי tokens במשימה בודדת. שימוש ב-prompt caching ומודל קטן יותר עבור שלבים שגרתיים משנים את החישוב הזה הרבה יותר מכל שינוי ב-prompt.

גם הזרקת פקודות (prompt injection) שייכת לכאן. אם ה-agent שלכם קורא דף אינטרנט, מערכת ניהול משימות או תיבת דואר נכנס, הרי שמי שכתב את הטקסט הזה כותב למעשה הוראות עבור ה-agent שלכם. ההגנה אינה טמונה ב-system prompt חכם יותר, אלא בגבולות הגזרה; agent שאינו מורשה למחוק מאגר (repository) לא יוכל להשתכנע לעשות זאת.

באיזו תוכנית לימודים כדאי לבחור?

בחרו תוכנית לימודים אחת והשלימו אותה במקום לנסות שש תוכניות במקביל. המאגר ai-agents-for-beginners של Microsoft הוא המקיף ביותר מבין המשאבים החינמיים; זהו קורס בן 18 שיעורים שצבר למעלה מ-70,000 כוכבים נכון ליולי 2026, והוא תואם במדויק לשלבים שפורטו לעיל. סיכומים של מאגרי סוכנים (agents) פופולריים מועילים כדי להבין אילו פרויקטים קיימים, אך הם פחות מתאימים כסילבוס, שכן רשימה הממוינת לפי כוכבים משקפת פופולריות ולא סדר לימוד מומלץ.

כאשר אתם מחפשים פרויקט מעשי לתרגול, סוכן כתיבת קוד (coding agent) הוא היעד הראשון הטוב ביותר: המשוב הוא מיידי, הכלים ברורים, וקל מאוד לבטל טעויות. המדריך הרצת סוכן AI לכתיבת קוד על גבי VPS מלווה את התהליך מקצה לקצה. אם אתם מעדיפים ללמוד מערכות עובדות במקום לבנות מאפס, ההשוואה ב-סוכני ה-AI הטובים ביותר לאירוח עצמי מציגה כיצד פרויקטים שונים פותרים את אותו לולאת עבודה בדרכים שונות.

כמה זמן זה לוקח?

עבור מי שכבר עוסק בתכנות, שלבים 1 ו-2 ידרשו ערב אחד. שלב 3 יצריך סוף שבוע, שרובו יוקדש לתיאור הכלים ולא לפרוטוקול עצמו. שלבים 4 ו-5 דורשים כמה שבועות של שימוש מעשי, שכן לומדים מה הסוכן שוכח רק על ידי צפייה בו כשהוא שוכח. שלב 6 לעולם אינו מסתיים באמת, במובן זה שכל יכולת חדשה שמעניקים לסוכן פותחת אותו מחדש.

חודשיים של עבודה עקבית בערבים יביאו את רוב האנשים לסוכן עובד, מוגבל ושימושי. אלו שלוקח להם שנה הם בדרך כלל אלו שהמשיכו לקרוא במקום לבנות.

FAQ

האם עליי להכיר למידת מכונה כדי לבנות סוכן AI?

לא. בניית סוכן משמעותה קריאה למודל דרך API וחיבור בקשות הכלים שלו לפונקציות ממשיות, וזוהי תכנות יישומים רגיל. לעולם לא תיגע באימון, בגרדיאנטים או במערכי נתונים. הכישורים שקובעים אם הסוכן שלך יעבוד הם תכנון סכימות לכלים, טיפול בשגיאות והרשאות ב-Linux. תיאוריית למידת מכונה הופכת לרלוונטית רק אם תבחר לבצע fine-tuning למודל, שזהו תפקיד שונה עם דרישות קדם שונות.

האם כדאי להתחיל עם framework כמו LangChain או CrewAI?

כתוב תחילה לולאה גולמית אחת, ורק אז אמץ framework. ה-framework מחליף את שלושים השורות בשלב 2 באובייקט הגדרה, וזה נוח ברגע שאתה יודע מה הוא החליף, אך מבלבל לפני כן. כאשר הסוכן שלך מתנהג בצורה לא תקינה, עליך להסיק מסקנות ישירות מרשימת ההודעות ותוצאות הכלים, וזה הרבה יותר קשה אם מעולם לא ראית אותם. לאחר לולאה אחת משלך, ה-framework יחסוך לך זמן במקום להסתיר את המנגנון.

כמה עולה ללמוד סוכני AI?

פחות ממה שרוב האנשים מצפים, אם מציבים גבולות. מפתח API מאוחסן ו-VPS קטן מכסים את כל מה שנדרש בששת השלבים הללו. הסיכון האמיתי אינו התעריף השעתי, אלא לולאה בלתי מוגבלת שמחייבת אותך על כל איטרציה בזמן שאתה ישן. הגדר מגבלת הוצאה קשיחה בחשבון ה-API שלך ביום הראשון, הוסף מגבלת איטרציות לכל לולאה שאתה כותב, והשתמש במודל זול יותר עבור שלבים שגרתיים. הרצת המודל באופן מקומי מבטלת את החיוב על טוקנים ומחליפה אותו בדרישות חומרה.

מה ההבדל בין סוכן AI לבין צ'אטבוט?

צ'אטבוט עונה פעם אחת. סוכן חוזר על מחזור פעולה: המודל מבקש כלי, הקוד שלך מריץ אותו, התוצאה חוזרת, והמודל מחליט מה לעשות הלאה. החזרה הזו היא שמאפשרת לסוכן לסיים משימה בת כמה שלבים, וזו גם הסיבה שסוכנים זקוקים לגבולות שצ'אטבוטים אינם זקוקים להם. תשובה שגויה מצ'אטבוט היא פסקה גרועה. תשובה שגויה מסוכן היא פסקה גרועה בתוספת כל פעולה שהוא ביצע בעקבותיה.