# From Loops to Graphs: How to Run a Real Team of AI Agents
**作者**: shmidt
**日期**: 2026-07-23T15:00:05.000Z
**来源**: [https://x.com/shmidtqq/status/2080306964068790561](https://x.com/shmidtqq/status/2080306964068790561)
---
It is a quiet morning. No tabs are open, no coffee is even poured. Yet a finished report on the question you typed in one line last night is already sitting on the screen.
Five researchers dug at it overnight, each from a different angle, all in parallel. A sixth agent went down every finding and tried to kill it: is it made up, is it stale, does the source actually exist. What did not survive the check never reached the report. What did survive is in front of you, ranked by confidence, with links attached.
The last word is yours. You read it and decide what to do. You have not clicked a single button yet.
This is not new magic, and it is not another one-month hype cycle. It is a graph: a pattern critical systems have run on for decades, now pointed at a team of AI agents instead of a data pipeline.
One blunt truth before the fun begins: a graph buys breadth, not judgment. Five agents will find more than one, but they will not reason better than one. Confuse the two and you will pay for a team where a single agent would have done.
A couple of weeks ago you maybe stepped out of a loop for the first time and let the model run on its own. And the timeline has already declared loops yesterday's news, with the whole conversation moving to graphs. The good news is there is nothing here you cannot get in one evening, and not a line of code to write.
This piece covers seven things:
1. what a graph actually is, from the ground up
2. the diamond, the one pattern that genuinely pays
3. the stop rule that protects your bill
4. where exactly you stand in the whole thing
5. three ready graphs you can paste and run today
6. how to build your first graph in ten minutes
7. the traps everyone walks into
Before we dive in: I post daily notes on AI and agents in my Telegram channel, along with ready prompts and breakdowns: https://t.me/shmidtai. It is free.
## Part 1 · What a Graph Is, From the Ground Up
1.1 A graph is a plan for your work, drawn out
Drop the word "graph" for a second, along with everything you have seen in the posts. At heart it answers two questions: which jobs need to happen, and which job has to wait for which.
A job is something you would hand to one assistant: research one competitor, write one draft, check one claim. One job, one node.
When a job needs the result of another job before it can start, you connect the two with an arrow. And a small set of running notes travels with the work: what was found, what was decided, what is still left. That is the whole vocabulary. Nodes, arrows, notes.
The loop everyone was talking about last month is a graph of one node wired back to itself: do it, check it, not done, again. A graph is the same line of thinking, only now there are several jobs, and some of them can run at once.
1.2 Half your arrows are fake
Here is the one exercise worth doing tonight, before you open a single new tool.
Take the system you run right now, and for every "and then" inside it, ask one question: does the next job actually need the last job's result?
"Summarize this file and then check my calendar" sounds like a sequence. But the calendar step never needs the summary, not for a second. Those two jobs were never required to wait for each other. The arrow between them is fake, and the waiting is pure waste.
An arrow is real only when work actually flows through it. Draw your own system and you will find two or three fake arrows in any of them. Right now your system probably runs as one straight line where every job waits for the one before it. That works. And it is the slowest possible way to run things, because one stuck step blocks everything behind it.
A quick test for a fake arrow: cover the previous job with your thumb. If the next one can still start, there is no arrow between them, whatever your instinct says.
A short glossary so the rest reads clean:
- Node: one job for one agent.
- Arrow (edge): "this job waits on that one." Real only if work flows through it.
- State: the running notes, what was found and decided, riding along with the work.
- Fan-out: the moment one job splits into several running in parallel.
- Diamond: the shape "split, gather in parallel, check, merge back."
- Gate: the point where the flow hits a human and waits for their yes.
## Part 2 · The Diamond, the One Pattern That Pays
Watch any serious agent system work and the same picture keeps surfacing. The work splits. Several workers dig side by side. Something checks what they found. And it all merges back into one answer.
That picture is called the diamond, and I am fairly confident it is the only pattern you will need this year.
This is not whiteboard theory. The research feature inside Claude is built exactly this way: a lead agent plans, workers gather in parallel, each in its own separate context window, and a separate agent verifies the sources before anything reaches you. By Anthropic's own measurement, that team beat a single agent on the same engine by more than 90 percent on their internal research eval.
-> How we built our multi-agent research system, Anthropic
The reason is not that there were more agents. The reason is that the reasoning was spread across several separate context windows, which is a breadth a single agent physically cannot reach: it has one window, and it blurs.
Now the part everyone scrolls past. The check. Treat it as part of the pattern, not an option.
When researchers asked models point blank where the error was in their own chain of reasoning, the best of them got it right 52.9 percent of the time. That is barely better than a coin flip. Yet when the error is pointed out, the model fixes it well. The takeaway is simple: a model is close to useless at finding its own mistakes and good at fixing the ones you show it.
-> Can large language models identify and correct their mistakes?, Google Research
Hence the iron rule: never let an agent grade its own homework. Give the checking to a separate job whose only task is to kill weak findings before they reach you. And give every checker a different question. One asks if it is correct. One asks if it is current. One asks if the source exists at all. Three different questions catch three kinds of flaw; three identical ones catch only one.
One more rule for the checker: it only reads. Give it write access and it will quietly patch a weak finding instead of rejecting it. Same logic as a copy editor in a newsroom and a second approver on a payment: the second party is reliable not because it is smarter, but because it does not carry the first one's history.
2.1 What this pattern is already inside
The diamond is not something you have to invent. It already sits inside tools you may be using:
- Claude Code, sub-agents. It can run several sub-agents in parallel and merge their output when the prompt asks it to branch out (the word "workflow" is one such signal). This is where to start, with nothing extra installed.
- Research in Claude, that same lead agent plus parallel workers plus source verification. A live diamond in production, with the +90 percent number attached.
- The "orchestrator-workers" pattern Anthropic wrote up separately: an orchestrator splits the task, workers do the pieces, the orchestrator merges. That is the diamond in other words.
- LangGraph and similar frameworks, where you write nodes and edges explicitly, in code. Reach for them when the graph gets large and needs versioning and reuse.
-> Building effective agents, Anthropic
The takeaway is not "install another framework," it is the opposite: one tool runs your first graph today. You add a framework later, and only when you can name the reason you need it.
## Part 3 · The Stop Rule That Protects Your Bill
More agents is not automatically better, and this is the part of the course that saves you real money.
When a team of agents and a single agent are handed the same budget, the team wins clearly on work that splits into independent pieces, and loses just as clearly on work where each step leans on the one before it. Breadth, the graph buys. Judgment, it does not.
That breadth carries a price tag, and not a small one. That same research team inside Claude burns roughly fifteen times more tokens than a normal chat. Fifteen times. On work that honestly splits, it is worth it. On work where everything is connected, you are just emptying your account fifteen times faster for an answer a single agent would have given for less.
A short picker to run before you launch anything:
```
One-off task -> a single sharp prompt
Recurring, but steps chain together -> one agent, or a loop
Recurring and splits into pieces -> a graph (diamond)
```
And on unit economics, because the "15x" number scares people for no reason. If a decision worth thousands sits behind the answer (a price, a hire, a market), the extra tokens are cents against dollars, and the graph pays off on the first run. If you run a diamond on connected trivia a single agent would close for pennies, you are paying fifteen times over for a mediocre answer. The graph is not expensive. A graph in the wrong place is.
Hence the stop rule, and it is short.
Before you add a single agent, ask the one question that decides the size of the bill: where does my work split? Where every step needs the full picture, stay with one agent. The moment the work breaks into pieces that never read each other's results, that is when the graph starts to pay. Not before.
It is the exact same discipline as with loops. A tool is stronger not where it is more complex, but where the task actually fits it.
## Part 4 · You, the Last Node
You are the most important node in your own graph, and this part is about where exactly you should stand.
Every serious system routes the flow to a human before anything that cannot be undone. The send, the publish, the refund, the invoice, those are arrows that should end at you. Your approval is the last yes between a draft assembled on a pipeline and the outside world.
Klarna learned this one in public. The company pushed AI support across the equivalent of around 700 roles, then admitted the tilt toward cost cutting hurt service quality, and brought humans back as a premium layer on top of the AI. Its CEO, Sebastian Siemiatkowski, said it plainly: an overemphasis on cost cutting led to poorer service.
-> Klarna reverses on AI, says customers like talking to people, Forbes
The design rule fits in one line: put your approval where a mistake would be expensive to undo, not on every step. A gate on everything makes you the bottleneck. A gate on nothing means nobody is watching.
And four small rules that keep the graph from turning into an expensive accident:
- Every loop inside the graph has a ceiling on how many rounds it can run.
- Only one job writes to any one file. Two writers on one file is guaranteed corruption.
- The routing lives in written steps, and the AI fills the jobs. You set the shape, the model does the content.
- There is always a cap on how many agents can spawn, so the graph cannot breed them without end.
And judge the system by numbers that cannot lie: money that landed, customers that stayed, tests that passed. A system that only grades its own reports is confidently wrong.
## Part 5 · What It Looks Like When It Runs
Here is what a run looks like when the graph is actually working. You do not see a wall of text, you see a short log:
```
Split: question divided into 5 angles
Launch: 5 researchers in parallel
Gather: 23 findings, each with a link and a date
Skeptic: 9 findings killed (no source, stale)
Merge: 14 survivors, ranked by confidence
Pause: waiting on your yes before saving the report
```
Nine findings out of twenty-three did not survive the check. That is the product. The difference between research and rumor collection is exactly that skeptic pass.
If you doubt that a team of agents is serious and here to stay: Anthropic's engineers built a working C compiler with a team of 16 parallel Claudes, around 100,000 lines of Rust. Not a three-function toy, a compiler. That is the upper edge of what the pattern already carries today.
-> Building a C compiler with a team of parallel Claudes, Anthropic
## Part 6 · Three Graphs That Pay for Themselves
Each build below runs in Claude Code, ends with the exact prompt you paste, and keeps you as the gate. Claude Code can run sub-agents in parallel, and the prompt asks it to do exactly that: several researchers at once plus a separate checker, instead of one line of steps. The word "workflow" is the signal to branch out.
The prompts are kept as-is; models read them more precisely that way, and you do not have to write a line of code.
6.1 The Research Desk
Think of the last decision you made with real money behind it: a price change, a new offer, a market you almost entered. You probably decided it on a week of googling or an expensive analyst invoice. This graph replaces both.
Your question splits into five angles, five researchers dig at once, a skeptic attacks every finding, and only the survivors reach the final report, with their sources.
How to run it: open Claude Code in an empty folder, write your real question in one line, paste the prompt, watch the fan-out and the skeptic pass, read the report. Only what survives your read enters the decision.
```
i need decision-grade research on: [your question]. use a workflow:
split the question into 5 distinct angles, run one researcher per
angle in parallel, every finding needs a source link and a date,
then run a skeptic against each finding that tries to disprove it,
drop what fails, merge the survivors into one report ranked by
confidence, save it as research-report.md and show me the top findings
```
The first run takes minutes instead of days. The skeptic pass is the real product here: it is the difference between research and a collection of pretty rumors.
Tip: add a line to the end, "list what you could not verify." The list of what it failed to confirm is often more valuable than the findings, because it shows you where not to lean.
6.2 The SEO Content Machine
Be honest about your publishing schedule. For a lot of people it either costs a monthly retainer or it simply stopped happening. This graph produces one ranking-ready draft per run and never publishes without you.
Three researchers work side by side: one breaks down what the current top pages cover, one collects the real questions people ask about the topic, one finds what everyone skips. Their work merges into an outline, a draft is written from it, the draft is fact-checked, and it waits in your folder for your yes.
How to run it: take the one topic your customers type into search, paste the prompt, the three research jobs run at once, and the draft lands in a drafts folder with every shaky claim flagged at the top. You read it, fix what only you would know, and publish it yourself. Then ask Claude to save the workflow, and every Monday it becomes one command instead of an afternoon.
```
i want an article that can rank for: [topic]. use a workflow: run
three research jobs in parallel, one lists what the current
top-ranking pages cover, one collects the real questions people ask
about this topic, one finds what the top pages skip, merge all three
into an outline, write a full draft from the outline, then run a
fact-checker that flags every claim without a source, save the draft
to drafts/ with the flagged claims listed at the top, never publish
anything
```
Tip: keep the skeptic and the fact-checker as separate nodes with different questions. One checks the facts, the other checks whether the piece answers the reader's real question. Fuse them into one and you lose half the value.
6.3 The Go-to-Market Kit
You are launching something: a product, an offer, a service. The honest options were always two, weeks of prep or launching blind. This graph produces the full kit in one run, and you approve every piece.
Three researchers profile the buyer, the channels, and the competition in parallel. Their work merges into a one-page positioning doc, and the system pauses right there so you can read it: that page becomes the foundation every asset gets checked against. Then three writers produce the landing copy, the launch posts, and the outreach messages in parallel, a checker flags anything that drifted from the positioning, and the kit lands in a folder where nothing ships on its own.
How to run it: name the product and who it is for, one line each. Paste the prompt. Read the positioning page when the system pauses, the one step I would never skip. Let the three writers produce the assets, review what the checker flagged, and approve piece by piece.
```
i'm launching [product] for [audience]. use a workflow: run three
research jobs in parallel, one profiles the buyer and collects the
exact words they use, one maps where these buyers spend time online,
one collects how competitors pitch them, merge into a one-page
positioning doc and pause to show it to me, then run three writers in
parallel from that doc: landing page copy, a week of launch posts, a
set of outreach messages, then run a checker that compares every
asset against the positioning doc and flags anything off, save
everything to launch-kit/ and change nothing after that without
asking me
```
The pause on the positioning doc is not a courtesy, it is a gate. The one page you approved sets the voice for every asset at once. Skip it and the three writers scatter into three different brands.
## Part 7 · Build Your First Graph in Ten Minutes
You have seen the theory, now the hands. Take a real question with money behind it and build the research desk from 6.1. On the clock:
```
3 minutes -> write the question and name 5 angles to dig it from
3 minutes -> paste the prompt with the word "workflow," launch the fan-out
2 minutes -> add a skeptic node whose job is to kill findings with no source
2 minutes -> add the gate: a pause and your yes before the report is saved
```
That is it. You have a working diamond and an understanding almost nobody on your timeline has. From here it is two moves only: save the workflow so it becomes one command, and add angles or checkers as you see where the graph goes blind.
Rule of the first graph: let it be ugly. Five angles instead of a perfect seven, one skeptic instead of three. A working rough graph teaches you more than a perfect one on paper.
## Part 8 · The Traps Everyone Walks Into
A graph breaks in predictable ways. Here are five breaks as symptom, cause, fix, so you recognize them before they get expensive.
- The file turned to mush. Cause: two nodes wrote to it at once, racing. Fix: one writer per file, the rest read only. Want to assemble from pieces, add a dedicated merge node at the end.
- The skeptic waves everything through. Cause: you gave it the same question as the author, so it thinks the same way. Fix: hand the checker a different angle, "does the source exist," "is it current," not "is the work good."
- The bill hit the ceiling. Cause: the graph had no cap on agents or rounds, so it bred them. Fix: a hard cap on agents and a max number of rounds on every loop, always.
- You became the bottleneck. Cause: a gate sits on every step, so the graph waits on you constantly. Fix: gates only where a mistake is expensive to undo, let the rest flow.
- You paid 15x for a mediocre answer. Cause: a fan-out on connected work, where each step needed the last. Fix: go back to "where does the work split," and if there is no answer, stay with one agent.
The common thread across all five: a graph punishes a skipped rule with exactly the thing that rule protected. That is where the discipline comes from.
## Part 9 · The Part Nobody Advertises
A graph changes the shape of the work. It does not remove you from it. And two things get worse, not better, as the graph gets good.
- The cost nobody mentions. The breadth you buy costs tokens, and we already saw the number: roughly fifteen times more than a normal chat. A graph pointed at connected work, where everything depends on everything, is the most expensive way to get a mediocre answer.
- Comprehension debt grows faster. A loop shipped code you did not write. A graph ships more of it, and faster, because it runs in parallel. The more smoothly it turns, the wider the gap between what goes out and what you have actually read.
And one trap that costs more than all of them. Skip that last yes and the graph ships its first confident mistake straight to a customer. A gate on everything makes you the bottleneck. A gate on nothing means the first confident miss goes out into the world under your name.
The takeaway is not discouraging, just realistic: a graph is a reach amplifier, not a replacement for judgment. Judge it by the numbers that cannot argue back, and keep a hand on the last gate.
## Cheat sheet
Take this and apply it without rereading the rest:
1. Fake edges first. Run nothing new until you have deleted the arrows no work flows through.
2. Split only what never reads each other's results. Keep anything step-by-step on one agent.
3. No finding travels unchecked, and no two checkers ask the same question.
4. The checker only reads, so it cannot quietly patch the weak stuff.
5. Every loop inside the graph has a ceiling on its rounds, and so does the agent count.
6. One writer per file. The routing lives in written steps, the AI fills the jobs.
7. The last yes sits exactly where a mistake would be expensive to undo.
8. One tool is enough until you can name the reason it is not.
Three questions to ask before you build a graph:
- Where does my work actually split into independent pieces?
- What here is so expensive to undo that it should end at me?
- Would this finding survive a separate skeptic asking a different question?
## Zoom out
Loops were a shift in who does the work. Graphs are a shift in how much of the work runs at once. But the point where all of it meets the real world has not moved an inch. It stayed exactly where it was, with you.
A graph does not make you smarter. It makes you wider. It takes on the waiting, the parallelism, the first cut of the weak stuff, and hands you back the seat the whole thing was built for: the last decision, with the full picture in hand.
Loops took manual prompting off your hands. Graphs take the manual waiting. Neither one takes the thinking, that stays with you. If you keep a single thing from this, keep that, then go draw your own system tonight, count the fake edges, and delete them. It costs nothing and usually removes more waiting than any tool you could buy.
If this landed, save it and follow me, there will be more ready graphs, prompts and breakdowns: https://t.me/shmidtai
@shmidtqq
## 相关链接
- [shmidt](https://x.com/shmidtqq)
- [@shmidtqq](https://x.com/shmidtqq)
- [5.9K](https://x.com/shmidtqq/status/2080306964068790561/analytics)
- [https://t.me/shmidtai](https://t.me/shmidtai)
- [How we built our multi-agent research system, Anthropic](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Can large language models identify and correct their mistakes?, Google Research](https://research.google/blog/can-large-language-models-identify-and-correct-their-mistakes/)
- [Building effective agents, Anthropic](https://www.anthropic.com/research/building-effective-agents)
- [Klarna reverses on AI, says customers like talking to people, Forbes](https://www.forbes.com/sites/quickerbettertech/2025/05/18/business-tech-news-klarna-reverses-on-ai-says-customers-like-talking-to-people/)
- [Building a C compiler with a team of parallel Claudes, Anthropic](https://www.anthropic.com/engineering/building-c-compiler)
- [https://t.me/shmidtai](https://t.me/shmidtai)
- [@shmidtqq](https://x.com/@shmidtqq)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [11:00 PM · Jul 23, 2026](https://x.com/shmidtqq/status/2080306964068790561)
- [5,908 Views](https://x.com/shmidtqq/status/2080306964068790561/analytics)
- [View quotes](https://x.com/shmidtqq/status/2080306964068790561/quotes)
---
*导出时间: 2026/7/24 10:24:11*
---
## 中文翻译
# 从循环到图：如何运行一个真正的 AI 智能体团队
**作者**: shmidt
**日期**: 2026-07-23T15:00:05.000Z
**来源**: [https://x.com/shmidtqq/status/2080306964068790561](https://x.com/shmidtqq/status/2080306964068790561)
---
这是一个宁静的早晨。没有打开任何标签页，甚至咖啡都还没倒。然而，一份关于你昨晚输入的那行问题的完整报告，已经呈现在屏幕上。
五位研究人员连夜钻研，每个人从不同的角度切入，全部并行进行。第六个智能体逐一审查每个发现，试图扼杀它：这是编造的吗？是过时的吗？来源真的存在吗？未通过审查的内容绝不会进入报告。通过审查的内容就在你面前，按置信度排名，并附有链接。
最后一句话由你来说。你阅读它并决定怎么做。你至今还没点击过一个按钮。
这不是什么新的魔法，也不是又一个为期一个月的热度周期。这是一个图：一种关键系统运行了几十年的模式，现在指向的是一个 AI 智能体团队，而不是数据流水线。
在开始有趣的内容之前，有一个直白的真理：图带来的是广度，而非判断力。五个智能体比一个能发现更多东西，但它们不会比一个推理得更好。混淆这两者，你将为一个团队买单，而原本一个智能体就能搞定。
几周前，你可能第一次跳出循环，让模型自主运行。时间线已经宣告循环已成昨日黄花，整个对话已经转向图。好消息是，这里没有什么你花一个晚上掌握不了的，也不需要写一行代码。
本文涵盖了七件事：
1. 图到底是什么，从零开始
2. 钻石型，唯一真正有回报的模式
3. 保护你账单的停止规则
4. 你在整个事情中究竟处于什么位置
5. 三个今天就可以复制并运行的现成图
6. 如何在十分钟内构建你的第一个图
7. 每个人都会踩进的陷阱
深入之前：我每天在我的 Telegram 频道上发布关于 AI 和智能体的笔记，附带现成的提示词和拆解：https://t.me/shmidtai。这是免费的。
## 第 1 部分 · 什么是图，从零开始
1.1 图是你的工作计划，画出来
先把“图”这个词放下，还有你在帖子里看到的所有东西。从根本上说，它回答了两个问题：哪些工作需要发生，以及哪个工作必须等待哪个工作。
一项工作就是你会交给一个助手的事情：研究一个竞争对手，写一个草稿，检查一个主张。一项工作，一个节点。
当一个工作需要另一个工作的结果才能开始时，你用箭头将它们连接起来。一些简短的运行笔记伴随着工作：发现了什么，决定了什么，还剩什么。这就是全部词汇。节点，箭头，笔记。
上个月大家都在谈论的循环，就是一个节点连回自身的图：做它，检查它，没做完，再来一次。图是同样的思维方式，只是现在有几项工作，其中一些可以同时运行。
1.2 你有一半的箭头是假的
这是今晚值得做的一个练习，在你打开任何新工具之前。
拿出你现在的系统，对其中的每一个“然后”，问一个问题：下一项工作真的需要上一项工作的结果吗？
“总结这个文件，然后检查我的日历”听起来像是一个序列。但检查日历这一步从来不需要总结，一秒钟也不需要。这两项工作从来不需要互相等待。它们之间的箭头是假的，等待纯属浪费。
只有当工作真正流经其中时，箭头才是真实的。画出你自己的系统，你会发现其中任何一个都有两三个假箭头。现在你的系统可能像一条直线一样运行，每项工作都在等待前一项。这行得通。但这是最慢的运行方式，因为一个卡住的步骤会挡住后面的一切。
测试假箭头的快速方法：用拇指盖住前一项工作。如果下一项仍然可以开始，那么无论你的直觉告诉你什么，它们之间都没有箭头。
简短的词汇表，以便阅读后续内容顺畅：
- 节点：一个智能体的一项工作。
- 箭头（边）：“这项工作等待那项工作。”只有当工作流经它时才是真实的。
- 状态：运行笔记，即发现和决定的内容，随着工作一起流转。
- 分叉：一项工作分裂成几项并行运行的时刻。
- 钻石型：“分裂，并行收集，检查，合并回来”的形状。
- 门控：流程到达人类并等待其确认的节点。
## 第 2 部分 · 钻石型，唯一有回报的模式
观察任何严肃的智能体系统工作，同样的画面不断浮现。工作分裂。几个工人并排挖掘。某种东西检查他们发现的东西。所有这些都合并回一个答案。
这个画面被称为钻石型，我相当有信心这是今年你唯一需要的模式。
这不是白板理论。Claude 内部的研究功能正是这样构建的：一个主导智能体做计划，工人们并行收集，每个都在自己独立的上下文窗口中，还有一个独立的智能体在 anything reaches you 之前验证来源。根据 Anthropic 自己的测量，该团队在内部研究评估中，比同一引擎上的单个智能体高出了 90% 以上。
-> 我们如何构建多智能体研究系统，Anthropic
原因不在于有更多的智能体。原因在于推理分布在几个独立的上下文窗口中，这是单个智能体在物理上无法达到的广度：它只有一个窗口，而且会模糊。
现在到了每个人都会跳过的部分。检查。将其视为模式的一部分，而不是一个选项。
当研究人员直接问模型它们自己的推理链条中错误在哪里时，最好的模型只有 52.9% 的时候答对了。这比抛硬币好不了多少。然而，当错误被指出时，模型能很好地修复它。结论很简单：模型在发现自己的错误方面几乎无用，但在修复你展示给它的错误方面很擅长。
-> 大型语言模型能识别并纠正自己的错误吗？，Google Research
因此有了铁律：永远不要让智能体批改自己的作业。将检查工作交给一项单独的工作，其唯一任务是在薄弱的发现到达你之前扼杀它们。给每个检查器一个不同的问题。一个问是否正确。一个问是否当前。一个问来源是否真的存在。三个不同的问题捕捉三种缺陷；三个相同的问题只捕捉一种。
给检查者还有一个规则：它只读。给它写权限，它会悄悄地修补一个薄弱的发现而不是拒绝它。这就像新闻编辑室里的文字编辑和付款的第二审批人：第二方之所以可靠，不是因为它更聪明，而是因为它不携带第一方的历史。
2.1 这种模式已经在哪些东西里面
钻石型不是你必须发明的。它已经存在于你可能正在使用的工具中：
- Claude Code，子智能体。它可以在提示词要求它分支（“工作流”这个词就是这样一个信号）时并行运行几个子智能体并合并它们的输出。这是开始的地方，不需要额外安装任何东西。
- Claude 中的研究，同样的主导智能体加并行工人加来源验证。一个生产中的实时钻石型，带有 +90% 的数字。
- Anthropic 单独写下的“编排者-工人”模式：编排者拆分任务，工人做部分，编排者合并。换句话说，这就是钻石型。
- LangGraph 和类似的框架，你在代码中显式地编写节点和边。当图变大并且需要版本控制和重用时，可以接触它们。
-> 构建有效的智能体，Anthropic
结论不是“安装另一个框架”，而是相反：一个工具今天就能运行你的第一个图。你稍后再添加框架，只有当你能说出需要它的理由时。
## 第 3 部分 · 保护你账单的停止规则
更多的智能体并不自动意味着更好，而这一部分是真正为你省钱的课程。
当一个智能体团队和单个智能体被赋予相同的预算时，团队在分裂成独立部分的工作上明显获胜，而在每一步都依赖前一步的工作上则明显失败。图买来的是广度。它不买判断力。
这种广度带有价格标签，而且不是个小数目。Claude 内部同样的研究团队消耗的 token 大约是普通聊天的十五倍。十五倍。在诚实分裂的工作上，这是值得的。在一切都相连的工作上，你只是以十五倍的速度清空你的账户，为了得到一个单个智能体只需更少成本就能给出的答案。
在启动任何东西之前运行的一个简短选择器：
```
一次性任务 -> 一个犀利的提示词
重复性，但步骤连在一起 -> 一个智能体，或一个循环
重复性且分裂成几块 -> 一个图（钻石型）
```
关于单位经济效益，因为“15 倍”这个数字毫无理由地吓到了人们。如果一个价值数千美元的决定取决于答案（一个价格、一次招聘、一个市场），额外的 token 相对于美元来说是几分钱，而且图在第一次运行时就回本了。如果你在连接琐碎的事情上运行钻石型，而单个智能体只需几分钱就能搞定，你就是在为一个平庸的答案支付十五倍的代价。图并不贵。放错了地方的图才贵。
因此有了停止规则，它很短。
在添加一个智能体之前，问一个决定账单大小的问题：我的工作在哪里分裂？在每一步都需要全貌的地方，坚持使用一个智能体。当工作分裂成从不阅读彼此结果的部分时，就是图开始有回报的时候。不是在此之前。
这与循环所需的纪律完全相同。一个工具之所以更强大，不在于它更复杂，而在于任务实际上适合它。
## 第 4 部分 · 你，最后一个节点
你自己的图中最重要的是你，这一部分是关于你究竟应该站在哪里。
每个严肃的系统都会在任何不可撤销的事情之前将流程路由给人类。发送、发布、退款、发票，这些是应该结束于你的箭头。你的批准是流水线上组装的草稿与外部世界之间最后的“是”。
Klarna 公开地学到了这一课。公司在相当于约 700 个职位上推行了 AI 支持，然后承认倾向于削减成本损害了服务质量，并将人类作为 AI 之上的高级层带了回来。其首席执行官 Sebastian Siemiatkowski 直言不讳：过分强调削减成本导致了更糟糕的服务。
-> Klarna 在 AI 上回撤，称客户喜欢与人交谈，Forbes
设计规则可以总结为一行：将你的批准放在难以撤销错误的地方，而不是每一步。在所有地方都设置门控会让你成为瓶颈。没有任何门控意味着没有人监视。
还有四条小规则，防止图变成一场昂贵的事故：
- 图内的每个循环都有运行轮次的上限。
- 只有一个工作写入任何一个文件。两个写手在一个文件上保证会造成损坏。
- 路由存在于书面步骤中，AI 填充工作。你设定形状，模型做内容。
- 总是有多少个智能体可以生成的上限，这样图就不能无休止地繁殖它们。
并用不能撒谎的数字来判断系统：到账的钱、留下的客户、通过的测试。一个只给自己报告打分的系统是自信地错误。
## 第 5 部分 · 它运行时的样子
当图实际工作时，运行的样子是这样的。你看到的不是一堵文字墙，你看到的是一段简短的日志：
```
Split: 问题分为 5 个角度
Launch: 5 个研究人员并行运行
Gather: 23 个发现，每个都有链接和日期
Skeptic: 9 个发现被扼杀（无来源、过时）
Merge: 14 个幸存者，按置信度排名
Pause: 在保存报告前等待你的确认
```
二十三个发现中有九个未能通过检查。这就是产品。研究和谣言收集的区别恰恰在于怀疑论者这一关。
如果你怀疑智能体团队是严肃的并且会留下来：Anthropic 的工程师用一个由 16 个并行 Claude 组成的团队构建了一个可工作的 C 编译器，大约 100,000 行 Rust。不是一个三个功能的玩具，而是一个编译器。这就是该模式目前所能承载的上限。
-> 用并行 Claude 团队构建 C 编译器，Anthropic
## 第 6 部分 · 三个能回本的图
下面的每个构建都在 Claude Code 中运行，以你要粘贴的确切提示词结束，并让你作为门控。Claude Code 可以并行运行子智能体，提示词要求它完全这样做：一次几个研究人员加上一个单独的检查者，而不是一行步骤。“工作流”这个词是分支的信号。
提示词保持原样；模型读取它们更精确，而且你不必写一行代码。
6.1 研究台
想一想你最后一次背后有真金白银的决定：改变价格、新优惠、你差点进入的市场。你可能是根据一周的谷歌搜索或昂贵的分析师发票来决定的。这个图取代了两者。
你的问题分裂成五个角度，五个研究人员同时挖掘，一个怀疑论者攻击每一个发现，只有幸存者进入最终报告，并带有来源。
如何运行它：在一个空文件夹中打开 Claude Code，在一行中写下你的真实问题，粘贴提示词，观察分叉和怀疑论者通过，阅读报告。只有幸存于你阅读的内容才能进入决定。
```
i need decision-grade research on: [your question]. use a workflow:
split the question into 5 distinct angles, run one researcher per
angle in parallel, every finding needs a source link and a date,
then run a skeptic against each finding that tries to disprove it,
drop what fails, merge the survivors into one report ranked by
confidence, save it as research-report.md and show me the top findings
```
第一次运行需要几分钟而不是几天。怀疑论者通过是这里真正的产品：这是研究和一堆漂亮谣言的区别。
提示：在末尾加一行，“列出你无法核实的内容。”它未能确认的列表通常比发现更有价值，因为它告诉你不要依赖哪里。
6.2 SEO 内容机器
诚实面对你的发布时间表。对很多人来说，它要么花费每月的聘用费，要么干脆不再发生。这个图每次运行生成一份排名就绪的草稿，并且没有你绝不发布。
三个研究人员并排工作：一个分解当前顶级页面涵盖的内容，一个收集人们关于这个主题问的真实问题，一个找到每个人跳过的东西。他们的工作合并成一个大纲，起草自它，草稿经过事实核查，并在你的文件夹中等待你的确认。
如何运行它：拿出你的客户在搜索中输入的一个主题，粘贴提示词，三个研究工作同时运行，草稿降落在 drafts 文件夹中，每个不可靠的主张都在顶部标记。你阅读它，修复只有你知道的东西，并自己发布。然后让 Claude 保存工作流，每个星期一它变成一个命令而不是一个下午。
```
i want an article that can rank for: [topic]. use a workflow: run
three research jobs in parallel, one lists what the current
top-ranking pages cover, one collects the real questions people ask
about this topic, one finds what the top pages skip, merge all three
into an outline, write a full draft from the outline, then run a
fact-checker that flags every claim without a source, save the draft
to drafts/ with the flagged claims listed at the top, never publish
anything
```
提示：让怀疑论者和事实核查员作为具有不同问题的独立节点。一个检查事实，另一个检查文章是否回答了读者的真实问题。将它们合并为一个，你就会失去一半的价值。
6.3 上市工具包
你正在发布某样东西：产品、优惠、服务。诚实的选项总是两个，几周的准备或盲目发布。这个图在一次运行中生成完整的工具包，你批准每一部分。
三个研究人员并行地描绘买家、渠道和竞争对手。他们的工作合并成一页定位文档，系统就在那里暂停，以便你可以阅读它：该页面成为检查每个资产的基础。然后三个作家并行生成落地页文案、发布帖子和外展消息，检查器标记任何偏离定位的内容，工具包降落在文件夹中，没有任何东西自行发货。
如何运行它：命名产品及其对象，各一行。粘贴提示词。当系统暂停时阅读定位页面，我永远不会跳过的一步。让三个作家生成资产，检查检查器标记的内容，并逐件批准。
```
i'm launching [product] for [audience]. use a workflow: run three
research jobs in parallel, one profiles the buyer and collects the
exact words they use, one maps where these buyers spend time online,
one collects how competitors pitch them, merge into a one-page
positioning doc and pause to show it to me, then run three writers in
parallel from that doc: landing page copy, a week of launch posts, a
set of outreach messages, then run a checker that compares every
asset against the positioning doc and flags anything off, save
everything to launch-kit/ and change nothing after that without
asking me
```
定位文档上的暂停不是礼貌，而是一个门控。你批准的那一页立即为每个资产设定了基调。跳过它，三个作家就会分散成三个不同的品牌。
## 第 7 部分 · 在十分钟内构建你的第一个图
你已经看到了理论，现在是动手。拿一个背后有真金白银的真实问题，并从 6.1 构建研究台。计时：
```
3 分钟 -> 写下问题并命名 5 个挖掘角度
3 分钟 -> 带有“工作流”一词的粘贴提示词，启动分叉
2 分钟 -> 添加一个怀疑论者节点，其工作是扼杀没有来源的发现
2 分钟 -> 添加门控：在保存报告前暂停和你的确认
```
就是这样。你有了一个可工作的钻石型和一个几乎你时间线上没有人理解的理解。从这里开始只有两步：保存工作流使其成为一个命令，并在你看图哪里变盲时添加角度或检查者。
第一个图的规则：让它丑一点。五个角度而不是完美的七个，一个怀疑论者而不是三个。一个可工作的粗糙图比纸上的完美图教给你更多。
## 第 8 部分 · 每个人都会踩进的陷阱
图以可预测的方式崩溃。这里有五个崩溃，作为症状、原因、修复，以便你在它们变得昂贵之前认出它们。
- 文件变成了浆糊。原因：两个节点同时写入它，竞态。修复：每个文件一个写手，其余只读。想从碎片组装，在末尾添加一个专用的合并节点。
- 怀疑论者放过了所有东西。原因：你给了它和作者相同的问题，所以它的思维方式相同。修复：给检查者一个不同的角度，“来源存在吗”，“是当前的吗”，而不是“工作好吗”。
- 账单触顶。原因：图没有对智能体或轮次的上限，所以它繁殖了它们。修复：对智能体的硬上限和每个循环的最大轮次数，始终如此。
- 你成了瓶颈。原因：门控坐在每一步，所以图一直在等你。修复：只在难以撤销错误的地方设置门控，让其余部分流动。
- 你为一个平庸的答案支付了 15 倍。原因：在连接的工作上进行分叉，每一步都需要前一步。修复：回到“工作在哪里分裂”，如果没有答案，坚持使用一个智能体。
所有五个的共同点：图通过受规则保护的确切事物来惩罚跳过的规则。这就是纪律的来源。
## 第 9 部分 · 没有人宣传的部分
图改变了工作的形状。它没有将你从中移除。而且有两件事变得更糟，而不是更好，随着图变好。
- 没有人提到的成本。你买来的广度花费 token，我们已经看到了数字：大约是普通聊天的十五倍。指向连接工作的图，其中一切都依赖于一切，是获得平庸答案的最昂贵方式。
- 理解债务增长得更快。循环发布了你没写的代码。图发布更多，更快，因为它并行运行。它运行得越顺畅，输出和你实际阅读之间的差距就越大。
还有一个比所有这些都昂贵的陷阱。跳过最后一个“是”，图就会将其第一个自信的错误直接发送给客户。在所有地方都设置门控让你成为瓶颈。没有任何门控意味着第一个自信的失误以你的名义进入世界。
结论不是令人沮丧，只是现实：图是一个范围放大器，而不是判断力的替代品。用不能反驳的数字来判断它，并把手放在最后一个门控上。
## 速查表
拿走这个并在不重读其余部分的情况下应用它：
1. 先处理假边。在删除没有工作流经的箭头之前，不要运行任何新东西。
2. 只分裂那些从不阅读彼此结果的部分。任何一步一步的事情保持在一个智能体上。
3. 没有发现可以未经检查就传播，并且没有两个检查者问相同的问题。
4. 检查者只读，所以它不能悄悄地修补薄弱的东西。
5. 图内的每个循环都有轮次上限，智能体数量也是如此。
6. 每个文件一个写手。路由存在于书面步骤中，AI 填充工作。
7. 最后的“是”恰好位于难以撤销错误的地方。
8. 一个工具就足够了，直到你能说出它不足够的理由。
构建图之前问的三个问题：
- 我的工作在哪里真正分裂成独立的部分？
- 这里有什么东西撤销起来如此昂贵，以至于应该结束于我？
- 这个发现能经受住一个问不同问题的独立怀疑论者的考验吗？
## 拉远视角
循环是关于谁来工作的转变。图是有多少工作同时运行的转变。但所有这些与现实相遇的点并没有移动一英寸。它确切地停留在它所在的地方，与你同在。
图不会让你更聪明。它让你更宽广。它承担等待、并行、对薄弱东西的第一轮筛选，并将整个事情构建的座位还给你：最后的决定，手握全貌。
循环将手动提示从你手中拿走。图将手动等待拿走。两者都不带走思考，那始终伴随着你。如果你从这当中只保留一样东西，保留这一点，然后今晚去画出你自己的系统，计算假边，并删除它们。这不需要任何成本，并且通常能消除比你能买的任何工具更多的等待。
如果这篇文章对你有帮助，请保存并关注我，会有更多现成的图、提示词和拆解：https://t.me/shmidtai
@shmidtqq
## 相关链接
- [shmidt](https://x.com/shmidtqq)
- [@shmidtqq](https://x.com/shmidtqq)
- [5.9K](https://x.com/shmidtqq/status/2080306964068790561/analytics)
- [https://t.me/shmidtai](https://t.me/shmidtai)
- [How we built our multi-agent research system, Anthropic](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Can large language models identify and correct their mistakes?, Google Research](https://research.google/blog/can-large-language-models-identify-and-correct-their-mistakes/)
- [Building effective agents, Anthropic](https://www.anthropic.com/research/building-effective-agents)
- [Klarna reverses on AI, says customers like talking to people, Forbes](https://www.forbes.com/sites/quickerbettertech/2025/05/18/business-tech-news-klarna-reverses-on-ai-says-customers-like-talking-to-people/)
- [Building a C compiler with a team of parallel Claudes, Anthropic](https://www.anthropic.com/engineering/building-c-compiler)
- [https://t.me/shmidtai](https://t.me/shmidtai)
- [@shmidtqq](https://x.com/@shmidtqq)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [11:00 PM · Jul 23, 2026](https://x.com/shmidtqq/status/2080306964068790561)
- [5,908 Views](https://x.com/shmidtqq/status/2080306964068790561/analytics)
- [View quotes](https://x.com/shmidtqq/status/2080306964068790561/quotes)
---
*导出时间: 2026/7/24 10:24:11*