6. דחיסת הקשר

הבעיה

חלון ה-context מוגבל. read_file יחיד על קובץ של 1000 שורות עולה ~4000 טוקן. אחרי קריאת 30 קבצים והרצת 20 פקודות bash, מגיעים ל-100,000+ טוקן. הסוכן לא יכול לעבוד על codebases גדולים ללא דחיסה.

הפתרון

שלוש שכבות, בעוצמה עולה:

Every turn:
+------------------+
| Tool call result |
+------------------+
        |
        v
[Layer 1: micro_compact]        (silent, every turn)
  Replace tool_result > 3 turns old
  with "[Previous: used {tool_name}]"
        |
        v
[Check: tokens > 50000?]
   |               |
  yes              no
   |               |
   v               +--- continue normally
[Layer 2: mid_compact]
  Summarize assistant messages
  Keep only last 5 tool results
   |
   v
[Check: tokens > 80000?]
   |               |
  yes              no
   |               +--- continue
   v
[Layer 3: hard_compact]
  Call LLM to write a dense summary
  Replace entire history with summary
  Inject <identity> reminder

איך זה עובד

1. שכבה 1 — דחיסת micro רצה בשקט בכל סיבוב. תוצאות כלים ישנות מיותר מ-3 סיבובים הופכות למציין מקום של שורה אחת.

def micro_compact(messages: list) -> list:
    compacted = []
    for i, msg in enumerate(messages):
        if msg["role"] == "user" and isinstance(msg["content"], list):
            age = len(messages) - i
            if age > 6:  # older than 3 turns (user+assistant pairs)
                new_content = []
                for block in msg["content"]:
                    if block.get("type") == "tool_result":
                        tool_name = block.get("_tool_name", "tool")
                        new_content.append({
                            "type": "tool_result",
                            "tool_use_id": block["tool_use_id"],
                            "content": f"[Previous: used {tool_name}]",
                        })
                    else:
                        new_content.append(block)
                compacted.append({**msg, "content": new_content})
                continue
        compacted.append(msg)
    return compacted

2. שכבה 2 — דחיסת mid מופעלת כשספירת הטוקנים עוברת 50,000. היא שומרת את פרומפט המערכת, את 5 תוצאות הכלים האחרונות במלואן, ומסכמת את השאר.

def count_tokens(messages: list) -> int:
    text = json.dumps(messages)
    return len(text) // 4  # rough estimate: 4 chars ≈ 1 token

def maybe_compact(messages: list) -> list:
    tokens = count_tokens(messages)
    if tokens > 80000:
        return hard_compact(messages)
    if tokens > 50000:
        return mid_compact(messages)
    return micro_compact(messages)

3. שכבה 3 — דחיסת hard מבקשת מה-LLM עצמו לכתוב סיכום צפוף של מה שקרה, ואז מחליפה את כל ההיסטוריה בסיכום הזה בתוספת תזכורת זהות.

def hard_compact(messages: list) -> list:
    summary_prompt = (
        "Summarize the conversation so far. Include: "
        "what the user asked, what tools you used, "
        "what you found, what's left to do. Be dense."
    )
    summary_messages = messages + [{"role": "user", "content": summary_prompt}]
    response = client.messages.create(
        model=MODEL, system=SYSTEM,
        messages=summary_messages, max_tokens=2000,
    )
    summary = response.content[0].text
    return [
        {"role": "user", "content": f"<context_summary>\n{summary}\n</context_summary>"},
        {"role": "assistant", "content": "Understood. Continuing from the summary."},
    ]

מה השתנה מ-מיומנויות

מסקנה מרכזית

דחיסת ה-context היא מה שהופך סוכנים עם ריצה ארוכה לאפשריים מעשית. האסטרטגיה התלת-שכבתית היא פרוגרסיבית: עשה את הדבר הזול ביותר קודם (micro), הסלם רק כשצריך (mid), ובתור מוצא אחרון בקש מהמודל לסכם את עצמו (hard). קוד הלולאה כמעט לא משתנה — רק עטפו את messages דרך maybe_compact() לפני כל קריאת LLM.