Agent Harness מ-0 ל-100: למה אותו מודל בדיוק קפץ 25 מקומות בדירוג

הסיפור שמסביר הכל: אותו מודל, קפיצה של 25 מקומות

בואו נתחיל מהמספר שהפך את המונח Agent Harness ללהיט של 2026. צוות LangChain לקח מודל אחד, לא נגע במשקלים שלו אפילו לרגע, ורק שינה את מה שעוטף אותו - את ה-harness. הציון שלו במבחן Terminal-Bench 2.0 (מבחן שבודק כמה טוב סוכן AI מתפעל טרמינל אמיתי) קפץ מ-52.8% ל-66.5%. אותו מודל בדיוק עלה מחוץ למקום ה-30 ישר לחמישייה הראשונה - רק כי שינו את ה"רתמה" סביבו, לא את המוח.

מה זה בכלל Agent Harness, למה כולם פתאום מדברים עליו, ולמה זה - ולא המודל - מה שקובע אם הסוכן שלנו יעבוד או יתפרק? היום נפרק את זה מ-0 ל-100. נלווה את כל הדרך בדוגמה אחת קטנה: סוכן שאני קורא לו "אנליסט הטוקנים", שכל תפקידו לענות על שאלה אמיתית מחדר החדשות שלנו - כמה יותר יקר להריץ עברית מול אנגלית. נבנה אותו קודם בלי שום כלים, ואז נראה איך הוא נראה בכל הספריות הגדולות (ה-frameworks), ואיך פורסים אותו לפרודקשן ב-AWS וב-GitHub.

אז מה זה בכלל סוכן AI - האנטומיה

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

סוכן AI הוא מודל שפה ששמנו אותו בתוך לולאה שנותנת לו ידיים - כלים לפעול בעולם - וגורמת לו לחזור על עצמו עד שהמשימה נגמרת. זו ההגדרה במילים של AWS עצמם: "סוכן LLM מריץ כלים בלולאה כדי להשיג מטרה". הלב של הסיפור הוא המילה לולאה.

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

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

• המוח (המודל): מקבל החלטות, מנסח מחשבות.
• ההוראות (system prompt): מי הוא, מה מותר, ואיך להתנהג.
• הכלים (tools): הפעולות שהוא יכול לבצע - להריץ קוד, לחפש, לקרוא קובץ.
• הזיכרון (context): מה הוא יודע ברגע הזה, וגם מה שהוא זוכר משיחות קודמות.
• הלולאה (the loop): המנוע שמחבר את הכל ומריץ שוב ושוב.

הסוכן הכי פשוט בעולם - בלי שום framework

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

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

import anthropic, subprocess
client = anthropic.Anthropic()

# כלי אחד: הרצת קוד פייתון. זה כל ה"ידיים" שנתנו לסוכן.
TOOLS = [{
    "name": "run_python",
    "description": "Run a Python snippet, return stdout.",
    "input_schema": {"type": "object",
        "properties": {"code": {"type": "string"}}, "required": ["code"]},
}]

def run_python(code):
    r = subprocess.run(["python3", "-c", code], capture_output=True, text=True)
    return r.stdout or r.stderr

messages = [{"role": "user",
    "content": "Measure how many more tokens Hebrew costs vs English, then explain."}]

while True:                                    # <<< הלולאה הזאת = ה-harness
    resp = client.messages.create(
        model="claude-opus-4-8", max_tokens=1024,
        tools=TOOLS, messages=messages)
    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":         # המודל סיים -> יש תשובה
        print(resp.content[-1].text); break

    for block in resp.content:                 # המודל ביקש כלי -> מריצים
        if block.type == "tool_use":
            result = run_python(block.input["code"])
            messages.append({"role": "user", "content": [{
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result}]})

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

עכשיו נבין: מה זה harness (ולמה המילה מבלבלת)

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

הבלבול נולד כי אותה מילה משמשת לחמישה דברים שונים לגמרי. בואו נעשה סדר - זה בעיניי החלק הכי חשוב בכתבה:

