agent-00 · AI agent 是圍繞 LLM processor 建成的 computer system

用 computer architecture 重新理解 AI agent：LLM 是 processor，context 是 working set，memory 是 storage，tools 是 I/O，harness 是 OS。

2026 年 5 月 19 日 · 10 分鐘 · Arthur Yau

本文為 LLM 自動翻譯，原文以 English 版本為準；另有 Lee Hung-yi-inspired English teaching-style version 與李宏毅老師經典的教學風格版（受李宏毅教學風格啟發，非本人撰寫或背書）。如有不通順或誤譯處，建議參照原文。

如果你把 AI agent 當成「一個 model 加上一個 chat box」，每次失敗看起來都會像 model failure。

Model 忘了。Model hallucinate。Model 不夠聰明。Model 需要更大的 context window。

有時候這是真的。但它常常不是第一個該下的 diagnosis。

更好的 frame 是：AI agent 是一套圍繞 LLM processor 建成的 computer system。

LLM 是中央 reasoning engine，但真正的 capability 來自它周圍的整個 architecture：context、memory、retrieval、tools、drivers、feedback、permissions、tests，以及協調整個 loop 的 harness。

這是我從李宏毅近期六堂 agent 課程整理出的 architecture map。

agent capability = model x context x tools x feedback x harness x memory

Model 很重要。當然重要。但它不是整台機器。

為什麼這個 frame 有用

Computer architecture 給 agent builders 一套更乾淨的 debugging language。

沒有人會只用 CPU 評估一台電腦。再快的 processor，也需要 working memory、storage、buses、device drivers、I/O ports、operating system、interrupts、permissions、diagnostics 與 recovery behavior。

Agents 也是一樣。

強 model 放在弱系統裡，會看起來很困惑。較小的 model 放在紀律清楚的系統裡，可能會意外地能幹。差別不是魔法，而是周圍 architecture 改變了 processor 看得到什麼、能做什麼、錯誤如何回來，以及系統何時可以宣稱成功。

所以有用的問題不只是「model 夠不夠聰明？」也包括：「是哪一層 system layer 失敗？」

Architecture map

先看 compact map：

LLM：CPU / reasoning processor。
Context window：active working set。
Long-term memory：storage layer。
Retrieval：page loader / cache fill。
Tools：peripherals、I/O devices 與 accelerators。
Tool schemas：drivers 與 syscalls。
Feedback 與 tests：interrupts、diagnostics 與 watchdogs。
Harness：motherboard、OS、scheduler、permission layer 與 recovery system。

主機板風格 architecture map，顯示 LLM processor 連接 context RAM、memory、retrieval、tools、feedback、tests 與 harness layers。 — Agent 不只是 LLM CPU，而是圍繞那顆 processor 的整套 system。

這個 analogy 不完美。LLM 不能像 CPU 一樣 random access memory。Vector database 也不是真的 page table。Prompt 也不是真的 RAM。

但作為 builder map，它很有用，因為它迫使你檢查 model 周圍的 interfaces，而不是只盯著 model weights。

LLM 是 processor，不是整台電腦

LLM 像 processor，因為核心 reasoning step 在這裡發生。

它接收 serialized input tokens，產生 output tokens。它的 weights 編碼了語言能力、coding patterns、world knowledge、reasoning habits，以及從 pretraining 和 post-training 學到的 behavior。

這已經很多，但還不夠。

Model 不會自動知道哪些 files 存在。它不會自動記得昨天發生什麼。它不會自動知道 shell command 是否成功。它也不會自動在說「完成」之前跑 verifier。它只看得到 harness 載入 prompt 的內容，也只能透過系統暴露的 tools 行動。

所以當 agent 失敗時，「model 太弱」只是其中一種可能。Active context 可能錯了。Tool 可能太模糊。Schema 可能太鬆。Feedback 可能不存在。Harness 可能允許 model 在 verification 前就停下來。

Model 是核心，但不是整台電腦。

Context 是 loaded working set

第一堂課名義上談 context engineering。放在這個 frame 裡，它其實是 working-set management。

LLM 不能按需伸手進入所有 long-term memory。它只看得到 prompt。重要的東西必須被序列化進 prompt-visible workspace。

主機板風格圖，將 Context engineering 顯示為 prompt-visible RAM、context manager、memory store、loaded pages 與 LLM processor 的連接。 — Context engineering 是 LLM-shaped processor 的 working-set management。

