Lobster & OpenProse — Bộ Đôi Kiểm Soát Quy Trình Trong OpenClaw

Dành cho ai: Người dùng OpenClaw đang xây dựng các quy trình tác nhân phức tạp và muốn hiểu đúng vai trò của từng công cụ trước khi thiết kế hệ thống.

Mục lục

1. Vấn đề mà cả hai cùng giải quyết
2. Lobster — Vỏ Chạy Quy Trình Tất Định
3. OpenProse — Ngôn Ngữ Điều Phối Phiên AI
4. Sai Lầm Phổ Biến: Dùng Lobster Một Mình Cho Tất Cả
5. Phân Chia Vai Trò Đúng
6. Kết Hợp OpenProse + Lobster: Cách Làm Chuẩn
7. Kết Luận

1. Vấn đề mà cả hai cùng giải quyết

Khi yêu cầu một tác nhân AI thực hiện một quy trình nhiều bước — nghiên cứu, tổng hợp, gửi email, cập nhật tệp — điều thường xảy ra là:

• Tác nhân phải lên kế hoạch lại từng bước từ đầu, tiêu tốn token lãng phí.
• Tác nhân tự quyết định thực hiện các hành động có tác dụng phụ (gửi tin nhắn, ghi tệp, gọi API ngoài) mà không có điểm dừng để kiểm soát.
• Khi quy trình bị gián đoạn giữa chừng, không có cách nào tiếp tục từ đúng điểm đã dừng.
• Trong các quy trình đa tác nhân phức tạp, ngữ cảnh của phiên chính bị phình to quá mức.

OpenClaw giải quyết những vấn đề này bằng hai plugin bổ sung cho nhau: Lobster và OpenProse. Hai công cụ này không cạnh tranh — chúng hoạt động ở hai tầng khác nhau và phục vụ hai nhu cầu khác nhau.

Hiểu rõ ranh giới đó là chìa khóa để thiết kế hệ thống đúng.

2. Lobster — Vỏ Chạy Quy Trình Tất Định

2.1 Lobster là gì?

Lobster là một vỏ chạy quy trình (workflow shell) — một môi trường thực thi có kiểu dữ liệu, cho phép OpenClaw thực thi chuỗi lệnh shell/CLI theo thứ tự xác định, truyền dữ liệu JSON giữa các bước, và dừng lại chờ người dùng phê duyệt trước khi thực hiện các hành động có tác dụng phụ.

Có thể ví von như sau: Lobster đối với OpenClaw giống như GitHub Actions đối với GitHub — một bản khai báo quy trình chạy bên trong nền tảng.

Đặc điểm cốt lõi của Lobster gồm ba điểm:

Một lần gọi thay vì nhiều lần. Thay vì tác nhân phải lần lượt gọi từng công cụ, suy nghĩ, rồi gọi công cụ tiếp theo — Lobster gộp toàn bộ chuỗi đó vào một lời gọi duy nhất. Tác nhân khởi động Lobster, Lobster chạy chuỗi lệnh, tác nhân nhận kết quả.

Cổng phê duyệt tích hợp sẵn. Bất kỳ bước nào có khả năng gây tác dụng phụ (gửi tin nhắn, thay đổi dữ liệu, gọi API ngoài) đều có thể đặt sau một cổng approval: required. Quy trình tự động dừng lại, trả về resumeToken, và chờ người dùng quyết định.

Có thể tiếp tục sau khi bị gián đoạn. Quy trình đang chờ phê duyệt không mất trạng thái. Khi người dùng phê duyệt, lệnh tiếp tục kèm token sẽ chạy chính xác từ bước đó — không chạy lại phần đã hoàn thành.

2.2 Tại sao cần một ngôn ngữ đặc thù riêng?

Câu hỏi hợp lý: tại sao không viết script Python hay Bash thông thường?

Câu trả lời nằm ở hai khía cạnh: khả năng kiểm tra và sự an toàn được thiết kế sẵn.