וההבחנה שצריך לזכור: הסוכן הוא ההתנהגות, ה-harness הוא המנוע. המודל מתחלף כל כמה חודשים, אבל ה-harness הוא מה שאנחנו באמת מהנדסים - ושם, לפי המדידות, יושבים כ-70% מהביצועים של הסוכן. בדיוק בגלל זה LangChain הצליחו לקפוץ 25 מקומות בלי לגעת במודל.

(האטימולוגיה, למי שאוהב: מרתמת-סוס, למונח test harness בתוכנה - עטיפה שמריצה קוד ובודקת אותו אוטומטית, ל-ML evaluation harness שמריץ מודלים על מבחנים, ומשם ל-agent harness של היום.)

אותו סוכן, ארבעה ניבים

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

# 1) Claude Agent SDK - הספרייה שמריצה את Claude Code עצמו
from claude_agent_sdk import query, ClaudeAgentOptions
async for msg in query(
        prompt="Measure Hebrew vs English token cost, then explain.",
        options=ClaudeAgentOptions(allowed_tools=["Bash"])):
    print(msg)

# 2) AWS Strands - ה-framework הפתוח של AWS (מריץ גם את AgentCore)
from strands import Agent
from strands_tools import python_repl
agent = Agent(model="us.anthropic.claude-opus-4-8-v1:0", tools=[python_repl])
agent("Measure Hebrew vs English token cost, then explain.")

# 3) LangChain / LangGraph - ה-prebuilt המודרני
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic
from langchain_experimental.tools import PythonREPLTool
agent = create_react_agent(ChatAnthropic(model="claude-opus-4-8"),
                           tools=[PythonREPLTool()])
agent.invoke({"messages": [("user", "Measure Hebrew vs English token cost.")]})

# 4) GitHub Copilot SDK - מטמיע את ליבת-הסוכן של Copilot בכל אפליקציה
from copilot import CopilotClient
from copilot.tools import define_tool
from pydantic import BaseModel, Field

class RunParams(BaseModel):
    code: str = Field(description="Python code to run")

@define_tool(description="Run Python, return stdout")
async def run_python(params: RunParams) -> str: ...

client = CopilotClient(); await client.start()
session = await client.create_session(tools=[run_python], model="auto")
print((await session.send_and_wait("Measure Hebrew vs English token cost.")).data.content)

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

• ה-Claude Agent SDK הוא הספרייה שמריצה את Claude Code עצמו.
• ה-Strands הוא ה-framework הפתוח של AWS.
• ה-LangGraph הוא הגרסה המודרנית של LangChain.
• ה-Copilot SDK של GitHub מטמיע את אותה ליבת-סוכן שמריצה את Copilot CLI בתוך כל אפליקציה שלנו.

למה צריך לדאוג כשבונים סוכנים

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

• פיצוץ קונטקסט (context rot): ככל שהלולאה רצה, השיחה תופחת עד שהמודל מתחיל לשכוח את ההתחלה או להתבלבל. צריך לנהל את הזיכרון, לא לתת לו לגלוש.
• לולאות אינסופיות (doom loops): הסוכן נתקע ומנסה שוב ושוב את אותו דבר שנכשל. LangChain פתרו את זה עם middleware - שכבת ביקורת שמזהה את הדפוס ועוצרת אותו.
• פיצוץ עלות: סוכן שולח עשרות קריאות למודל למשימה אחת, וכל אחת עולה טוקנים. בעברית זה כואב כפליים - כמו שמדדנו בחדר החדשות, מילה בעברית שוקלת בערך פי ארבעה טוקנים ממילה באנגלית, אז סוכן שרץ בעברית עולה יותר מאותו סוכן באנגלית.
• אבטחה: סוכן עם גישה לכלים אמיתיים הוא גם משטח תקיפה. הסכנה הקלאסית נקראת prompt injection - טקסט זדוני שהסוכן קורא (למשל מדף אינטרנט) ומתייחס אליו כאל פקודה. שילוב מסוכן במיוחד: גישה לנתונים רגישים, יחד עם קריאת תוכן חיצוני, יחד עם יכולת לשלוח מידע החוצה.
• אימות: האם מה שהסוכן טוען שהוא עשה זה מה שבאמת קרה? צריך לבדוק את התוצאה, לא להאמין לסיכום שלו.

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