這讓 context window 更像某個 process 已載入的 working set，而不是整個系統的 memory。它包含 current instructions、recent state、retrieved facts、tool outputs、user constraints、partial plans，以及系統選擇保留的 scratch reasoning。

天真的 agent 把 working set 當成 append-only transcript：

C_next = C_current + new_input + model_output

短對話裡它能工作。Agents 裡它會壞掉。

Tool outputs 變得很大。File reads 淹沒 prompt。舊錯誤留在裡面。重要 constraints 被埋住。Context window 變成垃圾場，而不是 working set。

更好的 model 是：

C_next = F(C_current, new_input, model_output)

有趣的部分是 F。它決定什麼保持 hot、什麼被 evict、什麼被 summarized、什麼被 externalized、什麼被 retrieved，以及什麼被 delegated 給 sub-agent。

所以 context engineering 不是 prompt decoration。它是 LLM-shaped processor 的 memory management。

Memory 與 retrieval 是 storage 加 loading policy

Prompt-visible context 不等於 memory。

Memory 是 prompt 外面的更大 storage layer：files、notes、logs、embeddings、databases、traces、previous decisions、user preferences 與 project conventions。

C = P + M

P 是 prompt-visible working set。M 是 external memory。

弱的 agent system 會試圖把太多 M 塞進 P。更強的系統會讓 memory 留在外部，保留 pointers，刻意搜尋，然後只在需要時載入 relevant pages。

Retrieval 就是 page-loading layer。它找到正確的 memory chunk，並把它帶進 active working set。Vector index 不是真的 address translation unit，但它扮演了相似的 architectural role：讓系統在不要求 model 一次背下所有東西的情況下，找到相關的 stored state。

這也是 sub-agents 變有趣的地方。它們不只是 parallel workers。它們也是 context-compression devices。Parent agent 把一條 messy branch 丟給另一個 process，最後拿回 compact return：一個 claim、一組 evidence、一個 file path、一條 command、一個 timestamp，或一個 reproduction handle。

Tools 是 peripherals、accelerators 與 interfaces

Tools 不只是 output devices。它們是圍繞 LLM processor 的 I/O system。

Browser tool 像 network interface 加 web client。Calculator 像 math coprocessor。Shell 是 execution environment。Database tool 是 storage controller 與 query engine。Image/audio tools 是 media accelerators。Calendar、email、cloud、robotics 與 sensor APIs 則是 external peripherals。

LLM 可以 reason about an action。Tools 讓系統碰到世界。

Tool schemas 是 driver layer。它們把 model intent 轉成 valid operations：argument names、types、constraints、return shapes、permissions、failure modes 與 safe boundaries。

壞 drivers 會讓 device 很難用。模糊的 tool schema 會迫使 model 猜。會回傳一整牆 unstructured text 的 tool，會把每一次 observation 都變成另一個 context-management 問題。

Agent-first tools 應該暴露 structured inputs、bounded outputs、concise errors、stable IDs、line numbers、raw-output handles 與 deterministic verification commands。Human interfaces 常把 state 藏在 visual affordances 後面。Agent interfaces 應該讓 state machine-readable。

這也是為什麼 cover image 用 physical motherboard analogy 是合理的。RAM、storage、ports、slots、accelerators 與 diagnostic LEDs 不是裝飾，而是 agent capability surface 的可見部分。

Feedback 與 tests 是 diagnostics

Self-correction 那堂課，如果把 feedback 當成 signal path，會更容易理解。

只會 generate and reflect 的 agent，就像一台沒有 diagnostics 的 machine。它聽起來可以很深思熟慮，但仍然離 reality 越來越遠。

主機板風格圖，將 self-correction 顯示為 LLM processor 連到 decoding、verifier、diagnostics 與 watchdog 模組。 — Self-correction 需要 signal paths：decoding、workflow checks 與 trained reasoning behavior。

有用的 system 需要 interrupts 與 test signals：compiler errors、failing tests、lint output、browser screenshots、user corrections、evaluator scores、reward signals、timeouts、permission denials 與 watchdog checks。

目標不是只叫 model「自己檢查一下」。目標是把來自 environment 的 grounded signal 餵回 processor。

這就是為什麼 programming 是很強的 agent domain。Environment 可以精確說出哪裡失敗，agent 可以把這個 failure 當成下一步 input。

Tests beat vibes，因為 tests 會創造一個 system 不能誠實忽略的 interrupt。

Harness 是 system layer

Harness 這堂課是 builders 最實用的一部分。

