ช่วงนี้ Fable (ตัว top model ตัวใหม่ของ Anthropic) เพิ่งกลับมา หลายคนน่าจะดีใจกัน แต่พอมาลองใช้จริงคือ… เอ่อ มันไม่เหมือนเดิมแล้วครับ ตอนนี้เอา Fable มาเขียน code ตรงๆ ไม่ได้แล้ว แถมยังใช้ได้แค่ 50% ของ limit ที่เคยมี เลยต้องหาวิธีใหม่ในการเอามันมาใช้ให้คุ้ม
พอดีไปเจอวิธีนึงที่มีคนโพสต์ไว้ใน X อ่านแล้วรู้สึกว่าน่าสนใจดี เลยเอามาลอง แล้วก็อยากมาแชร์ต่อ
ไอเดียมันคือ — แทนที่จะให้ Fable ลงมือเขียน code เอง เราให้มันเป็น main agent หรือ orchestrator แทน คือให้ Fable ทำหน้าที่แตกงานออกเป็น task ย่อยๆ แล้วก็กระจายงานต่อ งานที่ต้องคิดหนักๆ ต้องถกเถียง reasoning เยอะๆ ก็โยนให้ Opus กับ Codex ส่วนงานที่เป็นการลงมือทำจริง execute ตาม plan ก็โยนให้ Sonnet
ที่มันเวิร์คผมว่าเพราะ Sonnet เดี๋ยวนี้มันฉลาดขึ้นมากๆ พอเรามี plan ที่ดีอยู่แล้ว มันตาม execute ได้เป๊ะเลย ไม่ค่อยหลุด งานที่เป็น execution เลยไม่จำเป็นต้องใช้ model ที่แพงที่สุดก็ได้
อีกจุดที่ผมชอบคือ Fable กับ Codex มันกลายเป็นสอง agent หลักที่เอาไว้ “ถกกัน” คือแต่ละตัวมันมองปัญหาจากคนละมุม พอเอามาคุยกันเลยได้ความเห็นที่หลากหลายกว่าการใช้ตัวเดียว ผมมอง Codex เป็นเหมือน senior engineer อีกคนที่มานั่งคุยด้วย ไม่ใช่แค่ตัว review code เฉยๆ นะครับ คือมันเถียงกับเราได้ เสนอมุมที่เราไม่ได้คิดได้
ถ้าเป็นงานตัดสินใจใหญ่ๆ จริงๆ ผมชอบโยนโจทย์เดียวกันให้ทั้ง Opus กับ Codex ทำไปพร้อมๆ กัน โดยไม่ให้ตัวไหนเห็นคำตอบของอีกตัว แล้วค่อยเอาของดีจากทั้งคู่มารวมกัน ได้มุมสดๆ ไม่ตีกันเป็นพวกเดียว
พอเป็น workflow แบบวางแผนงาน หรือทำ PR ทีละอัน วิธีนี้มันช่วยเรื่อง orchestrate ได้ดีขึ้นเยอะเลย เพราะ Fable มันเก่งเรื่องมองภาพรวมแล้วสั่งงานต่อ
อีกเรื่องที่อยากบอกคือ — เลิกเอา Fable ไปรัน task ยาวๆ ได้แล้วครับ สมัยก่อนเราชอบปล่อยให้มันรันยาวๆ ทีเดียวจบ แต่ตอนนี้มันโดนแบนไปรอบนึง พอกลับมาก็มี limitation เยอะมาก ทางที่ดีกว่าคือให้ Fable วาง plan ให้เสร็จ แล้วส่งไม้ต่อให้ agent ตัวอื่นทำแทน อย่าไปเผา limit กับมันทั้งดุ้น
สรุปคือ ถึงจะเขียน code ตรงๆ ไม่ได้แล้ว แต่ Fable มันก็ยังเหมาะกับการเป็น main agent อยู่ดี แค่เปลี่ยน role มันจากคนลงมือ มาเป็นคนคุมทีมแทน
เผื่อใครอยากลองเซ็ตตาม ผมสรุปวิธีสั้นๆ ไว้ให้ครับ
- ใน Claude Code — /model เลือก Fable 5 แล้ว /effort ตั้งเป็น max ให้ Fable เป็น orchestrator ที่คิดเต็มที่สุด
- /agents สร้าง subagent สองตัว — ตัวแรกชื่อ deep-reasoner pin ไว้ที่ Opus (เอาไว้ทำงานที่ต้องคิดหนักๆ architecture, debugging, ออกแบบ algorithm สั่งให้มันคิดให้ลึกแล้วสรุปกลับมาสั้นๆ) อีกตัวชื่อ fast-worker pin ไว้ที่ Sonnet (เอาไว้ทำงาน mechanical พวก boilerplate, test, แก้ไขเล็กๆ น้อยๆ)
- ลง Codex plugin ตัว official ของ OpenAI (ต้องลง codex CLI ให้เรียบร้อยก่อนนะครับ) — /plugin marketplace add openai/codex-plugin-cc → /plugin install codex@openai-codex → /codex:setup
- เพิ่ม section เรื่อง orchestration workflow ลงใน CLAUDE.md — เขียนให้ชัดว่า Fable = orchestrator (วางแผน, แตกงาน, สังเคราะห์), งานคิด → deep-reasoner, งาน mechanical → fast-worker, Codex = peer engineer ที่มองคนละมุม, ถ้าเป็นงานตัดสินใจใหญ่ๆ ก็โยนโจทย์เดียวกันให้ Opus กับ Codex ทำพร้อมกัน แล้วเอาของดีจากทั้งสองมารวมกัน โดยไม่ให้ตัวไหนเห็นคำตอบของอีกตัว แล้วก็พยายามให้ context ของตัว orchestrator เองบางๆ ไว้
- สั่ง Fable เหมือนสั่ง tech lead คนนึงเลยครับ — “Goal: อยากได้อะไร … Context: ไฟล์กับข้อจำกัดที่เกี่ยวข้อง … นายเป็นหัวหน้านะ งานคิดโยนให้ deep-reasoner งานลงมือจุกจิกโยนให้ fast-worker งานที่อยากได้มุมใหม่ๆ โยนให้ Codex ขอดู plan ก่อน แล้วค่อยลงมือ”
ยาวไปไม่อ่าน สรุปก็คือ:
- Fable กลับมาแล้วก็จริง แต่เขียน code ตรงๆ ไม่ได้ และใช้ได้แค่ 50% ของ limit — ต้องเปลี่ยนวิธีใช้
- ให้ Fable เป็น orchestrator แตกงานแล้วกระจาย — reasoning ให้ Opus กับ Codex, execution ให้ Sonnet
- Fable กับ Codex เอาไว้ถกกันสองมุม มอง Codex เป็น senior engineer อีกคน ไม่ใช่แค่คน review
- อย่าเอา Fable ไปรัน task ยาวๆ อีกแล้ว ให้มันวาง plan เสร็จแล้วส่งต่อ
- Fable ยังเหมาะเป็น main agent อยู่ แค่เปลี่ยนบทจากคนโค้ด มาเป็นคนคุมทีม
ใครลองแล้วเป็นยังไง หรือมี setup ที่เจ๋งกว่านี้ มาแลกกันได้นะครับ
Fable — Anthropic’s new top model — just came back, and I think a lot of people were happy to see it. But once you actually start using it… well, it’s not the same as before. Right now you can’t use Fable to write code directly anymore, and on top of that you only get 50% of the usage limit you used to have. So you need a new way to actually get good value out of it.
I happened to come across an approach someone posted on X. It caught my eye, so I tried it — and now I want to pass it along.
The idea is this: instead of letting Fable write code itself, you make it the main agent, the orchestrator. Fable’s job is to break the work into smaller tasks and hand them out. The heavy-thinking, discussion-heavy, reasoning work goes to Opus and Codex; the actual hands-on execution — following the plan — goes to Sonnet.
I think it works because Sonnet has gotten seriously smart lately. Once you have a solid plan in place, it executes it faithfully and rarely goes off the rails. So the execution work really doesn’t need your most expensive model.
The part I like most is that Fable and Codex become the two main agents that “argue it out.” Each one looks at the problem from a different angle, so putting them in conversation gives you a much more diverse set of opinions than leaning on a single model. I treat Codex like another senior engineer sitting at the table, not just a code reviewer — it’ll push back on me and suggest angles I hadn’t considered.
For anything really high-stakes, I’ll throw the exact same problem at both Opus and Codex in parallel, without letting either one see the other’s answer, and then take the best of both. Fresh perspectives, no groupthink.
For workflows that are about planning work out, or doing one PR at a time, this setup improves orchestration a lot — because Fable is great at seeing the whole picture and directing traffic from there.
One more thing: stop using Fable for long-running tasks. We used to love just letting it run for ages and finish everything in one go, but it got banned for a while, and now that it’s back there are a lot of limitations. The better move is to have Fable finish the plan and then hand the baton to another agent. Don’t burn your whole limit on it in one shot.
Bottom line: even though it can’t write code directly anymore, Fable is still a great fit as the main agent. You just change its role — from the one doing the work to the one running the team.
If you want to set this up yourself, here’s the short version:
- In Claude Code — /model, pick Fable 5, then set /effort to max, so Fable is your orchestrator running at full reasoning.
- /agents, create two subagents. The first, deep-reasoner, pinned to Opus (for the heavy-thinking work — architecture, debugging, algorithm design; tell it to think thoroughly and return a concise conclusion). The second, fast-worker, pinned to Sonnet (for the mechanical stuff — boilerplate, tests, small edits).
- Install OpenAI’s official Codex plugin (you’ll need the codex CLI installed first): /plugin marketplace add openai/codex-plugin-cc → /plugin install codex@openai-codex → /codex:setup
- Drop an orchestration-workflow section into your CLAUDE.md. Spell it out: Fable = orchestrator (plan, decompose, synthesize); reasoning → deep-reasoner; mechanical → fast-worker; Codex = a peer engineer with a different perspective; for high-stakes decisions, hand the same problem to Opus and Codex in parallel and synthesize the best of both, without letting either see the other’s answer; and keep the orchestrator’s own context lean.
- Prompt Fable like you’d brief a tech lead: “Goal: … Context: the relevant files/constraints … You’re the lead. Delegate reasoning to deep-reasoner, grunt work to fast-worker, fresh-perspective problems to Codex. Show me your plan first, then execute.”
TL;DR:
- Fable is back, sure, but it can’t write code directly and you only get 50% of the limit — so you have to change how you use it.
- Make Fable the orchestrator that breaks work down and hands it off — reasoning to Opus and Codex, execution to Sonnet.
- Use Fable and Codex as two perspectives that argue it out; treat Codex as another senior engineer, not just a reviewer.
- Stop running long tasks on Fable — let it finish the plan and pass the rest along.
- Fable is still a great main agent — you’re just switching its role from coder to team lead.
If you’ve tried this, or you’ve got an even slicker setup, let’s compare notes.
