Huang-HI1200×1505 80.4 KB

Huang Jia

A lot of us have moved past “can I call an LLM API?” and into the messier question: how do I build an agent that keeps working after the demo? The hard parts are familiar to anyone shipping software: cost, reliability, testing, permissions, failure recovery, observability, and deciding when a simple design is enough.

This book gives those problems a shared vocabulary.

Jia Huang, an AI researcher at A*STAR Singapore, organizes agent design around a two-axis framework:

• Seven cognitive functions: perception, memory, reasoning, action, reflection, collaboration, governance

• Six execution topologies: chain, route, parallel, orchestrate, hierarchy, loop

Together, those axes produce 27 reusable agent patterns. The point is to help teams stop arguing vaguely about “agent architecture” and start naming the actual design choice in front of them: context triage, hierarchical retention, complexity-based routing, tool dispatch, generator-critic loops, approval gates, blast-radius control, and so on.

The book also has a running build, which I think DevTalk readers will appreciate. You incrementally build Argus, a code-review agent that starts as a small perception-reasoning-action loop and grows into a more production-ready system. Each chapter adds a capability:

• perception, so Argus loads the right files instead of drowning in context

• memory, so it can carry lessons across sessions

• reasoning, so it can spend more thinking budget on hard changes and less on trivial ones

• action, so tool use is routed, checked, and bounded

• reflection, so it can critique and improve its own work with external signals

• collaboration, for multi-agent coordination

• governance, for permissions, audit trails, and progressive trust

One idea that runs through the book is simple but useful: the model spends; the harness budgets. Tokens, context, tool calls, trust, and human review are all limited resources. Good agent architecture is mostly deciding where those resources go.

The book is written for engineers who already know the basics of agents and want to build systems that are dependable enough to ship. It also looks at reference harnesses and production tools such as Claude Code, Cursor, and OpenClaw, plus case studies for DevOps incident response, compliance review, and research synthesis.

If your team is wrestling with questions like these, this one is worth a look:

• When should a task stay single-agent, and when does multi-agent coordination pay for itself?

• How do you stop context windows from becoming expensive junk drawers?

• What should an agent remember, and what should it forget?

• How do you test something probabilistic without pretending it is deterministic?

• What does “governance” look like as architecture rather than policy theater?

• Full details: Designing AI Agents - Huang Jia

Don’t forget you can get 45% off with your Devtalk discount! Just use the coupon code “devtalk.com” at checkout