How to Engineer Claude Agents for Stable Production: From Single Agent to Multi‑Agent Systems

TL;DR

Start with a single Agent; only add more when clear signals appear.

Three core values of multi‑Agent: context protection, parallel search, specialized division of labor.

Skills encode "how to do"; MCP encodes "what can be accessed".

Four‑layer stack: Agent Loop → Runtime → MCP → Skills.

Use progressive disclosure to keep prompts short.

Follow the concrete checklist at the end to get a system running tomorrow.

1. Put the Agent Back into the Correct Layer

Anthropic proposes a four‑layer architecture:

Agent Loop : decides the next step (reasoning).

Agent Runtime : actually executes the step (code, file system, sandbox).

MCP Servers : connects to external tools and data sources (Notion, Slack, databases).

Skills Library : stores workflows, standards, scripts, templates.

Key constraint: keep reasoning free of concrete processes (move them to Skills) and keep connection logic out of prompts (move it to MCP). Benefits include versionable Skills, auditable MCP connections, and shorter, more stable prompts.

2. Don’t Treat Multi‑Agent as the Default

Anthropic’s Jan 23 article states that in most cases a single Agent is sufficient. Adding agents multiplies token cost (3‑10×), coordination complexity, and observability problems.

Only add agents when you see one of three signals:

Context is drowned in noise : isolate the noisy sub‑task in a child Agent and let the parent receive a concise summary.

Search space is too large : split the space into non‑overlapping sub‑directions and run child Agents in parallel (accept higher token cost).

Too many tools cause interference : create domain‑expert child Agents, each with its own toolset.

Anthropic recommends slicing by "information flow" rather than by generic task type.

3. Skills: Turning Agents into Domain Experts

Skills package workflows, best practices, templates, and scripts into a version‑controlled file set. They are loaded progressively:

Metadata (name + one‑line description) – ~50 tokens, always shown.

SKILL.md (process skeleton) – ~500 tokens, loaded when Claude decides it’s needed.

references/ (long docs, examples, templates) – 2000+ tokens, loaded on demand.

This design lets you attach hundreds of Skills without blowing the context window.

Design Principles for a Skill

SKILL.md contains only the "skeleton": trigger keywords, ordered steps, fixed output format, quality gates.

Long knowledge lives in references/ and is loaded lazily.

Reusable scripts go into scripts/ (e.g., apply_template.py).

Skill complexity ranges from simple (~100 lines) to complex (>2500 lines). Start simple and iterate.

4. MCP: Standardised Connections

MCP isolates the engineering concerns of connectivity: permissions, retries, rate‑limits, auditability. It should never be baked into prompts.

Best results come from using Skills + MCP together. Example cases:

Meeting preparation : MCP fetches Notion pages; Skill defines the agenda generation workflow.

Financial analysis : MCP pulls data from S&P Capital IQ, Daloopa, Morningstar; Skill runs the valuation and compliance checks.

The combination yields controllable, auditable, and compliant outputs.

5. Signals from the 2026 Software‑Building Trends

Anthropic’s "Eight trends defining how software gets built in 2026" reports that ~60 % of developer work now uses AI, but only 0‑20 % can be fully delegated. Success comes from standardising processes, not from smarter models.

6. One‑Day Actionable Checklist

Make a single Agent controllable

Define completion criteria (format, required fields, failure conditions).

Force structured output (headings, tables, JSON).

Create a small evaluation set (10‑30 real samples) and run it after each change.

Scale to multi‑Agent only when signals appear

Context noise → isolate into a child Agent.

Large search space → parallel child Agents.

Tool clash → domain‑expert child Agents.

Extract workflows into Skills, not prompts

Identify the three most repeatable processes in your team and implement them as Skills.

Route all external system calls through MCP

Handle permissions, retries, and audit logs at the MCP layer.

Upgrade the model only after the engineering foundation is solid

Otherwise you’ll keep falling back to manual supervision.

Sample Skill Template (Meeting Prep)

---
name: Meeting Prep (Notion)
description: 为一次会议生成可复用的会议材料：背景、问题清单、决策点、风险与下一步
---
## 触发条件
- 用户说"准备会议 / 写会议材料 / 生成议程"
## 输入
- 会议主题
- 参会人（可选）
- 项目名或 Notion 链接（可选）
## 工作流程（严格按顺序）
1. 通过 MCP 搜索项目主页与最近 2 次会议纪要
2. 提取现状、未决问题、关键指标（不确定就标注"待确认"）
3. 生成议程（含每项的目标与预计时长）
4. 生成"需要对齐的问题清单"（按优先级排列）
5. 输出一页版会议材料（固定小标题，见下方）
## 输出格式（固定，每次必须按这个来）
- 📋 背景（一段话，不超过 100 字）
- 📊 现状（3 条，每条一句话）
- 🎯 本次要决策的 1～3 件事
- ⚠️ 风险与依赖（最多 5 条）
- ➡️ 下一步（负责人 / 截止时间 / 交付物）

Place heavy reference material (templates, standards) under references/ and load it only when needed.

7. Common Pitfalls to Check

Embedding team processes in the System Prompt – move them to version‑controlled Skills.

Unordered tool usage – define a strict workflow in a Skill.

Missing permission boundaries in connections – enforce them in MCP.

No fixed output format – specify it in the Skill.

Starting with multi‑Agent – first stabilise a single Agent.

No evaluation set – even a tiny test suite is better than none.

8. Further Reading

Extending Claude's capabilities with Skills and MCP servers – https://claude.com/blog/extending-claude-capabilities-with-skills-mcp-servers

Eight trends defining how software gets built in 2026 – https://claude.com/blog/eight-trends-defining-how-software-gets-built-in-2026

Building agents with Skills: Equipping agents for specialized work – https://claude.com/blog/building-agents-with-skills-equipping-agents-for-specialized-work

Building multi‑agent systems: when and how to use them – https://claude.com/blog/building-multi-agent-systems-when-and-how-to-use-them