Trong Lobster, chuỗi lệnh là dữ liệu, không phải mã lệnh. Mỗi bước là một đối tượng YAML có thể ghi lại, so sánh sự khác biệt, và chạy lại. Không có trạng thái ẩn, không có tác dụng phụ che giấu. Khi một bước thất bại, bạn biết chính xác bước nào, vì sao, và đầu ra của các bước trước là gì.

Hơn nữa, bề mặt thực thi của Lobster bị giới hạn có chủ ý: giới hạn thời gian, giới hạn kích thước đầu ra (maxStdoutBytes), nhận biết môi trường cô lập (sandbox). Đây là "bề mặt thu hẹp" giúp hành vi của tác nhân có thể dự đoán được — AI không thể "sáng tạo" sai ở tầng điều phối thực thi.

2.3 Cú pháp và cách hoạt động

Lobster chạy các tệp .lobster — YAML/JSON với cấu trúc name, args, steps, env, condition, và approval.

Tệp quy trình mẫu — phân loại hộp thư:

name: inbox-triage
args:
  tag:
    default: "family"

steps:
  - id: collect
    command: inbox list --json

  - id: categorize
    command: inbox categorize --json
    stdin: $collect.stdout

  - id: approve
    command: inbox apply --approve
    stdin: $categorize.stdout
    approval: required

  - id: execute
    command: inbox apply --execute
    stdin: $categorize.stdout
    condition: $approve.approved

Nhìn vào cấu trúc này, bạn thấy ngay triết lý thiết kế: bước approve nằm trước execute. Không có cách nào để execute chạy mà không qua cổng phê duyệt. Đây là sự an toàn được đưa vào cấu trúc, không phải vào lời nhắc (prompt).

Cách OpenClaw gọi Lobster:

{
  "action": "run",
  "pipeline": "/path/to/inbox-triage.lobster",
  "argsJson": "{\"tag\":\"family\"}",
  "cwd": "workspace",
  "timeoutMs": 30000,
  "maxStdoutBytes": 512000
}

OpenClaw khởi động Lobster CLI ở chế độ công cụ và phân tích phong bì JSON từ đầu ra. Nếu quy trình dừng tại cổng phê duyệt:

{
  "ok": true,
  "status": "needs_approval",
  "output": [{ "summary": "5 need replies, 2 need action" }],
  "requiresApproval": {
    "type": "approval_request",
    "prompt": "Send 2 draft replies?",
    "items": [],
    "resumeToken": "eyJ..."
  }
}

Tác nhân nhận phong bì này, trình bày cho người dùng, và chờ quyết định. Khi người dùng phê duyệt:

{
  "action": "resume",
  "token": "eyJ...",
  "approve": true
}

Quy trình tiếp tục từ đúng điểm đó.

2.4 Nhúng bước AI vào Lobster: plugin llm-task

Lobster là vỏ thực thi — nó không tự gọi mô hình ngôn ngữ. Nhưng với plugin llm-task được bật, bạn có thể nhúng một bước AI có cấu trúc vào trong chuỗi lệnh mà không phá vỡ tính tất định của phần còn lại.

Bật llm-task:

{
  "plugins": {
    "entries": {
      "llm-task": { "enabled": true }
    }
  },
  "agents": {
    "list": [
      {
        "id": "main",
        "tools": { "allow": ["llm-task"] }
      }
    ]
  }
}

Gọi mô hình từ trong bước Lobster:

- id: classify
  command: >
    openclaw.invoke --tool llm-task --action json --args-json '{
      "prompt": "Given the input email, return intent and draft reply as JSON.",
      "input": { "subject": "Hello", "body": "Can you help?" },
      "schema": {},
      "model": "ollama/qwen3.5:14b",
      "temperature": 0.4,
      "maxTokens": 2000
    }'
  stdin: $collect.stdout

llm-task yêu cầu mô hình chỉ xuất JSON (không có thêm giải thích hay định dạng markdown), kiểm tra schema trước khi trả về. Bước AI này là một hộp đen từ góc nhìn của Lobster — nó chỉ nhận đầu vào JSON và xuất đầu ra JSON như mọi bước khác.

2.5 Cài đặt và cấu hình

Cài Lobster CLI:

# Cài toàn cục qua npm
npm install -g @clawdbot/lobster

