# How to design an AI agent
**作者**: Will Chen
**日期**: 2026-07-24T16:56:14.000Z
**来源**: [https://x.com/stablechen/status/2080698585176494277](https://x.com/stablechen/status/2080698585176494277)
---
Who the fuck wants to pay for your platform when $200 already buys Claude Max or Codex?
The labs sell the intelligence. They train it, they serve it at a scale you’ll never match, and it improves every few months whether you did anything or not. Your agent sits on top of theirs with a persona, tuned prompts, a tool list, some skills, and a private method for assembling context.
However real that work is, the customer can’t perceive its value when all they can see is a better chatbot.
Every agent launch collapses into the same claim: it can research, browse, write, code, and take actions for you. A team spends months on prompts and evals, and the customer sees another chat box wired to the same models everyone else uses. Then the lab ships an upgrade and the difference is gone. Jasper, the AI copywriting company, raised $125 million at a $1.5 billion valuation as the best way to make GPT-3 write marketing copy. Forty-three days later, OpenAI released ChatGPT for free, and within a year Jasper was laying people off.
People aren’t refusing to pay because the agents are weak. They’re refusing because they can’t see what the extra subscription buys.
The way out of this trap is a mental model I’ve been using for months, and it fits in two words: every agent is a mind and a body. In this post I'll show how you can look at any agent product and see what it’s actually selling, or start from a problem and design backward to the thing that would solve it.
## 1. Capability has no shape
There’s a trap almost every agent builder falls into, because the models make it so easy: the platform can suddenly do anything. The agent writes code, so it can iterate its way toward almost any goal you hand it, hill-climbing on its own output. It feels like the product just became infinitely capable — and it helps nobody, because the customer has no way to see what any of it is for.
The capability leaks out of every container you put it in. WHOOP’s coach runs on OpenAI’s models and will write you Python if you ask nicely. Your customer-support agent will happily answer high-school trigonometry. A product whose walls all leak has no shape, and that’s the precise problem: pure capability is cognitively illegible.
Nothing marks where an agent like that starts or stops working, and nothing that happens afterward visibly belongs to it. Adding tools widens the claim without making the product any easier to understand.
Normal software gets its shape from its edges. A CRM holds contacts, companies, deals, and follow-ups, so you know which part of your business it represents and what you’re trusting it to maintain. Same with an IDE: files, symbols, errors, builds. The edges are what let you see the thing.
An agent with code execution and fifty integrations has no edges. The customer can’t tell which records belong to it, what it’s supposed to notice on its own, or what it’s allowed to change, and until those relationships get concrete, the product stays a cloud of capability.
Hidden configuration makes the problem worse. The customer can’t inspect your system prompt, and they’ll never feel the months you spent refining skills or the ten percent your context selector gained on some eval. What they perceive is the structure all that machinery operates inside. When there’s no structure, the work disappears behind the model.
## 2. The body
So what do the few legible agents have that the clouds of capability don’t? They have structure the intelligence lives inside. That structure is what I call the body.
A body is functional tissue with reduced degrees of freedom: specialized capability organized into a unit that begs for an intelligent controller. The reduction is the point. A well-built body narrows the mind’s possible moves until the job becomes obvious and almost any competent model can do it. When the body is missing, every mind ends up demonstrating the same unbounded tricks.
What goes into one? An identity, first: a name, a domain, an address the world can use to reach this thing and no other. Then property: money in an account, rows in a database, records that are still there tomorrow. Then contact with reality: an inbox, a sensor, a feed, somewhere events arrive whether or not anyone is prompting. And limits: spending caps, approval rules, permissions that make a thousand separate model calls behave like one accountable thing. Each piece is boring on its own. Together they give broad capability a place where its work begins, accumulates, and gets answered for.
The pieces organize the way tissue does. Related parts group into organs: the inbox, the records, and the rules of one function working together. Organs compose into systems. A mature organ even carries its own cached procedures: workflows that fire without the mind ever waking up, or a standing agent call that the organ schedules on its own. Seen this way, the mind’s job is smaller than it looks: it supplies the control and the interpretation, while the body handles most of the running on its own.
The product is the union of a mind and a body that understand each other: the body decides which context, events, and resources reach the mind, while the mind knows the body’s parts well enough to coordinate them. A skill is that mutual understanding, written down.
The founder who taught me to trust this frame runs an established company that services restaurant kitchens: hundreds of restaurant accounts, machines with sensors on them, a fleet of trucks, human technicians, warehouses full of parts. He asked me how to add AI to that without becoming “just a GPT wrapper,” and the plan on the table was what the plan always is: a chatbot over the company’s data.
Through the mind-and-body lens, his question almost answers itself, because this company owns more body than any AI startup I’ve met. A walk-in fridge that’s been drifting warm for three days is an event, arriving from a sensor the company already owns, about a machine whose repair history the company already holds. An agent living in that body can catch the drift, check the compressor’s history and warranty, order the part, put a technician’s truck on the route, and bill for the save, and the restaurant pays happily, because the alternative was a weekend of spoiled inventory. Every kitchen could run as its own small body: equipment records, maintenance history, a dispatch channel, a budget with a limit. The truck fleet is another body. The parts warehouse is a third. There’s a product inside each of them, and not one is a chatbot. The intelligence was the easy part. What he needed was to organize what he already owned into bodies that intelligence can inhabit.
## 3. Coding agents have a computer as a body
Claude Code and Codex feel more substantial than most agents because they enter a body that already exists: the computer.
The model works inside a file system, among running processes, installed programs, credentials, and repositories. The project lives outside the context window, so the model doesn’t have to hold it all in its head. Git remembers every decision anyone ever made, and when the model edits a file, the tests come back within seconds to say whether the edit worked.
A shell command means something here because it runs in a directory, under an identity, against files that have a history. The same Bash tool in a blank chat is just another capability on a list.
The boundary is what makes the intelligence legible: you can see the agent working on this repository, trying to make these tests pass, and you can read the diff it leaves behind.
Coding agents inherited all of it from fifty years of software engineering. Git alone is twenty years old, and GitHub holds over six hundred million repositories for the minds to walk into. Every other domain is still waiting for somebody to build the equivalent.
## 4. A business as an agent body
Coding agents got their body for free. The more interesting move is building one on purpose, and the clearest case is a business.
A business body is a business made legible enough for intelligence to operate. It holds a domain, products, customer records, a support inbox, payment accounts, a codebase, deployments, and a ledger. These aren’t integrations hanging off an agent: they belong to one business, they refer to one another, and they carry obligations that outlive the current model call.
A skill becomes more than advice only when it has a body to act through. A model can know your refund procedure perfectly and still be useless: it needs the order record to tell whether this customer is eligible, the policy on that product to choose the amount, and access to the account that received the money to send it back. The skill earns its keep by coordinating the parts of this business.
Memory changes the same way. Retrieving old transcripts reminds the model what somebody said. A business needs more than reminders. It needs records it’s obligated to keep: the order status, the amount owed, what it promised the customer, what the ledger says. Those records stay authoritative after the chat is gone, and the next action starts from them.
Constraints make the parts safe to use over and over. A payment account becomes a usable limb once it has a known balance, a spending limit, an approval rule, and a history behind it. Every model call passes through the same limits, which is how a hundred separate calls still add up to one accountable business instead of a hundred temporary agents with unrestricted access to money.
Without a body, a skill is advice, memory is a pile of text, and an autonomous loop can burn tokens forever without leaving the product any better than it found it.
A failed payment shows the whole thing running. Stripe fires an event whether or not anybody has a chat open, and the event creates an obligation for this business. The agent reads the customer’s history and the company’s policy before it decides: retry the charge, offer a grace period, send a message, or hand it to a person.
Whatever happens next comes back to the same body. When the customer updates their card, the obligation clears, the ledger picks up the change, and the follow-up cancels itself. Nobody has to reconstruct the situation in a fresh chat, because the records already hold it.
The model already knows what a failed payment is, and Stripe already exposes the API. The valuable part is the business sitting around them — the thing that receives the event, knows which relationship is at risk, and carries the result forward through accounts it owns.
A prompt tells the mind what to do; a webhook lets the body receive reality without being prompted.
You can watch pricing change when the body is present. Intercom’s Fin answers support conversations inside Intercom’s own helpdesk, using its inbox, its conversation history, and its knowledge base, and charges $0.99 per resolution. You can only price the outcome when the outcome lands somewhere you own. A bare chat assistant can’t bill that way, because nothing inside it can say for sure that anything got resolved.
A tutor needs a different structure: a gradebook, lesson history, a calendar, a way to reach the student, and a record of what they can retrieve without help. Each session changes those records, and the records decide what the next session looks like. A word the student keeps missing shows up again next week; a concept they’ve mastered drops out of the queue and makes room for something harder.
That body already exists at scale, and it predates the current models. Duolingo estimates a memory half-life for every word each learner studies and schedules reviews against it. It even treats the push notification as an organ: the company published research on a bandit algorithm it trained across two hundred million notifications to learn when a nudge brings a learner back. When GPT-4 arrived, Duolingo rented it into that body as a premium tier. The lab improves the intelligence; Duolingo keeps the accumulated relationship with fifty million daily learners.
## 5. How I use this
## Deciding what to build
Say a company is drowning in job applications. Calling the solution a “recruiting agent” tells me almost nothing: it names a task, and dozens of models can already read a résumé, compare it to a job description, and draft a polite reply. If that’s the product, the company can get most of it by pasting résumés into Claude.
The useful starting point is the thing that has to keep existing overnight: this company’s hiring pipeline. Somebody has to know which roles are open, who has applied, who’s been screened, which interviews are scheduled, what each candidate was told, and which offers are out. That responsibility doesn’t stop existing when nobody’s chatting with an agent.
Once I name that persisting thing, the rest of the product falls out of it. Applications have to arrive without a coordinator forwarding them, so the pipeline gets an address of its own. Candidate replies come back to the same place. The interview calendar tells it who met whom, and the feedback lands in the record of the candidate it concerns instead of in somebody’s DMs. Now I’m looking at a continuous operation instead of a clever trick with a résumé.
It also needs records somebody can hold it to. Every candidate sits in one of a few states (applied, screened, interviewing, offered, closed), and every promise made to a candidate is written where the next action can see it. Offers get a limit, because the ability to promise somebody a salary is only usable when everyone knows what can go out without a human signing off. When a candidate goes silent, the silence goes into the same record instead of vanishing at the end of a model call.
The first month will be full of exceptions. One candidate applies to three roles at once, another comes through a referral and skips a stage, a third reschedules the same interview four times. As people resolve those cases, the resolutions turn into rules the next candidate inherits, and by month twelve the pipeline knows which sources produce hires, which interviewers never submit feedback on time, and how long each stage really takes, because the company has spent a year hiring through it.
Only then do I have to choose a model, and by this point the choice is almost boring. Several models can read a résumé and apply the rules today, and next year’s models will do it better without me touching the application inbox, the candidate records, the calendar, or the offer limits. I can swap the intelligence precisely because the hiring pipeline doesn’t move.
None of this is a thought experiment. The applicant-tracking systems most tech companies already run, like Greenhouse and Ashby, are exactly this body, built years before the minds were good enough to inhabit it. The AI screening and scheduling features now shipping into them are minds moving into a body that was already standing.
## Reading the market
The analytical move is the same decomposition run in reverse. When somebody shows me an agent product, I don’t ask what it can do anymore, because the answer is always the same: anything. Instead I take the product apart. The raw intelligence is rented from a lab. The prompts, skills, and custom code around it are owned, and they’re real work — but a skill is only worth as much as the body it’s written against, and code written against public APIs can be rewritten by anyone renting the same model. Everything that persists or touches reality is the body. So what I’m really asking is: what would remain if a competitor rented the same intelligence and redid the code?
When I split the AI SDR products this way, the result explained a lot. The pitch was an agent that finds leads and writes outreach, and the demos were genuinely good. But the mind was doing almost all of the work: reading a prospect’s website and writing the email is a rented model plus prompts that a competitor could rewrite in a quarter. The body was hard to find. The mail landed in other people’s inboxes. The replies belonged to the customer’s CRM. Even the domain reputation that all that volume was spending belonged to the customer. If I set aside the rented model and the rewritable code, almost nothing remained, and that’s what made the category a bet on the mind. The market noticed before I did. TechCrunch talked to employees at 11x, the most visible startup in the category, and they described customers walking at the three-month break clause of their one-year contracts and churn near 70 or 80 percent; the company disputed the numbers. The mechanism underneath is harder to dispute: when the whole product is interpretation, the customer can compare it against $200 of general intelligence plus a template, and the comparison keeps coming out even.
The same split gives the opposite answer at the unglamorous end of cold email. Instantly and Smartlead sell deliverability: warmed-up mailboxes, domain reputation, suppression lists, inbox-placement testing. There’s barely a mind in these products at all, and the body is enormous. Instantly claims a warmup network of more than a million inboxes generating the engagement signals that keep mail out of spam, and a network like that gets more valuable with every account that joins it, while no model release touches it. The decomposition also predicted what happened next: by 2025, the AI SDR companies themselves were bundling domain provisioning, mailbox warmup, and deliverability monitoring into their products. The companies that had been selling minds were growing organs, because the market had taught them which half of the product customers actually pay for.
So when somebody pitches me an agent, I want to know what remains after I mentally remove the model. Does the company own the inbox, or does it borrow access to mine? Which events reach the product before anyone prompts it? What history gets more valuable after a year of operation? If the model got swapped tomorrow, what would the replacement inherit?
Some answers kill the deal. A prompt, a tool list, and a handful of eval scores are owned property, but they’re the kind a well-funded competitor can rebuild in months against the same rented model — a company holding only those is competing with the lab that supplies its intelligence and with everyone else renting it. A domain with a reputation, a ledger full of open obligations, the operating history of a specific business — that’s something no competitor can rebuild, because it took contact with reality to accumulate.
The reason I keep asking about the body is that the question is so much easier to answer than “what does your chatbot do.” Capabilities blur together; bodies don’t. An agent that can do anything tells me nothing about the product. An agent that inhabits the hiring pipeline of a mid-size company, with its own application inbox, its candidate records, its offer approvals, is something I can picture, price, and compare. Agents become distinguishable the moment you ask what they inhabit instead of what they can do.
The customer pays for the union of a mind and a body that understand each other. The raw intelligence is rented, and every competitor rents from the same supply. The skills and code you write around it are yours, but on their own they’re invisible and rewritable: they become defensible when they’re written against a body only you have. The body is where your agency lives: it’s the part you can build value into, and the value you build there stays yours.
Say the agent is already solved: what body do you want to give it?
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [12:56 AM · Jul 25, 2026](https://x.com/stablechen/status/2080698585176494277)
- [3,062 Views](https://x.com/stablechen/status/2080698585176494277/analytics)
---
*导出时间: 2026/7/25 10:43:29*
---
## 中文翻译
# 如何设计 AI Agent
**作者**: Will Chen
**日期**: 2026-07-24T16:56:14.000Z
**来源**: [https://x.com/stablechen/status/2080698585176494277](https://x.com/stablechen/status/2080698585176494277)
---
既然 200 美元就能买到 Claude Max 或 Codex，到底谁他妈愿意为你的平台买单？
实验室出售的是智能。他们训练模型，以你永远无法企及的规模提供服务，而且无论你做什么，它每隔几个月都会变得更强。你的 Agent 只是搭建在他们的模型之上，加上一个人设、调整过的提示词、一个工具列表、一些技能，以及一种组装上下文的私有方法。
无论这些工作多么真实，当客户只能看到一个更好一点的聊天机器人时，他们无法感知其中的价值。
每一个 Agent 的发布最终都归结为同样的宣传：它可以研究、浏览、写作、编程，并为你采取行动。一个团队花了数月时间打磨提示词和评估指标，而客户看到的只是另一个连接着所有人都在用的相同模型的聊天框。随后，实验室发布了一个升级，差异便消失了。Jasper，这家 AI 文案公司，曾作为利用 GPT-3 撰写营销文案的最佳方式融资 1.25 亿美元，估值达 15 亿美元。仅仅 43 天后，OpenAI 免费发布了 ChatGPT，一年内 Jasper 就开始裁员。
人们拒绝付费不是因为 Agent 弱。他们拒绝是因为他们看不到额外的订阅费用到底买到了什么。
走出这个陷阱的方法是我几个月来一直在使用的一个心智模型，它只有两个字：每个 Agent 都是一个头脑和一个身体。在这篇文章中，我将向你展示如何审视任何 Agent 产品并看清它真正在卖什么，或者如何从一个问题出发，反向设计出能够解决它的方案。
## 1. 能力没有形状
几乎每个 Agent 构建者都会掉进一个陷阱，因为模型让这一切变得太容易了：平台突然无所不能。Agent 编写代码，所以它可以通过迭代来实现你交给它的几乎任何目标，在其自身的输出上攀登高峰。感觉就像产品变得无限强大了——但这帮不了任何人，因为客户看不出这一切到底是为了什么。
这种能力会从你放置它的任何容器中泄漏出来。如果你客气地请求，WHOOP 的教练会为你编写 Python 代码。你的客服代理会很乐意回答高中三角函数问题。一个四面漏风的产品没有形状，而这正是问题所在：纯粹的能力在认知上是不可读的。
没有任何标记表明这样一个 Agent 在哪里开始或停止工作，也没有任何后续发生的事件明显归属于它。添加工具只是扩大了宣称的范围，并没有让产品变得更容易理解。
普通软件的形状来自于它的边界。CRM（客户关系管理系统）包含联系人、公司、交易和后续跟进，所以你知道它代表了你业务的哪一部分，以及你信任它维护什么。IDE（集成开发环境）也是如此：文件、符号、错误、构建。正是这些边界让你能看清这个东西。
一个拥有代码执行功能和五十个集成的 Agent 没有边界。客户无法分辨哪些记录属于它，它应该自主注意什么，或者它被允许更改什么，直到这些关系变得具体化，否则产品始终是一团能力的迷雾。
隐藏的配置让问题变得更糟。客户无法检查你的系统提示词，他们也永远无法感受到你在完善技能上花费的数月时间，或者你的上下文选择器在某些评估上提升的那 10%。他们感知到的是所有这些机制运作其中结构。当没有结构时，工作就消失在模型背后了。
## 2. 身体
那么，少数清晰的 Agent 拥有而那些“能力迷雾”所没有的是什么呢？它们拥有智能赖以生存的结构。那个结构就是我所谓的身体。
身体是自由度降低的功能组织：被组织成一个单元的专业能力，这个单元呼唤着一个智能控制器。这种降低才是关键。一个构建良好的身体将头脑可能的行动范围缩小，直到工作变得显而易见，几乎任何胜任的模型都能完成。当身体缺失时，每个头脑最终都在展示同样的无边界技巧。
身体里包含什么？首先是身份：一个名字、一个域名、一个世界可以用来到达这个东西而不是其他东西的地址。然后是财产：账户里的钱、数据库里的行、明天依然存在的记录。接着是与现实的接触：一个收件箱、一个传感器、一个信息流，一个无论是否有人在提示都会接收到事件的地方。最后是限制：支出上限、审批规则、权限，这些让一千次独立的模型调用表现得像一件可问责的事情。每一部分本身都很无聊。但它们共同为广泛的能力提供了一个工作开始、积累并得到回应的地方。
这些部件像组织一样组织起来。相关的部分聚合成器官：一个功能的收件箱、记录和规则协同工作。器官组合成系统。一个成熟的器官甚至带有自己的缓存过程：无需头脑苏醒就会触发的工作流，或者器官自己调度的常驻 Agent 调用。从这个角度看，头脑的工作比看起来要小：它提供控制和解释，而身体自行处理大部分运行工作。
产品是一个相互理解的头脑和身体的结合体：身体决定哪些上下文、事件和资源到达头脑，而头脑足够了解身体的各个部分以便协调它们。技能就是这种相互理解的书面记录。
教我信任这个框架的创始人经营着一家为餐厅厨房提供服务的老牌公司：数百个餐厅账户、装有传感器的机器、一支卡车车队、人类技术人员、装满零件的仓库。他问我如何在不变成“仅仅一个 GPT 外壳”的情况下为这项业务添加 AI，而桌面上提出的计划总是千篇一律：在公司数据之上搭建一个聊天机器人。
通过“头脑和身体”的视角，他的问题几乎不攻自破，因为这家公司拥有的“身体”比我见过的任何 AI 初创公司都要多。一台温度持续偏高三天的步入式冷柜是一个事件，来自公司已经拥有的传感器，关于一台公司已经掌握其维修历史的机器。生活在那个身体里的 Agent 可以捕捉到这种漂移，检查压缩机的历史记录和保修状态，订购零件，将技术人员的卡车安排到路线上，并为这次挽救服务收费，餐厅也很乐意付费，因为替代方案是周末库存变质。每个厨房都可以作为自己的小身体运行：设备记录、维护历史、调度渠道、有预算限制的账户。卡车车队是另一个身体。零件仓库是第三个。它们每一个里面都有一个产品，而且没有一个产品是聊天机器人。智能是容易的部分。他需要做的是将他已经拥有的东西组织成智能可以寄居的身体。
## 3. 编程 Agent 以计算机为身体
Claude Code 和 Codex 感觉比大多数 Agent 更实在，因为它们进入了一个已经存在的身体：计算机。
模型在文件系统中工作，在运行的进程、已安装的程序、凭证和代码库之间。项目存在于上下文窗口之外，所以模型不必把所有东西都记在脑子里。Git 记录了任何人做出的每一个决定，当模型编辑文件时，测试会在几秒钟内返回，告诉我们编辑是否有效。
一个 Shell 命令在这里是有意义的，因为它在一个目录下、以一种身份运行，作用于有历史的文件。而在一个空白聊天中的同一个 Bash 工具只是列表中的另一种能力。
边界使得智能变得可读：你可以看到 Agent 正在这个代码库上工作，试图让这些测试通过，你可以阅读它留下的差异对比（diff）。
编程 Agent 从五十年的软件工程中继承了这一切。仅 Git 就有二十年的历史，GitHub 拥有超过六亿个代码库供头脑进入。其他所有领域都还在等待某人去构建同等的东西。
## 4. 企业作为 Agent 的身体
编程 Agent 免费获得了它们的身体。更有趣的举措是有目的地构建一个身体，而最明显的例子就是企业。
企业身体是一个企业，它被变得足够清晰以便智能进行运作。它持有一个域名、产品、客户记录、支持收件箱、支付账户、代码库、部署账本。这些不是挂载在 Agent 上的集成：它们属于一家企业，它们相互引用，并且承载着比当前模型调用更持久的义务。
技能只有通过一个身体来行动时，才会超越建议本身。一个模型可能完美地知道你的退款流程，但仍然毫无用处：它需要订单记录来判断这位客户是否符合资格，需要该产品的政策来选择金额，以及需要访问收到资金的账户以便退款。技能通过协调这家企业的各个部分来证明其价值。
记忆也以同样的方式改变。检索旧的对话记录能提醒模型某人说了什么。但企业需要的不仅仅是提醒。它需要它有义务保留的记录：订单状态、欠款金额、它对客户的承诺、账簿上显示的内容。这些记录在对话结束后依然具有权威性，而下一个行动则从它们开始。
约束使得这些部分可以安全地反复使用。一个支付账户一旦有了已知余额、支出限制、审批规则以及背后的历史，它就变成了一个可使用的肢体。每一次模型调用都经过同样的限制，这就是为什么一百次独立的调用加起来仍然是一个可问责的企业，而不是一百个拥有不受限制资金访问权限的临时 Agent。
没有身体，技能只是建议，记忆只是一堆文本，而自主循环可以永远消耗 Token，却不会让产品比它发现时更好。
一次支付失败展示了整个系统的运行。无论是否有人打开聊天，Stripe 都会触发一个事件，该事件为这家企业创建了一项义务。Agent 在决定之前会阅读客户的历史记录和公司的政策：重试扣款、提供宽限期、发送消息，还是转交给人工。
无论接下来发生什么，都会回到同一个身体。当客户更新了卡片，义务被清除，账簿记录了变化，后续跟进自动取消。没有人需要在新的聊天中重建情境，因为记录已经保存了它。
模型已经知道什么是支付失败，Stripe 也已经公开了 API。有价值的部分是围绕在它们周围的企业——那个接收事件、知道哪种关系处于风险之中，并通过它拥有的账户将结果传递下去的东西。
提示词告诉头脑做什么；Webhook 允许身体在被提示之前接收现实。
你可以看到当身体存在时定价是如何改变的。Intercom 的 Fin 在 Intercom 自己的帮助台内回答支持对话，使用它的收件箱、它的对话历史和它的知识库，每次解决方案收费 0.99 美元。只有当结果落在你拥有的地方时，你才能对结果定价。一个光秃秃的聊天助手无法这样收费，因为它内部没有任何东西可以确定任何事情得到了解决。
导师需要一种不同的结构：一本成绩簿、课程历史、一个日历、一种联系学生的方式，以及记录他们可以无辅助检索内容的记录。每次课程都会改变这些记录，而这些记录决定了下一次课程的样子。学生一直记不住的单词下周会再次出现；他们已经掌握的概念会从队列中退出，为更难的内容腾出空间。
那个身体已经大规模存在，并且早于当前的模型。Duolingo 估算每个学习者学习的每个单词的记忆半衰期，并据此安排复习。它甚至将推送通知视为一个器官：该公司发布了一项研究，关于它通过两亿次通知训练出来的强盗算法，以学习何时“轻推”能将学习者带回来。当 GPT-4 到来时，Duolingo 将其作为高级层租用进那个身体。实验室提升智能；Duolingo 保留与五千万日活学习者积累起来的关系。
## 5. 我如何使用这个框架
## 决定构建什么
假设一家公司被求职申请淹没了。把解决方案称为“招聘 Agent”几乎告诉我什么都没有：它命名了一个任务，而且几十个模型已经可以阅读简历、将其与职位描述进行比较，并起草礼貌的回复。如果那就是产品，这家公司通过把简历粘贴进 Claude 就能获得大部分功能。
有用的起点是必须通宵存在的东西：这家公司的招聘管道。必须有人知道哪些职位是空缺的，谁申请了，谁被筛选了，哪些面试安排了，告诉了每位候选人什么，以及有哪些 Offer 发出去了。当没有人与 Agent 聊天时，这种责任并不会停止存在。
一旦我命名了这个持久存在的东西，产品的其余部分就从中衍生出来。申请必须到达，无需协调员转发，所以管道获得了自己的地址。候选人的回复回到同一个地方。面试日历告诉它谁见了谁，反馈落在它所关注的候选人的记录中，而不是某人的私信里。现在我看待的是一个连续的运作，而不是一个关于简历的聪明把戏。
它还需要有人可以问责的记录。每个候选人处于少数几个状态之一（已申请、已筛选、面试中、已发 Offer、已关闭），对候选人做出的每一个承诺都写在下一个行动可以看到的地方。Offer 需要有限额，因为承诺某人薪水的能力只有在每个人都知道无需人工签字可以支出多少时才可用。当候选人失联时，这种沉默进入同一个记录，而不是在模型调用结束时消失。
第一个月将充满了例外情况。一个候选人同时申请三个职位，另一个通过推荐入职并跳过一个阶段，第三个把同一场面试改期了四次。当人们解决这些案例时，解决方案转化为下一个候选人继承的规则，到了第十二个月，管道就知道哪些来源能产生招聘，哪些面试官从不按时提交反馈，以及每个阶段实际需要多长时间，因为公司通过它招聘了一整年。
只有到那时我才需要选择一个模型，而在这一点上，这个选择几乎无聊透顶。几个模型今天就可以阅读简历并应用规则，明年的模型会做得更好，而无需我触碰申请收件箱、候选人记录、日历或 Offer 限额。我可以交换智能，正是因为招聘管道没有移动。
这些都不是思想实验。大多数科技公司已经在运行的申请人跟踪系统，如 Greenhouse 和 Ashby，正是这个身体，在头脑足够好可以寄居其中之前就已经构建了多年。现在植入其中的 AI 筛选和调度功能是搬进一个已经站立好的身体里的头脑。
## 阅读市场
分析性的动作是同样的逆向分解。当有人向我展示一个 Agent 产品时，我不再问它能做什么，因为答案总是一样的：什么都能做。相反，我把产品拆开。原始智能是从实验室租来的。周围的提示词、技能和自定义代码是拥有的，它们是真正的工作——但技能的价值仅取决于它所针对的身体，而针对公共 API 编写的代码可以被任何租用相同模型的人重写。所有持久存在或接触现实的东西都是身体。所以我真正问的是：如果竞争对手租用了相同的智能并重写了代码，还剩下什么？
当我以这种方式拆解 AI SDR（销售开发代表）产品时，结果解释了很多事情。宣传内容是一个能寻找线索并撰写外联邮件的 Agent，演示也确实令人印象深刻。但头脑做了几乎所有的活：阅读潜在客户的网站并撰写邮件是一个租来的模型加上竞争对手可以在一个季度内重写的提示词。身体很难找到。邮件落在了其他人的收件箱里。回复属于客户的 CRM。甚至所有这些体量正在消耗的域名声誉也属于客户。如果我抛开租来的模型和可重写的代码，几乎什么也没剩下，这就是为什么这个类别成了对头脑的赌注。市场比我先注意到了这一点。TechCrunch 采访了该类别中最显眼的初创公司 11x 的员工，他们描述客户在一年期合同的三个月解约条款处离开，流失率接近 70% 或 80%；公司对这些数字有争议。底层的机制更难反驳：当整个产品都是解释时，客户可以将其与价值 200 美元的通用智能加上一个模板进行比较，而比较结果总是不相上下。
同样的拆解在冷邮件的不起眼一端给出了相反的答案。Instantly 和 Smartlead 销售的是送达率：预热好的邮箱、域名声誉、屏蔽列表、收件箱放置测试。这些产品几乎没有头脑，身体却非常庞大。Instantly 声称拥有超过一百万个收件箱的预热网络，产生让邮件免于垃圾箱的参与信号，这样的网络随着每个加入的账户变得更有价值，而没有任何模型发布能触及它。这种拆分也预测了接下来发生的事情：到了 2025 年，AI SDR 公司自己也开始将域名配置、邮箱预热和送达率监控打包进他们的产品。那些一直在卖头脑的公司正在生长器官，因为市场教会了他们产品的一半实际上客户是为哪一部分买单。
所以，当有人向我推销一个 Agent 时，我想知道在我在脑海中移除模型后还剩下什么。公司拥有收件箱吗，还是它借用了对我的访问权限？哪些事件在任何人提示之前就到达了产品？什么历史在运营一年后会变得更有价值？如果模型明天被交换，替代者会继承什么？
有些答案会扼杀交易。提示词、工具列表和少量的评估分数是拥有的财产，但它们是资金充足的竞争对手可以在几个月内针对同样的租用模型重建的那种——一个只拥有这些东西的公司是在与提供其智能的实验室以及所有其他租用它的人竞争。一个有声誉的域名、一个充满未结义务的账本、特定企业的运营历史——那是没有任何竞争对手可以重建的东西，因为它是通过与现实的接触积累起来的。
我一直询问身体的原因在于，这个问题比“你的聊天机器人做什么”容易回答得多。能力会模糊在一起；身体则不会。一个什么都能做的 Agent 关于产品什么也没告诉我。一个寄居在中型公司招聘管道中的 Agent，拥有自己的申请收件箱、候选人记录、Offer 审批流程，这是我可以想象、定价和比较的东西。当你问 Agent 寄居在什么里面而不是它能做什么时，Agent 就变得可区分了。
客户为相互理解的头脑和身体的结合体付费。原始智能是租来的，每个竞争对手都从同一个供应源租用。你围绕它编写的技能和代码是你的，但它们本身是不可见且可重写的：只有当它们针对只有你拥有的身体编写时，它们才变得可防御。身体是你的能动性（agency）所在之处：这是你可以构建价值的地方，而你在这里构建的价值将永远属于你。
假设 Agent 已经解决了：你想给它什么身体？
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [12:56 AM · Jul 25, 2026](https://x.com/stablechen/status/2080698585176494277)
- [3,062 次观看](https://x.com/stablechen/status/2080698585176494277/analytics)
---
*导出时间: 2026/7/25 10:43:29*