זיכרון: קצר טווח מול ארוך טווח

זיכרון של סוכן מגיע בשתי צורות, ומבלבלים ביניהן הרבה.

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

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

כלים שבאמת עושים דברים

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

• מפרש קוד (code interpreter): המודל כותב קוד ומריץ אותו באמת, ומקבל תוצאה - בדיוק מה שאנליסט הטוקנים שלנו עושה.
• טרמינל (shell): גישה לשורת פקודה כדי להריץ פקודות מערכת.
• מערכת קבצים (filesystem): לקרוא, לכתוב ולערוך קבצים.
• דפדפן (browser): לגלוש, ללחוץ ולמלא טפסים באתרים אמיתיים.
• MCP (ר"ת Model Context Protocol): פרוטוקול אחיד לחיבור כלים לסוכן, כמו USB לכלים. במקום לכתוב מחדש חיבור לכל שירות, מחברים MCP והסוכן מקבל את הכלים.

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

וגם סקילים: ידע לפי דרישה (וזה לא כלי)

עד עכשיו דיברנו על כלים - פעולות שהסוכן מריץ. אבל יש שכבה שנייה שמבלבלים איתה המון: סקילים. כלי הוא יד שעושה משהו (מריץ קוד, פותח קובץ), אבל סקיל הוא חבילת ידע שמלמדת את הסוכן איך לעשות משהו - קובץ SKILL.md עם הוראות, שנטען רק כשצריך אותו.

המנגנון נקרא progressive disclosure (חשיפה הדרגתית): במקום להעמיס את כל ההוראות על הקונטקסט, נכנסים מראש רק כ-100 טוקנים של תיאור ("מה הסקיל הזה יודע"), והתוכן המלא נטען רק כשהסוכן מחליט שהוא רלוונטי - דרך קריאת כלי. כלומר סקיל וכלי לא מתחרים: הסוכן מריץ כלים, וטוען סקילים דרך כלי, שניהם יחד.

והנה מה שעונה בול על השאלה "האם זה נתמך": כל שלושת ה-harnesses תומכים בסקילים, וכולם משתמשים באותו תקן פתוח - AgentSkills.io, אותו SKILL.md בדיוק:

• AgentCore - מצרפים סקילים מקטלוג AWS המובנה, מ-Git (כל ריפו), מ-S3 או מהדיסק, לצד הכלים.
• Copilot SDK - מעבירים skill_directories ל-create_session לצד ה-tools. Copilot תומך ב-Agent Skills מדצמבר 2025.
• Strands - יש plugin רשמי (AgentSkills) שקורא SKILL.md עם אותה חשיפה הדרגתית.

# ---- AgentCore: מצרפים סקיל מ-Git / S3 / קטלוג AWS (לצד הכלים) ----
agentcore add skill --harness token-analyst \
  --git https://github.com/hoodini/ai-agents-skills --git-path skills/aws-harness
#   SDK - אפשר לשלב כמה מקורות יחד:
#   client.invoke_harness(harnessArn=ARN, runtimeSessionId=SID,
#     skills=[{"awsSkills": {"paths": ["core-skills/*"]}},
#             {"git": {"url": "https://github.com/anthropics/skills", "path": "skills/docx"}}])

# ---- Copilot SDK: skill_directories לצד tools ----
session = await client.create_session(
    tools=[run_python],                          # כלים = ידיים
    skill_directories=["./skills/aws-harness"],   # סקילים = ידע לפי דרישה
    model="auto")

# ---- Strands: ה-plugin הרשמי AgentSkills קורא SKILL.md ----
# from strands.vended_plugins.skills import agent_skills   # אותו SKILL.md, אותה חשיפה הדרגתית

וזאת בדיוק הסיבה שהסקילים שבניתי (aws-strands ו-aws-harness, מהריפו החינמי שלי github.com/hoodini/ai-agents-skills) עובדים בכל מקום: הם SKILL.md בתקן הפתוח, אז אפשר לטעון אותם ב-Claude Code, ב-Copilot וב-Cursor, ואפילו לצרף אותם ישירות ל-AgentCore דרך Git. כותבים פעם אחת, רצים בכל סוכן.

איך כותבים סקיל משלכם (התבנית המלאה)

ולמי שרוצה לבנות סקיל בעצמו - זה פשוט להפליא, וזו הנקודה שהופכת את זה למדריך אמיתי. סקיל הוא בסך הכל תיקייה עם קובץ SKILL.md אחד: כותרת YAML עם שם ותיאור, ואז הוראות ב-Markdown. אפשר לצרף תיקיות scripts/ (סקריפטים שהסוכן יריץ), references/ (חומר רקע) ו-assets/ (קבצים). והקטע החזק: סקיל יכול לארוז בתוכו סקריפט, וההוראות פשוט אומרות לסוכן "הרץ את scripts/measure.py" - ככה סקיל אחד מפעיל כלי מתוכו, ומחבר ידע (מתי ואיך) עם פעולה (הסקריפט עצמו).

hebrew-token-tax/
├── SKILL.md          # ההוראות + המטא-דאטה
└── scripts/
    └── measure.py     # כלי שהסקיל אורז בתוכו

# ===== SKILL.md =====
---
name: hebrew-token-tax
description: Measure how many more tokens Hebrew costs vs English for a given text. Use when asked about Hebrew token cost, tokenizer overhead, or pricing in Hebrew.
---

# Hebrew Token Tax

When the user asks about Hebrew token cost:
1. Run `python3 scripts/measure.py "<the text>"` to get the exact counts.
2. Report Hebrew tokens, English tokens, and the ratio.
3. If the ratio is above 3x, note Hebrew was trained on less data.

# ===== scripts/measure.py =====
import sys, tiktoken
enc = tiktoken.get_encoding("o200k_base")
print(len(enc.encode(sys.argv[1])), "tokens")

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

OpenClaw ו-Hermes: למה הם תפסו

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

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

השני, Hermes של Nous Research, תפס מזווית אחרת: ה-harness שמשתפר לבד. הוא "גדל איתנו" - יוצר לעצמו מיומנויות מתוך משימות שהצליחו, זוכר עובדות בין שיחות, ומחפש בעצמו בהיסטוריה שלו. בנוסף הוא בקוד פתוח ברישיון MIT, הנתונים נשארים מקומיים אצלנו, וזה נתן למשתמשים בעלות מלאה על המערכת שלהם.

ההבדל ביניהם, כמו שניסחו יפה ב-The New Stack: שניהם מסכימים מה זה סוכן, וחלוקים על מי שולט בו - OpenClaw שם את השליטה בקונפיג, ו-Hermes שם אותה בלמידה העצמית של הסוכן.

של מי יש harness - מפת הנוף

בואו נמפה את כל מי שכולם מזכירים, לפי חמשת החושים מלמעלה:

• מוצרים מוגמרים (harness שמריצים): Claude Code, Codex CLI, GitHub Copilot CLI.
• SDKs (harness שמטמיעים בקוד): Claude Agent SDK, AWS Strands, GitHub Copilot SDK, LangGraph.
• שירותים מנוהלים (harness כתשתית): AWS AgentCore Harness, OpenClaw.
• זירות מדידה (harness שמקבעים כדי למדוד): SWE-bench, Terminal-Bench, וה-benchmark של GitHub Copilot.

מהתיאוריה לפרודקשן: קודם, מה זה בכלל "Copilot harness"

לפני שנבנה, בואו נסדר בלבול נפוץ, ובצדק. כשאומרים "Copilot harness" מתכוונים ל-Copilot CLI - הסוכן שרץ בטרמינל של GitHub, שהמנוע שלו (הלולאה, הכלים, ניהול הקונטקסט) הוא בדיוק ה-harness. וה-CLI הזה לא חדש: הוא יצא ל-public preview בספטמבר 2025 והגיע ל-GA בפברואר 2026.

מה שחדש יותר הוא ה-Copilot SDK - ספרייה בקוד פתוח שלוקחת את אותו מנוע של ה-CLI וחושפת אותו בקוד, בשש שפות. גם הוא לא נולד ביוני: technical preview בינואר 2026, public preview באפריל, ורק חותמת ה-GA שלו היא מ-2 ביוני 2026. אז "Copilot harness" הוא המנוע של Copilot CLI (ותיק, מ-2025), וה-SDK הוא רק הדרך התכנותית לתפוס את אותו מנוע - לא מוצר חדש, אלא גישה חדשה לאותו דבר. במילים של GitHub עצמם: ה-SDK לוקח את הכוח הסוכני של Copilot CLI - התכנון, השימוש בכלים, ולולאת הריצה הרב-תורית - והופך אותו לזמין בשפת התכנות האהובה עלינו.

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

מסלול AWS: אנליסט הטוקנים ב-AgentCore Harness, צעד אחר צעד

נתחיל מ-AWS. הרעיון: אנחנו לא כותבים שרת, לא מנהלים בידוד, ולא בונים זיכרון - רק מצהירים מה הסוכן צריך, ו-AgentCore מרים את כל השאר.

• התקנה (דורש Node.js 20 ומעלה): הפקודה npm install -g @aws/agentcore.
• יצירה: הפקודה agentcore create --name token-analyst --model-provider bedrock. אפשר גם בלי דגלים, ואז אשף אינטראקטיבי שואל: שם הפרויקט, סוג (Harness), ספק המודל, סביבה, זיכרון, והגדרות מתקדמות. אם לא בוחרים מודל, ברירת המחדל היא Claude Sonnet 4.6 על Bedrock.
• מה קרה מתחת למכסה: ברגע הזה AgentCore כבר הקצה לנו זיכרון מנוהל (אסטרטגיות SEMANTIC + SUMMARIZATION, תפוגה של 30 יום) וסביבת הרצה מבודדת - בלי שכתבנו שורת תשתית אחת.
• הכלי: אנליסט הטוקנים צריך להריץ קוד, ו-AgentCore נותן code interpreter מובנה (וגם דפדפן), אז מספיק להפעיל אותו בקונפיג במקום לכתוב sandbox בעצמנו.
• דיפלוי: הפקודה agentcore deploy.
• הרצה: הפקודה agentcore invoke עם --session-id (חייב 33 תווים ומעלה, למשל uuid). התשובה זורמת לטרמינל בזמן אמת.

# 1) התקנה (דורש Node.js 20+)
npm install -g @aws/agentcore

# 2) יצירה - שם + ספק מודל. בלי --model = Claude Sonnet 4.6 על Bedrock (ברירת מחדל)
agentcore create --name token-analyst --model-provider bedrock
#    -> מרים אוטומטית: זיכרון מנוהל (SEMANTIC+SUMMARIZATION, 30 יום) + microVM מבודד

# 3) דיפלוי
agentcore deploy

# 4) הרצה - session-id חייב 33+ תווים. אותו id = אותה שיחה + אותו זיכרון
agentcore invoke --harness token-analyst --session-id "$(uuidgen)" \
  "How many more tokens does Hebrew cost than English? Measure it with code."

# --- אותו דבר דרך boto3 (SDK), עם זיכרון פר-משתמש דרך actorId: ---
#   import boto3
#   c = boto3.client("bedrock-agentcore", region_name="us-west-2")
#   r = c.invoke_harness(harnessArn=ARN, runtimeSessionId=SID, actorId="user-123",
#         messages=[{"role":"user","content":[{"text":"Measure the Hebrew token tax."}]}])
#   for e in r["stream"]:
#       d = e.get("contentBlockDelta", {}).get("delta", {})
#       if "text" in d: print(d["text"], end="")

ופה החלק המדליק - הזיכרון. בכל הרצה עם אותו session-id, AgentCore טוען לבד את היסטוריית השיחה לפני שהסוכן חושב, גם אחרי שה-microVM כבר נסגר והוחלף. אנחנו לא שולחים בחזרה את ההודעות הקודמות, רק את ההודעה החדשה - ה-harness זוכר בשבילנו. רוצים זיכרון נפרד לכל משתמש? מוסיפים actorId="user-123" בקריאה, וכל משתמש מקבל זיכרון קצר-וארוך-טווח מבודד. וכשהשיחה גדלה מעבר לחלון הקונטקסט, ה-harness מקצץ אוטומטית (ברירת מחדל sliding_window ששומרת את ההודעות האחרונות, או summarization שמסכמת את הישנות).

מתחת למכסה של AgentCore: מודלים, כלים, הרשאות ומעקב

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

קודם הדרישות המקדימות. כדי להתחבר ל-AWS צריך: חשבון AWS עם aws configure (מפתחות גישה), הפעלת גישה למודל ב-Bedrock (למשל Claude, באזור שבחרנו), ו-Python 3.10 ומעלה. ל-CLI צריך בנוסף Node.js 20 ומעלה ו-AWS CDK (מריצים cdk bootstrap פעם אחת לחשבון). וחשוב מכל: IAM execution role - תפקיד הרשאות ש-AgentCore "לובש" כדי לפעול בשמנו.

עכשיו תפקיד המודל. המודל הוא המוח שמחליט: בכל סבב בלולאה הוא בוחר אם לקרוא כלי ואיזה - אנחנו לא מתכנתים את ההחלטות, רק נותנים לו כלים ומטרה. ואילו מודלים אפשר? הרבה: Bedrock (Claude, Nova, Llama), OpenAI (דרך Bedrock Mantle בלי מפתח, או ישירות עם מפתח), Gemini, וכל מודל שנתמך ב-LiteLLM. ברירת המחדל היא Claude Sonnet 4.6, ואפשר אפילו להחליף מודל באמצע אותה שיחה - הקונטקסט עובר איתנו.

והכלים - כאן היופי: הם דקלרטיביים. אנחנו רק מצהירים מה מותר לסוכן, ו-AgentCore מטפל בהרצה, בהרשאות ובתוצאה. יש חמישה סוגים - שרת MCP, AgentCore Gateway, דפדפן, code interpreter, ופונקציה inline (שרצה אצלנו בצד הלקוח, לאישורי אנוש) - וגם shell ו-file_operations מובנים בכל סשן. לאנליסט הטוקנים שלנו מספיק code interpreter אחד.

# דרישות מקדימות: aws configure + הרשאת מודל ב-Bedrock + IAM execution role

# מודל: ברירת מחדל Claude Sonnet 4.6. אפשר להחליף ספק (גם באמצע שיחה):
agentcore add harness --name token-analyst \
  --model-provider bedrock --model-id us.anthropic.claude-opus-4-5-20251101-v1:0
#   OpenAI דרך Bedrock Mantle (בלי מפתח): --model-provider open_ai --model-id gpt-5.4 --api-format responses
#   Gemini / כל LiteLLM:                  --model-provider lite_llm --model-id gemini/gemini-2.5-pro --api-key-arn <arn>

# כלים דקלרטיביים - מוסיפים רק מה שצריך. לאנליסט מספיק code interpreter:
agentcore add tool --harness token-analyst --type agentcore_code_interpreter --name code-interpreter
#   שרת MCP:               --type remote_mcp --name exa --url https://mcp.exa.ai/mcp
#   פונקציית-אנוש (אישור):  --type inline_function --name approve ...
#   הגבלת כלים למודל:       agentcore invoke --allowed-tools "code_interpreter" ...

# מגבלות משאבים - שסוכן משתולל לא ישרוף כסף:
agentcore add harness --name token-analyst \
  --max-iterations 50 --timeout 1800 --max-tokens 8192 --truncation-strategy sliding_window
agentcore deploy

# מעקב טוקנים ו-traces (אוטומטי ב-CloudWatch, בלי הגדרה):
agentcore logs   --harness token-analyst --since 1h --level error
agentcore traces list --harness token-analyst

ומה עם הרשאות, משאבים ומעקב - בדיוק מה ששאלנו עליו:

• הרשאות: ה-execution role קובע מה הסוכן רשאי לגעת בו ב-AWS, ו-allowedTools מגביל אילו כלים המודל יכול לבחור. מפתחות API של ספקים חיצוניים נשמרים ב-AgentCore Identity (token vault), והסוכן אף פעם לא רואה אותם בקוד.
• ניהול משאבים: שמים תקרות קשות כדי שסוכן משתולל לא ישרוף כסף - maxIterations (ברירת מחדל 75 סבבים), timeoutSeconds (3600 שניות), maxTokens, ותפוגת ה-microVM. אפשר להגדיר פעם אחת או לדרוס בכל הרצה.
• מעקב טוקנים: כל הרצה מייצרת אוטומטית traces, logs ו-metrics ב-CloudWatch (כולל שימוש-הטוקנים בכל צעד), בלי הגדרה. שולפים עם agentcore logs ו-agentcore traces, או מדשבורד AgentCore Observability.

מסלול GitHub: אנליסט הטוקנים ב-Copilot SDK, צעד אחר צעד

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

• התקנה: הפקודה pip install github-copilot-sdk (או npm install @github/copilot-sdk).
• כלי: מגדירים אותו כפונקציית פייתון עם דקורטור @define_tool וסכימת פרמטרים ב-Pydantic - זה מה שמריץ את הקוד עבור האנליסט.
• לקוח וסשן: יוצרים CopilotClient, קוראים ל-start, ופותחים סשן עם create_session - שם נותנים את הכלים, את המודל, ואת מדיניות ההרשאות (מי מאשר הרצת פעולות).
• הרצה: קוראים ל-send_and_wait, והתשובה חוזרת ב-response.data.content. הסשן שומר את ההקשר בין תורות, אז אפשר להמשיך לשאול בו.
• מתחת למכסה: ה-SDK לא הריץ מודל בעצמו - הוא הפעיל את אותה לולאת-סוכן של Copilot CLI, כש-GitHub מטפל בהזדהות, בבחירת המודל (אוטומטית מ-20+ מודלים, או BYOK), ב-MCP ובסשן.

# 1) התקנה:  pip install github-copilot-sdk   (או: npm install @github/copilot-sdk)
import asyncio, subprocess
from copilot import CopilotClient
from copilot.tools import define_tool
from copilot.session import PermissionHandler
from pydantic import BaseModel, Field

# 2) הכלי - פונקציה עם @define_tool + סכימת Pydantic
class RunParams(BaseModel):
    code: str = Field(description="Python code to run")

@define_tool(description="Run Python, return stdout")
async def run_python(params: RunParams) -> str:
    r = subprocess.run(["python3", "-c", params.code], capture_output=True, text=True)
    return r.stdout or r.stderr

async def main():
    # 3) לקוח + סשן (כלים, מודל, מדיניות הרשאות)
    client = CopilotClient()
    await client.start()
    session = await client.create_session(
        tools=[run_python], model="auto",          # או מודל ספציפי / BYOK
        on_permission_request=PermissionHandler.approve_all)

    # 4) הרצה - הסשן זוכר את ההקשר בין תורות
    r1 = await session.send_and_wait(
        "How many more tokens does Hebrew cost than English? Measure it.")
    print(r1.data.content)
    r2 = await session.send_and_wait("And for a 500-word article?")  # אותו סשן
    print(r2.data.content)
    await client.stop()

asyncio.run(main())

ההבדל המהותי: ב-AgentCore הזיכרון והבידוד הם שירות ענן מנוהל שחי גם כשהאפליקציה שלנו כבויה; ב-Copilot SDK הסשן חי בתוך התהליך של האפליקציה שלנו, ו-GitHub מנהל את השכבה הסוכנית. שניהם מריצים את אותה לולאה - רק ה"איפה" שונה.

האם הם משתלבים? כן, ו-MCP הוא הגשר

השאלה הכי טובה: אפשר לשלב? התשובה חיובית, ודרך MCP - אותו פרוטוקול-כלים אוניברסלי שהכרנו. ל-AWS יש AgentCore MCP Server בקוד פתוח, שמחבר את עוזרי-הקוד (Claude Code, GitHub Copilot, Cursor, Amazon Q) ישירות ל-AgentCore, כך שאפשר לבנות, לפרוס ולבדוק סוכן AgentCore בשפה טבעית, מתוך העורך. כלומר Copilot לא מתחרה ב-AgentCore - הוא יכול להיות היד שכותבת ופורסת אליו.

ובכיוון השני, AgentCore Runtime יכול לארח כל סוכן או שרת MCP בקונטיינר משלנו, אז אפשר לעטוף סוכן Copilot SDK ולהריץ אותו על תשתית AgentCore. שורה תחתונה של השילוב: Copilot SDK הוא מנוע-הכתיבה-וההטמעה, AgentCore הוא תשתית-ההרצה-והזיכרון, והם נפגשים ב-MCP.

אז מה לבחור - יתרונות, חסרונות, וההחלטה שלכם

בעיניי ההחלטה פשוטה יותר משנדמה:

• צריך פרודקשן מנוהל - זיכרון מתמשך, בידוד לכל משתמש, ניטור, גרסאות ו-rollback, בלי לתחזק שרתים? זה AgentCore Harness.
• רוצים להטמיע סוכן קידוד בתוך אפליקציה או כלי משלכם, בשפה שלכם, על מנוע Copilot? זה Copilot SDK.
• רוצים את הטוב משניהם - Copilot ככלי שכותב ופורס, AgentCore כתשתית שמריצה? חברו אותם ב-MCP.

הקסם: שלושה סקילים שהופכים הכל למשפט אחד

ופה הדבר שהכי מרגש אותי. יש לי ריפו פתוח וחינמי, github.com/hoodini/ai-agents-skills, עם עשרות סקילים מוכנים שכל אחד מוזמן להשתמש בהם בחינם. וכדי שיהיה קל להתחיל דווקא עם AWS ו-AgentCore, בניתי שם שלושה סקילים ייעודיים שמלמדים את סוכן-הקוד שלכם (Claude Code, Copilot או Cursor) את כל השרשרת, כל אחד לפי תפקיד:

• רוצים לבנות סוכן? הסקיל aws-strands - ה-framework שהוא המוח, עם כלים ודפוסי ReAct.
• רוצים לפרוס אותו על AWS? הסקיל aws-harness - create, deploy ו-invoke ל-AgentCore, או עטיפת סוכן קיים.
• צריך לנהל חשבונות, IAM ו-billing? הסקיל aws-account-management - מסדר את התשתית וההרשאות שמתחת.

אחרי שמתקינים אותם בפקודת npx skills add אחת (למטה), לא צריך לזכור אף פקודה נוספת. פשוט אומרים לסוכן "תבנה סוכן אנליסט-טוקנים ב-Strands, ותפרוס אותו ל-AgentCore Harness עם זיכרון", והוא עושה את הכל לבד. שלושת הסקילים, יחד עם AgentCore MCP Server, הופכים את כל השלב-אחר-שלב שעברנו למשפט אחד בעברית.

# 1) התקינו את שלושת הסקילים שיצרתי - פקודה אחת עם npx skills (הכלי הפתוח של Vercel):
npx skills add hoodini/ai-agents-skills \
  --skill aws-strands --skill aws-harness --skill aws-account-management \
  -g -a claude-code -y     # -a github-copilot / cursor לסוכן אחר · -g גלובלי · -y בלי שאלות

# 2) העתיקו את הפרומפט הזה לסוכן שלכם (Claude Code / Copilot / Cursor):
#
#   Use aws-strands to build a "token-analyst" agent that measures how many
#   more tokens Hebrew costs than English (give it a code-interpreter tool and
#   short+long-term memory). Then use aws-harness to deploy it to AgentCore
#   Harness with max-iterations 50, and print the invoke command.
#
# 3) זהו. aws-strands בונה, aws-harness פורס, aws-account-management מסדר IAM.

שורה תחתונה

בעיניי, 2026 היא השנה שבה התעשייה הפסיקה לרדוף רק אחרי המודל הבא, והתחילה להנדס את ה-harness. הסיפור של LangChain הוא ההוכחה: אותו מודל, שינוי ברתמה בלבד, קפיצה של 25 מקומות. הביצועים חיים בעיקר מחוץ למודל. זה משחרר, כי על ה-harness יש לנו שליטה מלאה - הכלים, הזיכרון, הלולאה, הבידוד. ומצד שני זו אחריות, כי אותם כלים אמיתיים הם גם סיכון אמיתי.

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

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