# Hoặc dùng node trực tiếp (điều chỉnh đường dẫn)
alias lobster="node /path/to/lobster/bin/lobster.js"

# Kiểm tra
lobster --version

Lobster phải nằm trên PATH trên cùng máy chủ chạy OpenClaw Gateway.

Bật plugin trong openclaw.json:

{
  "tools": {
    "alsoAllow": ["lobster"]
    // Dùng alsoAllow thay vì allow để không vô tình giới hạn các công cụ cốt lõi
  }
}

Lưu ý quan trọng: Tránh dùng tools.allow: ["lobster"] (danh sách cho phép thuần túy) trừ khi bạn chủ ý chạy ở chế độ hạn chế. alsoAllow là bổ sung — an toàn hơn.

Các tham số khi chạy:

Xử lý lỗi thường gặp:

lobster subprocess timed out
→ Tăng timeoutMs hoặc chia chuỗi lệnh thành nhiều bước nhỏ hơn

lobster output exceeded maxStdoutBytes
→ Tăng maxStdoutBytes hoặc giảm kích thước đầu ra của từng bước

lobster returned invalid JSON
→ Đảm bảo chuỗi lệnh chạy ở chế độ công cụ và chỉ in JSON ra đầu ra

lobster failed (code N)
→ Chạy cùng chuỗi lệnh trong terminal để xem chi tiết lỗi

2.6 Ví dụ thực tế: "Bộ Não Thứ Hai" với kho lưu trữ Markdown

Một trường hợp sử dụng từ cộng đồng OpenClaw: quản lý ba kho lưu trữ Markdown (cá nhân, đối tác, chia sẻ) bằng một công cụ dòng lệnh tự viết kết hợp với Lobster.

Công cụ này xuất JSON cho thống kê, danh sách hộp thư đến, và quét tệp lỗi thời. Lobster nối các lệnh đó thành các quy trình:

name: weekly-review
steps:
  - id: stats
    command: brain stats --json --vault personal

  - id: inbox
    command: brain inbox list --json --vault personal
    stdin: $stats.stdout

  - id: stale
    command: brain stale --json --days 14

  - id: review_gate
    command: brain inbox preview --json
    stdin: $inbox.stdout
    approval: required

  - id: consolidate
    command: brain memory consolidate --json
    stdin: $inbox.stdout
    condition: $review_gate.approved

  - id: sync_shared
    command: brain task sync --vault shared
    condition: $review_gate.approved

Mỗi tuần, tác nhân khởi động weekly-review, người dùng xem lại tóm tắt hộp thư đến tại cổng phê duyệt, phê duyệt một lần — và toàn bộ quá trình hợp nhất + đồng bộ được thực thi theo thứ tự xác định.

3. OpenProse — Ngôn Ngữ Điều Phối Phiên AI

3.1 OpenProse là gì?

OpenProse là một ngôn ngữ lập trình cho các phiên AI — một định dạng quy trình đa nền tảng, ưu tiên markdown, dùng để điều phối các phiên AI có cấu trúc, nhiều tác nhân, với luồng kiểm soát tường minh.

Trong OpenClaw, nó được tích hợp dưới dạng plugin cài đặt một bộ kỹ năng OpenProse và một lệnh gạch chéo /prose. Trang chính thức: prose.md.

Để hiểu triết lý của OpenProse, hãy bắt đầu từ nhận định nền tảng của nó:

"Mô hình ngôn ngữ là bộ mô phỏng. Khi được cung cấp một mô tả hệ thống đủ chi tiết, chúng không chỉ mô tả nó — chúng mô phỏng nó. Bản đặc tả OpenProse mô tả một máy ảo với đủ độ chính xác để bất kỳ hệ thống tương thích Prose nào đọc nó đều trở thành máy ảo đó."

Nói cụ thể hơn: OpenProse không cần một trình thông dịch riêng. Khi tác nhân đọc tệp đặc tả prose.md, nó trở thành máy ảo đó. Mô phỏng với đủ độ chính xác chính là sự hiện thực hóa.

