Agentic Engineering · One Request, Five Layers

An agentic system turns a single user query into a dozen-plus orchestrated steps across five cooperating layers. Press Play to watch one request flow through, then read the detailed component cards below.

Prompt

提示词

Instruction & control

Agent

智能体

Decide, dispatch, remember

LLM

大模型

Cognition engine

MCP

协议

Tool/agent connection

Tools

工具

Limbs & senses

Press Play or → to begin. Click any component card below to focus on it.

Trace log

Controls

Auto-play speed

FastSlow

Step 0 / 0

The Five Components Explained

The active component is highlighted as the animation plays. Click any card to read it in isolation.

01Prompt

提示词 — instruction & control

Role: The instruction layer. The "communication language" and "operations manual" between the user and the LLM — sets role, task, available tools, and the expected output shape.
Concrete example: You are a travel-planning expert. Use the web-search tool to find Beijing's weather for the next 3 days, and recommend indoor and outdoor activities.
Engineering question: Are your prompts versioned, reproducible, and traceable to behavior changes — or hand-edited every time?
When it fails: Vague prompts produce vague tool choice and hallucinated answers. Look here first when the agent confidently asserts false facts.

02Agent

智能体 — decision & execution center

Role

The orchestrator. Not the brain itself — it uses the LLM to think, then decides, dispatches, remembers, and verifies. Three jobs:

Planning (规划) — break complex tasks into steps
Memory (记忆) — preserve context across turns
Tool use (工具调用) — pick when/which tool

Concrete example

Claude Code, AutoGPT, ChatGPT's Advanced Data Analysis mode, custom agents on the OpenAI/Anthropic SDK.

Engineering question

Is the plan inspectable? When the agent picks the wrong tool, can you tell why — or is it a black box?

When it fails

Most "agent runtime" failures live here: missing timeouts, no retry path, runaway loops, memory leaks. Cost overruns usually trace back to this layer.

03LLM

大模型 — cognition engine

Role: The cognition layer — language understanding, reasoning, classification, generation. Analogous to the human brain: capable of thinking but with no senses or hands of its own.
Concrete examples: Claude, GPT-4/5, DeepSeek, Qwen, Llama, Gemini.
Engineering question: When you swap the LLM (Claude → GPT, etc.), what breaks in your system that shouldn't be model-specific?
When it fails: Hallucinations, non-determinism, reasoning errors. Set temperature, cache prompts, use a smaller/cheaper model for routing decisions.

04MCP

Model Context Protocol — connection standard

Role: The protocol boundary between agent/runtime and external tools or data. Officially a host → client → server architecture over JSON-RPC; servers expose tools/resources/prompts; clients discover and invoke them.
Why it exists: Solves the "tools aren't interchangeable" problem. Authors publish to one spec; compatible clients can discover and invoke compatible servers.
Engineering question: Are your tool boundaries explicit and least-privilege, or did you grant broad access "just to get it working"?
When it fails: Auth, version mismatches, transport timeouts, schema drift. MCP makes operations explicit but doesn't itself guarantee safe use — still need human-in-the-loop for sensitive actions.

05Tools

工具 — limbs & senses

Role

The action layer. The LLM by itself is "pure thought": it doesn't know today's weather, can't run code, and can't read your database. Tools let the system act.

Categories of tool

Web search — fetch fresh info
Code execution — run code, return result
Database query — retrieve data
API call — talk to other services

Engineering question

When a tool call fails, does the agent recover gracefully, retry intelligently, or hand the raw error back to the user?

When it fails

External outages, rate limits, schema changes. The fix often lives at the Agent layer (retry/fallback policy), not the Tool itself.

One-line summary Prompts spark intent · the LLM provides cognition · the Agent decides and dispatches · MCP standardizes the connection · Tools execute in reality.
The five together form the loop that lets AI both think and act.