ยาวไปไม่อ่าน สรุปก็คือ:
- เอา agent ทั้งกองราว ๆ 168 ตัวมาต่อกับ tmux ให้แต่ละ pane คือ agent หนึ่งตัว สั่งงานพร้อมกันได้ในจอเดียว
- สั่งงานเป็นเวฟ: เวฟ research ไปสำรวจก่อน แล้วค่อยเวฟ build มาลงมือสร้างจากผลวิจัย
- ลองจริงด้วยการสร้าง visual design system สำหรับแดชบอร์ดห้องรอคลินิกสัตว์ ออปติไมซ์ให้ขึ้นทีวี ทำด้วย SvelteKit + Tailwind
เอาจริง ๆ ความรู้สึกตอนเปิดจอแล้วเห็น agent ทั้งกองขยับพร้อมกันมันเหมือนคาถาแยกเงาพันร่างในนารูโตะอยู่นิด ๆ ครับ 5555 ปล่อยร่างแยกออกไปทำงานเป็นกอง ๆ พร้อมกันหมด ไอเดียหลักคือผมเอา agent ราว 168 ตัวมาผูกกับ tmux เพราะ tmux มันแบ่งจอเป็น pane ได้เยอะ ๆ แต่ละ pane ก็คือ agent หนึ่งตัวที่กำลังทำงานของมันอยู่ ไม่ต้องนั่งสลับหน้าต่างทีละอัน เห็นทุกตัวขยับพร้อมกันในจอเดียว สั่งงาน orchestrate ง่ายขึ้นเยอะ
หัวใจของมันไม่ได้อยู่ที่จำนวน agent อย่างเดียวนะ แต่อยู่ที่การสั่งงานเป็น “เวฟ” ส่วนตัวผมว่าตรงนี้แหละที่ทำให้มันทรงพลังจริง แทนที่จะปล่อยทุกตัวลุยพร้อมกันแบบมั่ว ๆ ผมแบ่งเป็นรอบ เวฟแรกคือ research ปล่อย agent หลายตัวไปหาข้อมูล ไปสำรวจ design pattern ต่าง ๆ พอผลกลับมาครบค่อยปล่อยเวฟสองคือ build เอา agent อีกชุดมาลงมือสร้างจริงจากของที่เวฟแรกหามาได้ ข้อดีคือคนสร้างไม่ต้องเดาเอง มันต่อยอดจากงานวิจัยที่มีอยู่แล้ว งานเลยออกมานิ่งและไปในทางเดียวกัน
งานที่ผมเอามาเทสต์รอบนี้คือสร้าง visual design system สำหรับ “แดชบอร์ดห้องรอของคลินิกสัตว์” ที่ออปติไมซ์ให้แสดงบนจอทีวี ทำด้วย SvelteKit + Tailwind CSS อันนี้แอบฟินครับ เพราะมันเอาอดีตหมอสัตว์ของผมมาเจอกับงาน dev พอดี จากที่เคยยืนอยู่ในห้องตรวจ ตอนนี้ได้สั่งกองทัพ agent มาออกแบบจอให้ห้องรอเอง พอ research wave ไปดูเรื่องระยะการอ่านบนทีวี ขนาดฟอนต์ คอนทราสต์ มาให้ก่อน build wave ก็เอามาแปลงเป็นคอมโพเนนต์จริงได้ไวมาก สรุปคือ multi-agent ที่สั่งเป็นเวฟผ่าน tmux มันไม่ได้แค่เร็วขึ้นเพราะทำหลายอย่างพร้อมกัน แต่มันมีระเบียบขึ้นด้วย เพราะแยกชัดว่ารอบนี้กำลังหาข้อมูล หรือกำลังลงมือสร้าง
TL;DR:
- I wired a fleet of ~168 agents into tmux so each pane is one agent, all driveable from a single screen.
- I run them in waves: a research wave surveys first, then a build wave implements from those findings.
- As a real test, they built a TV-optimized visual design system for a vet waiting-room dashboard in SvelteKit + Tailwind.
Honestly, the moment you open the screen and see the whole fleet moving at once, it feels a little like the shadow-clone jutsu from Naruto — 5555 — spinning off a small army of clones that all work in parallel. The core idea is that I tied a fleet of around 168 agents to tmux, because tmux can split a screen into a lot of panes. Each pane is one agent doing its own job, so instead of jumping between windows I watch everything move together in a single view. It makes the whole thing much easier to orchestrate.
The power isn’t really in the agent count, though — it’s in dispatching work in waves. Personally I think that’s what makes it strong. Instead of letting everyone charge in at once in a mess, I split it into rounds. Wave one is research: several agents go gather information and survey design patterns. Once their findings are all back, I release wave two, build: a separate set of agents that actually implement, using what the research wave already found. The nice part is the builders aren’t guessing — they’re building on top of existing research, so the output comes out steady and pointed in one direction.
The task I used to test it this round was creating a TV-optimized visual design system for a vet clinic waiting-room dashboard, built with SvelteKit + Tailwind CSS. That one made me grin, because it lands right where my old vet life meets my dev work. I used to stand in the exam room; now I get to command a squad of agents to design the screen for the waiting room. The research wave looked into TV reading distance, font sizes, and contrast first, so the build wave could turn that into real components fast. In short, wave-based multi-agent orchestration through tmux isn’t just faster because things run in parallel — it’s also more orderly, because each round is clearly either finding information or building.