Đây là điểm khác biệt cốt lõi so với các khung như LangChain, CrewAI hay AutoGen — những công cụ đó điều phối tác nhân từ bên ngoài bằng mã lệnh. OpenProse chạy bên trong phiên tác nhân. Không cần phụ thuộc bên ngoài, có thể sử dụng trên mọi hệ thống tương thích Prose.

3.2 Triết lý: Tại sao không chỉ dùng tiếng tự nhiên?

Một quy trình phức tạp cần cấu trúc rõ ràng, không mơ hồ cho luồng kiểm soát. Nếu bạn mô tả bằng tiếng Việt hay tiếng Anh thông thường: "Nghiên cứu song song, rồi tổng hợp" — tác nhân phải đoán bạn muốn tuần tự hay song song, bao nhiêu tác nhân, khi nào gộp kết quả.

OpenProse giải quyết điều này bằng ngữ nghĩa dựa trên hợp đồng:

---
name: research-with-agents
kind: program
services: [researcher, writer]
---

requires:
  - topic: a research question to investigate

ensures:
  - report: an executive-ready summary of research findings

strategies:
  - when initial research is shallow: deepen with more targeted queries
  - when findings are too technical for executives: simplify language while preserving accuracy

requires: và ensures: là các hợp đồng — không phải mô tả, mà là cam kết. Môi trường thực thi biết chính xác đầu vào cần có và đầu ra cần đảm bảo trước khi chạy.

3.3 Cách OpenProse hoạt động

Tệp .prose — ví dụ nghiên cứu + tổng hợp:

# research-synthesis.prose
# Nghiên cứu + tổng hợp với hai tác nhân chạy song song

input topic: "What should we research?"

agent researcher:
  model: sonnet
  prompt: "You research thoroughly and cite sources."

agent writer:
  model: opus
  prompt: "You write a concise summary."

parallel:
  findings = session: researcher
    prompt: "Research {topic}."
  draft = session: writer
    prompt: "Summarize {topic}."

session "Merge the findings + draft into a final answer."
  context: { findings, draft }

Nhìn vào khối parallel: — đây là điều Lobster không thể làm. OpenProse hỗ trợ sẵn việc chạy song song, truyền ngữ cảnh tường minh giữa các tác nhân, và gộp kết quả về phiên chính.

Quản lý trạng thái:

OpenProse lưu trạng thái trong thư mục .prose/ trong không gian làm việc:

.prose/
├── .env
├── runs/
│   └── {YYYYMMDD}-{HHMMSS}-{random}/
│       ├── program.prose
│       ├── state.md
│       ├── bindings/
│       └── agents/
└── agents/

Ba chế độ lưu trạng thái:

3.4 Lệnh gạch chéo /prose và các lệnh con

Khi plugin OpenProse được bật, OpenClaw đăng ký /prose là lệnh gạch chéo có thể gọi trực tiếp từ bất kỳ kênh nào:

Chạy từ kho lưu trữ trực tuyến:

# Tên tắt từ kho — phân giải qua p.prose.md
/prose run irl-danb/habit-miner

# URL trực tiếp
/prose run https://raw.githubusercontent.com/openprose/prose/main/examples/48-habit-miner.prose

# Bí danh trong chương trình
use "alice/research" as research
use "@alice/code-review" as reviewer  # @ được loại bỏ tự động

3.5 Cài đặt và cấu hình

Bật plugin trong openclaw.json:

{
  "plugins": {
    "entries": {
      "open-prose": { "enabled": true }
    }
  }
}

Khởi động lại Gateway sau khi bật. Với phiên bản thử nghiệm cục bộ:

openclaw plugins install ./extensions/open-prose

Cấu hình chế độ lưu trạng thái (tùy chọn):

# Filesystem (mặc định) — không cần cấu hình thêm

# SQLite
OPENPROSE_STATE=sqlite

# PostgreSQL (dùng thông tin xác thực quyền hạn tối thiểu)
OPENPROSE_POSTGRES_URL=postgres://user:pass@host/db