核心例子又小又殘酷。有人要求一個 2B model 修 bug。它因為 hallucinate file content 而失敗。接著人類加了幾條簡單規則：先列出 directory、編輯前先讀 files、宣稱成功前先執行 verification script。同一個小 model 現在成功了。

Model 沒有變聰明。圍繞它的 system 變得沒那麼粗心。

主機板風格圖，將 harness 顯示為包住 LLM processor 的 OS boundary，包含 policy、tools、memory、verification 與 scheduler。 — Harness 是 OS layer：tools、tests、memory、permissions 與 recovery loops。

這就是為什麼 harness 比 bus 大。Bus 只是在 components 之間搬資料。Harness 決定什麼事情可以發生。

它選擇要載入什麼 context、有哪些 tools、套用哪些 permissions、state 如何儲存、failures 如何浮現、tests 是否必須通過、何時 retry、何時 stop，以及成功 procedure 如何變成 reusable skills。

在這個 analogy 裡，harness 是 motherboard 加 operating system，加 scheduler，加 permission layer，加 recovery system。

它是把 powerful text processor 變成 delegatable worker 的 layer。

Multi-agent systems 是 network topologies

「Multi-agent」不是一項 feature。它是一個 topology choice。

主機板風格圖，比較 star、chain、tree、mesh 等 multi-agent communication topology。 — Multi-agent systems 是 distributed systems；communication topology 會改變 algorithm。

Chain、tree、star、mesh、debate、blackboard、manager-worker 與 role-based search 都有不同 behavior。這是 distributed-systems logic 進入 agent design。

更多 processors 不會自動讓電腦更好。更多 communication 也不會自動改善結果。Topology 會改變 algorithm。

Chain 簡單，但 errors 會傳下去。Mesh 提供更多 critique 機會，但成本更高，也會產生更多 noise。Tree 可以分支成 variations，但 direction 與 merge policy 很重要。

對 builders 來說，有用的問題不是單純「one agent or many？」而是：你正在建什麼 network？每個 boundary 會跨過什麼 state？什麼 summary 被允許回到 main loop？

Self-correction 是 control loop

Self-correction 不是魔法式的 introspection。它是 control-loop problem。

System 嘗試某件事，觀察 signal，更新 state，retry，或 escalate。

這可以發生在幾個 layers。Decoding 改變 token selection。Workflow 先 generate、verify、revise，再試一次。Training 可以教出 reasoning behavior，讓 model 在 final output 前檢查 intermediate work。

Self-improvement 是同一個想法的更大版本。System 能不能改善自己的 data、objectives、rewards、model、tools、memory 或 harness？

主機板風格圖，顯示 self-improvement 從 human-defined tasks 到 AI-assisted labels、harness improvement、AI judges 與 recursive loops 的光譜。 — Self-improvement 是更大的 control loop，橫跨 data、rewards、tools、memory、model behavior 與 harnesses。

我們還沒有明確跨過那條河。AI 可以生成 pseudo-labels、幫忙寫 rewards、judge outputs、create tasks、train weaker models，也能改善 harness rules。但每一步都有陷阱：proxy reward drift、self-training plateau、benchmark overfitting、evaluator hacking，以及假的 progress。

我最信任的 near-term self-improvement path 是 harness improvement：加一個 verifier、收緊 tool、寫 reusable skill、清理 memory，或改善 workflow。這個版本不像改寫 weights 那麼戲劇化，但更容易 inspect。

Builder checklist

實務 takeaway 很簡單：在怪 processor 前，先檢查整台 computer。

正確的 working set 有被載入嗎？
Long-term memory 有被乾淨 retrieve 嗎？
Tools 有 expose explicit state 嗎？
Drivers 有限制 valid actions 嗎？
Feedback 有作為 real diagnostic signal 回來嗎？
Tests 或 watchdogs 有阻止 fake completion 嗎？
Permissions 和 task 匹配嗎？
Harness 知道何時 retry、stop 或 escalate 嗎？

這也是 agent engineering 感覺混亂的原因。沒有單一旋鈕。我們正在 LLM processors 周圍建造 computer systems，而每一層都會改變 processor 看起來能做到什麼。

我認識最強的 agent builders 不只問 model 夠不夠聰明。他們會問：是哪一層 system layer 失敗？

Companion deep dives

這篇是 architecture map。每篇 companion post 則深入拆解背後的課程 topic：

來源與參考資料

這張 architecture map 背後的 source lectures：