Building Agents: Three Posters, One Working Method
Four "how to build AI agents" graphics reached us in one batch — two of them byte-for-byte identical, which is its own lesson about how this content propagates. Underneath the duplication sits one durable method, a genuinely useful cost breakdown of multi-agent patterns, and the real 2026 protocol stack. We merged the four into the working version, and gave the odd one out — a "1600× faster, bypasses bot detection" promo — the verdict it earned.
01 — The shared skeletonWhat survives across every build guide
Strip the tool logos and the two step-by-step guides describe the same durable sequence — the one that will still be true when today's frameworks are three versions old:
- Define the job and the done-condition. What the agent does, who it helps, what output counts as finished. Vague here, useless everywhere after.
- Structure input and output. Schemas, not free text — "think like an API." The single most durable technical step; it's what makes an agent composable.
- Give it reasoning and tools. A reasoning pattern (the posters say ReAct / chain-of-thought) plus real tool access — web, code, retrieval. Tools are what separate an agent from a chat.
- Add memory deliberately. Only the kinds you need — see the memory taxonomy in A-06. Every layer is a liability as well as a capability.
- Add guardrails and a protocol. System prompts, permissions, and a connection standard (MCP) so tools plug in the same way everywhere.
- Test on real tasks and monitor. Benchmarks, logs, feedback. The step the excited builder skips and the working operator never does.
Optional add-ons the posters list — voice, vision, a UI wrapper — are real capabilities but not part of the skeleton; add them when the job needs them, not to feel finished.
The specific tools the posters name are a 2024 snapshot and should be read as examples, not requirements: some remain current, some renamed, some faded. The skeleton is what's durable; the logos decay at product speed (the lesson of I-10). Model references like "GPT-4o / LLaMA 3.2" also date the source — the frontier has moved.
02 — Multi-agent patternsThe cost–value breakdown worth keeping
The strongest of the four graphics ranks six coordination patterns by cost. It's a sound decision aid:
| Pattern | Best for | Cost |
|---|---|---|
| Sequential | deterministic workflows with clear dependencies | $ |
| Parallel | independent tasks, latency reduction at scale | $$ |
| Hierarchical | reusable sub-agents, enterprise scale | $$$ |
| Generator–Critic | high-quality output where accuracy beats speed | $$$ |
| Human-in-the-loop | decisions with real consequences, compliance | $$$ |
| Composite | complex end-to-end automation | $$$$ |
The graphic's own best line is its warning on Composite: using it too early, for problems that don't need it, is the biggest mistake. Start at the cheapest pattern that solves the problem and climb only when forced — the same discipline as closed loops in A-05. Generator–Critic is just this library's maker/checker rule as a named pattern.
03 — The 2026 protocol stack, verifiedMCP and A2A are real
The graphic names two layers, and both check out against primary sources:
- MCP (Model Context Protocol) — the tool-connectivity layer: tools, APIs, retrieval, databases, external systems. Real, widely adopted, correctly described.
- A2A (Agent2Agent) — the agent-coordination layer. Verified and more mature than the graphic implies: originally from Google, transferred to the Linux Foundation in 2025, and reaching a stable v1.0 in 2026 with a steering committee spanning AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP and ServiceNow, plus SDKs in five languages. "Works with Google / AWS / Microsoft" undersells it — it's a cross-vendor standard, not a vendor feature.
04 — The odd one outA promo, weighed honestly
The fourth graphic isn't a build guide — it's an advertisement for a scraping library, headlined "1600× faster, bypasses bot detection, plugs into Claude Code." Three separate verdicts:
- The speed number: unsourced. "1600×" has no benchmark behind it in the graphic; a raw fetch will always dwarf a full browser render, so the figure is a comparison of unlike things dressed as a spec.
- "Bypasses bot detection": a red flag, not a feature. Evading Cloudflare and anti-bot systems runs against sites' terms of service and, increasingly, their legal protections. ImageFirm won't recommend a tool on that selling point — the same ethics stance as the jailbreak section in I-10.
- The real technique underneath: legitimate. Structured extraction
into clean JSON for agents is genuinely useful. The honest version reads
robots.txt, respects rate limits, and prefers official APIs — and it belongs to whichever well-maintained library you can actually verify, not to a comment-for-the-link post.
05 — The ledgerChecked 2026-08-06
| Claim across the four graphics | Verdict | The record |
|---|---|---|
| Define-job → structured-IO → tools → memory → guardrails → test skeleton | VERIFIED | Durable; matches every serious build guide. |
| ReAct / chain-of-thought as reasoning patterns | VERIFIED | Real, published techniques. |
| Six multi-agent patterns ranked by cost | VERIFIED | Sound decision aid; "don't reach for Composite early" is the key line. |
| MCP as the tool-connectivity layer | VERIFIED | Correctly described, widely adopted. |
| A2A as the agent-coordination layer | VERIFIED | Linux Foundation project, stable v1.0 in 2026, cross-vendor. |
| Named tool rosters (LangChain, CrewAI, Zep, ChromaDB, …) | NUANCE | 2024 snapshot — examples, not requirements; some have moved. |
| Model names GPT-4o / LLaMA 3.2 as current | NUANCE | Dated; the frontier has advanced. Read as of their authoring. |
| "1600× faster" scraping | NO SOURCE | No benchmark; compares unlike operations. |
| "Bypasses bot detection" as a selling point | NO SOURCE | ToS-hostile; not endorsed. The lawful technique stands on its own. |
| Two of the four graphics are the same file | VERIFIED | Byte-identical duplicate — merged, not published twice. |