Lưu ý bảo mật PostgreSQL: Thông tin xác thực được truyền vào các phiên tác nhân con và sẽ hiển thị trong ngữ cảnh tác nhân và nhật ký. Hãy dùng cơ sở dữ liệu riêng với quyền hạn tối thiểu.

Một kỹ năng duy nhất, không phải nhiều:

Có một điểm dễ nhầm: OpenProse chỉ có một kỹ năng duy nhất là open-prose. Không có prose-run, prose-compile, hay prose-boot tách biệt. Mọi lệnh đều đi qua kỹ năng này.

Không đúng: npx playbooks add skill openclaw/skills --skill prose-run
Đúng:       npx playbooks add skill openclaw/skills --skill prose

Bảo mật — xem xét trước khi chạy:

OpenProse thực thi các chương trình với quyền truy cập đầy đủ vào không gian làm việc và các công cụ của tác nhân. Luôn xem xét tệp .prose trước khi chạy, đặc biệt với các chương trình từ xa từ kho lưu trữ hoặc URL. Dùng danh sách cho phép công cụ trong cấu hình để hạn chế những gì tác nhân con có thể làm.

3.6 Yêu cầu: Hệ thống tương thích Prose

OpenProse không chạy trên mọi mô hình. Nó yêu cầu một hệ thống tương thích Prose — tổ hợp mô hình và môi trường đủ mạnh để mô phỏng máy ảo khi đọc đặc tả. Hiện tại được hỗ trợ chính thức: Claude Code + Opus, OpenCode + Opus, Amp + Opus.

Với OpenClaw kết hợp mô hình cục bộ (như Qwen3.5), khả năng tương thích phụ thuộc vào việc mô hình có đủ năng lực mô phỏng hay không — đây là điểm cần kiểm tra thực tế.

4. Sai Lầm Phổ Biến: Dùng Lobster Một Mình Cho Tất Cả

Hiểu lý thuyết là một chuyện. Nhưng cách hiểu sâu nhất là xem một hệ thống thực tế đang dùng sai công cụ, và phân tích tại sao.

Dưới đây là kiến trúc của một quy trình xây dựng chương trình học đang dùng Lobster để điều phối toàn bộ — bao gồm cả phần điều phối các phiên AI:

# curriculum_master.lobster

- id: ph1_prep
  command: >
    python tools/prepare_prompt.py
    --skill skills/phase-1/skill-interview
    --context projects/curriculum/00_meta/requirements.md

- id: ph1_interview
  command: >
    openclaw.invoke --tool llm-task --action json --args-json '{
      "prompt": "Chạy skill interview. Output JSON.",
      "model": "ollama/qwen3.5:14b",
      "temperature": 0.6,
      "maxTokens": 2000
    }'
  stdin: $ph1_prep.stdout

- id: ph1_save
  command: python tools/file_manager.py save --path "projects/curriculum/00_meta/requirements.md"
  stdin: $ph1_interview.stdout

Và một đoạn từ cùng tài liệu thiết kế:

"Giai đoạn 6–7 được xử lý bằng script Python riêng vì Lobster không có vòng lặp for tích hợp sẵn."

Hai đoạn này chứa ba dấu hiệu của một hệ thống đang dùng sai tầng.

Dấu hiệu 1: prepare_prompt.py không nên tồn tại

Công cụ prepare_prompt.py làm một việc duy nhất: đọc SKILL.md từ thư mục kỹ năng, gộp các tệp tham chiếu, điền biến, rồi tạo một chuỗi văn bản làm đầu vào cho llm-task.

Lý do nó phải tồn tại: Lobster không biết cách nói chuyện với ngữ cảnh AI. Nó là vỏ thực thi — nó chỉ biết đầu vào/đầu ra. Để đưa kỹ năng và ngữ cảnh vào lời gọi mô hình, bạn phải tự xây dựng cầu nối thủ công.

OpenProse loại bỏ hoàn toàn sự cần thiết của cầu nối này. Trong một chương trình OpenProse, tác nhân là phiên AI — nó đọc tệp kỹ năng, hiểu ngữ cảnh, và đưa thông tin vào lời nhắc một cách tự nhiên, không cần lớp bao bọc.

