Sự tiến hóa giao diện: GUI → CLI → API → Agent

English title: The Interface Evolution: GUI → CLI → API → Agent

Mở đầu

Năm 1969, Ken Thompson ngồi trong phòng lab AT&T Bell Labs, viết những dòng code đầu tiên cho Unix. Ông đặt ra một nguyên tắc đơn giản đến mức nhiều người bỏ qua: mỗi chương trình làm đúng một việc, làm tốt việc đó, và giao tiếp qua text.

Nửa thế kỷ sau, hàng triệu developer xây GUI phức tạp, REST API đồ sộ, dashboard đẹp mắt. Rồi AI agent xuất hiện — và bỗng nhiên, nguyên tắc của Thompson trở nên đúng hơn bao giờ hết. Một agent không cần nút bấm. Nó cần input rõ ràng, output có cấu trúc, và exit code có nghĩa.

Bài này là bài đầu tiên trong chuỗi 10 bài về hành trình xây dựng CLI và biến ứng dụng thành công cụ mà AI agent dùng trực tiếp — agent-native. Chúng ta sẽ bắt đầu từ câu hỏi nền tảng: bốn tầng giao diện là gì, tại sao CLI đang quay lại, và vì sao bạn nên quan tâm.

1. Bốn tầng giao diện — và tại sao thứ tự quan trọng

Mỗi tầng giao diện sinh ra để giải quyết một giới hạn cụ thể. Nhưng không tầng nào thay thế tầng trước — chúng xếp chồng lên nhau.

CLI (1969 — Unix): Text vào, text ra. Composable qua pipe. Không cần chuột, không cần màn hình đồ họa. Developer giao tiếp với máy qua terminal. Mỗi command là một hàm: nhận argument, trả output, kết thúc bằng exit code.

GUI (1984 — Macintosh): Người dùng thường không nhớ command. GUI giải quyết bằng nút bấm, menu, drag-and-drop. Accessibility tăng mạnh — nhưng automation gần như không thể. Bạn không thể pipe một cái click chuột sang chương trình khác.

API (2000s — REST/GraphQL): Máy giao tiếp với máy. Không cần GUI, không cần terminal. Nhưng API yêu cầu SDK, authentication flow, error handling riêng cho từng service. Mỗi API là một thế giới khác — Stripe API khác hẳn GitHub API.

Agent interface (2024 — MCP, Skills, Agent SDK): AI agent cần tool. Nhưng agent không gọi API như developer gọi — agent cần biết tool nào tồn tại, tool đó nhận input gì, output trông như thế nào. Agent interface giải quyết bài toán discovery và invocation cho máy.

Để hình dung rõ hơn:

Người dùng thường  →  GUI   (click, kéo thả)
Developer          →  CLI   (gõ lệnh, pipe output)
Service            →  API   (HTTP request/response)
AI Agent           →  ???   (discovery + invocation + structured output)

Dấu ??? ở dòng cuối — đó là vấn đề mà chuỗi bài này giải quyết.

2. Khái niệm: Agent-native là gì?

Một công cụ "agent-native" không chỉ là tool có API. Nó được thiết kế từ đầu để AI agent dùng trực tiếp, không cần con người đứng giữa.

Năm thuộc tính cốt lõi:

• Structured output. Trả JSON ra stdout, text dành cho người ra stderr. Agent parse JSON — không đoán format.
• Self-describing. Tool tự mô tả mình: nhận input gì, trả output gì, schema ra sao. --help cho người, JSON schema cho agent.
• Deterministic. Không interactive prompt. Không hỏi "Are you sure? (y/n)". Agent không gõ được "y". Mọi input qua argument hoặc stdin.
• Composable. Output của tool A là input của tool B. Pipe, redirect — Unix composition model.
• Safe by default. Destructive action cần --force flag. Default behavior là preview hoặc dry-run.

Nếu bạn thấy list này quen — đúng rồi, đây chính là Unix philosophy, chỉ thêm "structured output" và "self-describing" cho agent.

3. Code sample: Sự khác biệt giữa CLI cho người và CLI cho agent

Một CLI truyền thống:

$ myapp list-users
╔══════════╦═══════════╦════════╗
║ Name     ║ Email     ║ Role   ║
╠══════════╬═══════════╬════════╣
║ Alice    ║ a@x.com   ║ admin  ║
║ Bob      ║ b@x.com   ║ member ║
╚══════════╩═══════════╩════════╝

Đẹp cho mắt. Nhưng agent không parse được bảng Unicode. Agent cần:

$ myapp list-users --json
[
  {"name": "Alice", "email": "a@x.com", "role": "admin"},
  {"name": "Bob", "email": "b@x.com", "role": "member"}
]

Và thêm introspection:

$ myapp list-users --schema
{
  "output": {
    "type": "array",
    "items": {
      "type": "object",
      "properties": {
        "name": {"type": "string"},
        "email": {"type": "string", "format": "email"},
        "role": {"type": "string", "enum": ["admin", "member", "viewer"]}
      }
    }
  }
}

Sự khác biệt nhỏ trong code — nhưng thay đổi hoàn toàn khả năng sử dụng bởi agent.

4. Progressive Enhancement Ladder

Không cần build agent interface từ đầu. Bạn bắt đầu từ thứ đơn giản nhất và nâng cấp dần:

Level 0: Raw API (REST/GraphQL)
    ↓    wrap bằng CLI
Level 1: CLI Wrapper (--json cho máy, text cho người)
    ↓    expose qua MCP
Level 2: MCP Server (agent tự discover tool)
    ↓    viết Skills doc
Level 3: Agent Skill (static markdown, ~200 tokens)
    ↓    tích hợp SDK
Level 4: Full Agent Integration (SDK-native tool definition)

Mỗi level thêm khả năng agent-accessible mà không phá level trước. Bạn vẫn giữ CLI, vẫn giữ API — chỉ thêm layer trên.

Tại sao không nhảy thẳng lên Level 4? Vì chi phí khác nhau:

• Level 1 (CLI): Gần như miễn phí — chỉ thêm --json flag. Agent gọi qua subprocess.run(). Zero token cost cho discovery.
• Level 2 (MCP): Cần MCP server runtime. Khi agent connect, schema của tất cả tool được load vào context — tốn ~55,000 tokens cho một MCP server trung bình.
• Level 3 (Skills): Static markdown file mô tả tool. Chỉ ~200-500 tokens. Giảm 99.6% so với MCP.

Benchmark thực tế: CLI đạt 28% task completion cao hơn MCP với lượng token tương đương. Không phải MCP tệ — mà là CLI đơn giản hơn, ít overhead hơn, và LLM đã được train trên hàng tỷ dòng terminal interaction.

5. Ứng dụng trong AI-centric engineering

Nếu bạn đang xây hệ thống có AI agent — dù là chatbot, coding assistant, hay workflow automation — CLI là giao diện đầu tiên bạn nên cung cấp.

Lý do thực tế:

Agent gọi CLI dễ hơn API. Một agent viết subprocess.run(["myapp", "list-users", "--json"]) là xong. Không cần SDK, không cần import, không cần manage connection. Exit code 0 = thành công, khác 0 = lỗi.

CLI composable bằng shell. Agent có thể viết pipeline:

myapp list-users --json | jq '.[] | select(.role == "admin")' | myapp notify --stdin

Ba tool, một pipeline, không cần orchestration framework.

CLI là foundation cho mọi layer khác. Khi bạn đã có CLI tốt, wrap thành MCP server là vài chục dòng code. Viết Skills doc là copy --help output vào markdown. Tích hợp Agent SDK là register CLI command như tool definition.

Trong chuỗi bài tiếp theo, chúng ta sẽ đi vào chi tiết từng bước: thiết kế CLI cho agent (bài 2), adapter pattern để wrap API (bài 3), code generation pipeline (bài 4-5), và cuối cùng là tích hợp MCP, Skills, Agent SDK (bài 7-9).

Bài tiếp

Bài 2: Anatomy of an Agent-Ready CLI — 7 nguyên tắc thiết kế CLI mà agent dùng được: --json output, meaningful exit codes, no interactive prompts, schema introspection. Kèm code sample bằng Python (Typer) và Go (Cobra).