Series 4 - Bài 5: Context Isolation vs Context Sharing

Context sharing trong multi-agent system là quyết định kiến trúc quan trọng nhất — và thường bị đưa ra mà không suy nghĩ kỹ.

Mặc định là share context — vì nó đơn giản. Nhưng shared context tạo ra implicit coupling mà bạn sẽ chỉ phát hiện khi hệ thống có vấn đề.

Hai extreme và thực tế

Full Isolation:

  Orchestrator: [Context O]
  Worker A:     [Context A] — riêng hoàn toàn
  Worker B:     [Context B] — riêng hoàn toàn

  Giao tiếp chỉ qua explicit message passing
  Worker A không biết Worker B đang làm gì

Full Sharing:

  [Shared Context]
      │││
   ┌──┘│└──┐
   │   │   │
  Orch  A   B

  Mọi agent đọc được mọi thứ

Reality: Somewhere in between
  Orchestrator giữ shared state
  Workers nhận explicit context packages
  Workers không truy cập trực tiếp nhau

Tại sao Isolation quan trọng

1. Context Pollution

Scenario:
  Worker A (Security Auditor) tìm thấy
  đoạn code có SQL injection risk.

  Worker A suy nghĩ (trong shared context):
  "Mã này rất nguy hiểm, khả năng cao
   toàn bộ service này có vấn đề security."

  Worker B (Backend Developer) đọc shared context:
  “Security auditor nói service có vấn đề lớn.”
  → Worker B bao giờ cũng do dự khi modify code
  → Over-cautious, đưa ra recommendations về security
     khi task là refactor lóc logic
  → Context của A ảnh hưởng decision của B theo cách
     không intentional

2. Implicit Coupling

Shared mutable state:

  shared_context = {
    files_analyzed: [],
    issues_found: [],
    recommendations: []
  }

  Worker A reads: files_analyzed (empty khi bắt đầu)
  Worker A writes: files_analyzed = ["a.ts", "b.ts"]

  Worker B reads: files_analyzed
  → Behavior của B phụ thuộc vào A đã chạy chưa
  → Race condition nếu A và B chạy parallel
  → B nếu đọc sai → wrong context → wrong result

3. Debugging phức tạp hơn

Với isolated context:
  Worker B output sai → inspect Worker B's context
  Context có thể reproduce được độc lập

Với shared context:
  Worker B output sai → inspect shared context
  Context có thể bị modify bởi A, C, orchestrator
  Khó reproduce mà không replay toàn bộ execution

Pattern: Isolated Workers với Explicit Handoff

                    [Orchestrator State]
                    {
                      task_plan: [...],
                      worker_results: {},
                      aggregated: null
                    }
                         │
              ┌─────────┴─────────┐
              │                   │
    [Worker A Context]    [Worker B Context]
    {
      task: {...},          task: {...},
      relevant_files: [...], relevant_files: [...],
      constraints: [...],   constraints: [...],
      // không có B's data   // không có A's data
    }

Handoff flow:
  Worker A xong → Return structured result
  Orchestrator nhận, validate, store trong orchestrator state
  Nếu B cần A's output:
    Orchestrator extract relevant parts từ A's result
    Package đưa vào B's context
    B nhận explicit package, không truy cập raw A output

Orchestrator là single source of truth và gateway cho mọi context sharing.

What to Share, What to Isolate

Share (qua orchestrator, explicit):
  Task results đã được validate
  Specific files cần để complete task
  User constraints và preferences
  Project-level context (stack, conventions)

Isolate (không share):
  Internal reasoning của mỗi agent
  Intermediate tool results
  Work-in-progress data
  Errors và failures của agent khác
    (trừ khi orchestrator quyết định relevant)

Shared Read-only vs Shared Mutable

Shared Read-only: An toàn hơn
  Project file tree (chỉ đọc)
  System conventions (chỉ đọc)
  Tool definitions (chỉ đọc)
  → Mọi agent thấy cùng content, không ai modify
  → Không có race condition
  → An toàn để share

Shared Mutable: Nguy hiểm
  issues_found list (ai cũng có thể thêm)
  files_modified tracking (đọc + ghi)
  shared workspace state
  → Race condition khi parallel
  → Corruption nếu không serialize access
  → Avoid hoặc duyù manage qua orchestrator

Trade-off: Isolation vs Convenience

Full isolation:
  + Dễ debug
  + Không có implicit coupling
  + Workers independent, dễ test
  - Orchestrator phải explicitly package context
  - Handoff overhead lớn hơn
  - Orchestrator có thể mất signal quan trọng khi package

Shared context:
  + Tiện, workers tự tìm context cần
  + ít handoff overhead
  - Implicit coupling
  - Race conditions khi parallel
  - Debug khó
  - Context pollution

Default: Isolation. Chỉ share khi explicitly cần và chỉ share read-only content.

Kết luận

• Context isolation là default đúng — workers không nên truy cập context của nhau.
• Orchestrator là gateway cho mọi context sharing — explicit, intentional, validated.
• Shared read-only là an toàn. Shared mutable là source of bugs.
• Context pollution: worker A's internal reasoning không nên influence worker B's behavior.
• Isolation làm debugging dễ hơn — mỗi worker context có thể inspect độc lập.
• Convenience của shared context không đáng với implicit coupling và race conditions.