Kiến trúc có vấn đề:
  Lobster (vỏ thực thi)
      → prepare_prompt.py (cầu nối thủ công)
      → llm-task (lời gọi mô hình)
      → file_manager.py (lưu kết quả)

Kiến trúc đúng:
  Phiên OpenProse (hiểu AI)
      → đọc tệp kỹ năng trực tiếp
      → lý luận về ngữ cảnh
      → [gọi Lobster khi cần thực thi tất định + phê duyệt]

Dấu hiệu 2: Kiến trúc tác nhân con phải tự xây từ đầu

Cùng tài liệu thiết kế mô tả toàn bộ kiến trúc ba tầng phải tự xây dựng thủ công:

Tác nhân chính (tầng 0)
  → sessions_spawn → Điều phối giai đoạn 8 (tầng 1)
                       → sessions_spawn → Các nhân viên bài học (tầng 2)

Bao gồm: tự viết logic đưa gói nhiệm vụ vào AGENTS.md trước khi tạo nhân viên, tự xử lý mẫu thông báo, tự quản lý trạng thái giữa các tầng.

Đây chính xác là những gì OpenProse được thiết kế để làm — có sẵn ngay từ đầu:

# Thay thế toàn bộ kiến trúc ba tầng trên bằng:

parallel:
  for lesson in lessons:
    result_{lesson.id} = session: lesson_worker
      prompt: "Execute lesson materials for {lesson.title} using skill {lesson.skill}."
      context: { lesson, constraints, unit_framework }

Không cần đưa ngữ cảnh thủ công, không cần tự xây mẫu thông báo, không cần quản lý AGENTS.md giữa các lần tạo tác nhân.

Dấu hiệu 3: "Lobster không có vòng lặp for" — đang ở sai tầng

Khi bạn cần vòng lặp, khi bạn cần logic điều kiện phức tạp, khi bạn cần điều phối nhiều phiên AI — đó là lúc bạn đã vượt ra ngoài phạm vi của Lobster.

Lobster là vỏ thực thi quy trình, không phải ngôn ngữ điều phối. Giống như bạn không nên dùng script Bash để quản lý máy trạng thái phức tạp của một ứng dụng — Bash là công cụ sai cho bài toán đó.

Tổng kết các dấu hiệu:

5. Phân Chia Vai Trò Đúng

Sau khi hiểu các sai lầm phổ biến, câu hỏi trở thành: ai làm gì?

┌─────────────────────────────────────────────────────────────┐
│  OPENPROSE — Tầng Điều Phối                                 │
│                                                             │
│  • Định nghĩa quy trình, luồng kiểm soát, đa tác nhân      │
│  • Đọc kỹ năng, lý luận về ngữ cảnh, xây dựng phiên AI     │
│  • Thực thi song song, cô lập ngữ cảnh                     │
│  • Quản lý trạng thái qua các phiên                        │
│  • Gọi Lobster như một công cụ bên dưới                     │
└──────────────────────┬──────────────────────────────────────┘
                       │ gọi khi cần
┌──────────────────────▼──────────────────────────────────────┐
│  LOBSTER — Tầng Thực Thi                                    │
│                                                             │
│  • Chạy chuỗi lệnh shell/CLI theo thứ tự xác định          │
│  • Cổng phê duyệt trước các tác dụng phụ                   │
│  • Truyền JSON giữa các bước                               │
│  • Tiếp tục với token sau khi được phê duyệt               │
│  • Kiểm tra schema, lưu tệp, so sánh sự khác biệt         │
└─────────────────────────────────────────────────────────────┘

Bảng phân chia theo loại công việc:

6. Kết Hợp OpenProse + Lobster: Cách Làm Chuẩn

Đây là cách tổ chức nên trở thành tư duy mặc định của bạn khi thiết kế quy trình phức tạp trong OpenClaw.

6.1 Kiến trúc tổng quát

/prose run curriculum-pipeline.prose
          │
          ▼
    [Máy ảo OpenProse]
    ┌─────────────────────────────────────────┐
    │                                         │
    │  Đọc yêu cầu, nghiên cứu ngữ cảnh      │ ← Công việc phiên AI
    │  Vòng lặp qua các giai đoạn, lưu TT    │ ← Luồng kiểm soát OpenProse
    │  Tạo nhân viên bài học song song        │ ← Đa tác nhân tích hợp sẵn
    │                                         │
    │  Khi cần phê duyệt trước tác dụng phụ: │
    │  → Gọi Lobster với chuỗi lệnh + cổng   │ ← Thực thi Lobster
    │  → Nhận resumeToken, chờ người dùng     │
    │  → Phê duyệt → Lobster tiếp tục         │
    │                                         │
    │  Khi cần kiểm tra + lưu kết quả:        │
    │  → Gọi Lobster với chuỗi kiểm tra      │ ← Thực thi Lobster
    │  → Nhận kết quả JSON, tiếp tục          │
    └─────────────────────────────────────────┘

6.2 Ví dụ thực tế: Quy Trình Xây Dựng Chương Trình Học

Dưới đây là cách viết lại kiến trúc từ Mục 4 theo đúng cách làm:

curriculum-pipeline.prose — Tầng OpenProse:

---
name: curriculum-pipeline
kind: program
---

requires:
  - project: tên dự án cần tạo chương trình

ensures:
  - full_curriculum: bộ học liệu hoàn chỉnh đã qua phê duyệt của con người

# Giai đoạn 1–3: Công việc phiên AI — OpenProse xử lý
session "Thu thập yêu cầu từ người dùng qua kỹ năng phỏng vấn."
  skill: skills/phase-1/skill-interview
  output: requirements

session "Nghiên cứu bối cảnh công nghệ và xã hội."
  skill: skills/phase-1/skill-research-synthesis
  context: { requirements }
  output: research_notes

session "Ánh xạ yêu cầu thành ràng buộc SMART."
  skill: skills/phase-3-5/skill-constraint-mapping
  context: { requirements, research_notes }
  output: constraints

# Cổng 1: Phê duyệt có tác dụng phụ — Lobster xử lý
invoke lobster:
  pipeline: workflows/gate-approval.lobster
  args: { gate: 1, file: constraints }
  wait_for_approval: true

# Giai đoạn 4–5: Công việc phiên AI tiếp tục
session "Thiết kế sản phẩm học tập."
  skill: skills/phase-4/skill-product-design
  context: { constraints }
  output: product_map

session "Xây dựng khung đơn vị học tập."
  skill: skills/phase-3-5/skill-unit-framework
  context: { constraints, product_map }
  output: unit_framework

# Cổng 2
invoke lobster:
  pipeline: workflows/gate-approval.lobster
  args: { gate: 2, file: unit_framework }
  wait_for_approval: true

# Giai đoạn 6–7: Vòng lặp — OpenProse xử lý tự nhiên
session "Phân rã thành đặc tả bài học."
  skill: skills/phase-7/skill-lesson-spec
  context: { unit_framework, constraints }
  output: lesson_specs

# Cổng 3
invoke lobster:
  pipeline: workflows/gate-approval.lobster
  args: { gate: 3, file: lesson_specs }
  wait_for_approval: true

# Giai đoạn 8: Đa tác nhân — OpenProse tích hợp sẵn
parallel:
  for lesson in lesson_specs:
    materials_{lesson.id} = session: lesson_worker
      prompt: "Sinh đầy đủ học liệu cho {lesson.title}."
      context: { lesson, constraints, unit_framework }
      tools_allow: ["lobster"]  # Cho phép nhân viên gọi Lobster

workflows/gate-approval.lobster — Tầng Lobster:

name: gate-approval
args:
  gate:
    required: true
  file:
    required: true

steps:
  - id: display
    command: python tools/file_manager.py display_gate_checklist --gate "${gate}" --file "${file}"

  - id: show_content
    command: cat "${file}"

  - id: human_gate
    command: echo "Cổng ${gate} — Chờ phê duyệt từ người dùng"
    stdin: $show_content.stdout
    approval: required

  - id: mark_approved
    command: python tools/progress_tracker.py mark_gate "${gate}" approved
    condition: $human_gate.approved

Nhân viên bài học — vẫn có thể dùng Lobster bên trong:

# Lobster chạy bên trong mỗi tác nhân nhân viên bài học
# Vẫn cần vì thứ tự tạo kết quả phải tất định

name: lesson-materials
args:
  lesson_json:
    required: true

steps:
  - id: gen_lesson_plan
    command: >
      openclaw.invoke --tool llm-task --action json --args-json '{
        "prompt": "Sinh giáo án 5E theo đặc tả bài học.",
        "model": "ollama/qwen3.5:14b",
        "temperature": 0.4,
        "maxTokens": 6000
      }'

  - id: validate_lesson_plan
    command: python tools/validator.py validate --schema schemas/lesson_plan.schema.json
    stdin: $gen_lesson_plan.stdout

  - id: save_lesson_plan
    command: python tools/file_manager.py save_artifact --artifact lesson_plan
    stdin: $validate_lesson_plan.stdout

  # ... các kết quả tiếp theo theo thứ tự xác định

  - id: critique
    command: >
      openclaw.invoke --tool llm-task --action json --args-json '{
        "prompt": "Đánh giá toàn bộ học liệu theo tiêu chí sư phạm.",
        "model": "ollama/qwen3.5:14b",
        "temperature": 0.2,
        "maxTokens": 3000
      }'

  - id: check_threshold
    command: python tools/validator.py check_critique_threshold --min-score 85
    stdin: $critique.stdout

6.3 Tại sao Lobster vẫn cần thiết bên trong nhân viên bài học?

Có thể bạn hỏi: tại sao không để OpenProse xử lý cả nhân viên bài học? Tại sao phải dùng Lobster bên trong nhân viên?

Câu trả lời: thứ tự tạo các kết quả phải hoàn toàn xác định.

lesson_plan phải được tạo trước slides_outline, vì phần trình chiếu dựa trên giáo án. exercises phải trước teacher_guide, vì hướng dẫn giáo viên tham chiếu bài tập. Đây là chuỗi phụ thuộc nghiêm ngặt.

Lobster đảm bảo điều này bằng cú pháp stdin: $step.stdout — không có bước nào bắt đầu trước bước trước hoàn thành và xuất kết quả. OpenProse mang lại sự điều phối thông minh; Lobster mang lại thực thi xác định. Cả hai cần nhau.

6.4 Lợi ích cụ thể của cách kết hợp

So sánh kiến trúc cũ (chỉ dùng Lobster) và kiến trúc mới (OpenProse + Lobster):

7. Kết Luận

Lobster và OpenProse là hai công cụ phản ánh hai cách tư duy khác nhau, phục vụ hai nhu cầu khác nhau — nhưng bổ sung cho nhau một cách tự nhiên khi được dùng đúng.

Lobster trả lời câu hỏi: "Làm thế nào để tôi chắc chắn rằng chuỗi lệnh này chạy theo đúng thứ tự, không có gì bất ngờ, và người dùng có thể kiểm soát mọi tác dụng phụ?" Câu trả lời của nó là tất định, có kiểu dữ liệu, minh bạch.

OpenProse trả lời câu hỏi: "Làm thế nào để tôi điều phối nhiều phiên AI thông minh, với ngữ cảnh đầy đủ, mà không cần viết mã hạ tầng cho những thứ AI đã biết cách làm?" Câu trả lời của nó dựa trên mô phỏng, khai báo, và đa nền tảng.

Nguyên tắc cốt lõi cần nhớ khi thiết kế bất kỳ quy trình tác nhân nào trong OpenClaw:

Nếu bạn đang viết mã để nói chuyện với AI, bạn đang ở sai tầng. Đó là việc của OpenProse. Nếu bạn đang xác định những gì xảy ra sau khi AI quyết định, bạn đang ở đúng tầng. Đó là việc của Lobster.

Và khi cả hai phối hợp: OpenProse suy nghĩ, điều phối, và quyết định. Lobster thực thi, kiểm soát, và bảo vệ.

Tham khảo: docs.openclaw.ai/tools/lobster · docs.openclaw.ai/prose · github.com/openprose/prose