AI 助手、Copilot 与智能体:何时用哪个

那场把我击垮的会议
现在是下午 2:15。房间没有窗户,空调已经罢工,站在前面的人已经讲了 45 分钟。我们翻到了第 31 页。而总共是 90 页。
每一页幻灯片都朝我们抛出又一个术语。智能体式 AI。大语言模型。RAG。ReAct。微调。GenAI。NLP。编排(Orchestration)。而有三个词像副歌一样反复出现:assistant、copilot、agent。
我环顾四周。二十位同事,二十张礼貌的脸,却没有一个人能讲清楚它们之间的区别——就算你付钱给他也不行。
“智能体式 AI 的时代已经到来,”演讲者宣布道。
没有人动。某人的笔记本电脑风扇转了起来。幻灯片继续往下翻。
如果这听起来很熟悉,那这篇文章就是写给你的。
这不关乎词汇。这关乎 ROI。
ChatGPT 于 2022 年 11 月 30 日向公众开放。自那以后,工具成倍增加,术语的增殖速度更快。我们大多数人如今每天都在用 ChatGPT、Gemini 或 Claude。但知道如何把它转化为企业真正可衡量的东西的人,要少得多。
这一鸿沟确实存在。MIT 的 Project NANDA 在 2025 年报告称,其研究的组织中,95% 没有从生成式 AI 支出中看到可衡量的回报。Gartner 更进一步,预测到 2027 年底,超过 40% 的智能体式 AI 项目将被取消,主要原因是成本上升和业务价值不明确。
问题的一部分出在语言上。厂商把“assistant”“copilot”和“agent”当成同一个意思来用。但它们并不是。如果你分不清它们,就会为任务买错东西,然后纳闷为什么 ROI 一直不出现。
所以这是我使用的思维模型。读到最后,你将了解:
assistant、copilot 和 agent 之间的区别
什么是编排技术
assistant 如何给出有用的建议
copilot 如何获取答案并处理小动作
智能体如何自主推理并行动
编排如何让它们像一个团队那样协同工作
以及每一个如何映射到真实的业务流程
开始之前,先说说这些标签
先声明一点。下面的三分法是我个人的心智模型,来自我参与过的部署项目。它不是行业标准,因为根本就不存在这样的标准。比如 Gartner 的分阶段模型里压根没有“copilot”这一层;它是从嵌入式助手直接跳到任务型智能体。一些厂商把“copilot”当作品牌名而非一个类别。就连研究智能体为何失败的 UC Berkeley 团队,也在论文开篇指出,智能体的正式定义至今仍有争议。你去问一位分析师、一家厂商和一位研究者,会得到三张不同的示意图。
这并不是放弃共同语言的理由,而是要在自己的组织内部就一套说法达成共识并把它写下来的理由。以下三点对我行之有效:
按行为来定义,而不是按名称。四个问题几乎能对任何工具做出分类:它会采取行动,还是只给建议?它无需提示就能自行运行吗?它会把多个步骤串联起来指向同一个结果吗?它会从上次发生的事情中学习吗?把你拥有或正在评估的每一个工具对应的答案记录下来,并把厂商的标签放在括号里。
选定一套参考术语并坚持使用。如果你的组织已经在采购分析师研究报告,就把那些定义作为基准,并标注你的定义与之不同之处。如果没有,就用本文末尾的速查表,或者其他任何一套,只要在场的每个人都用同一套就行。
把定义固化到商业论证模板中。如果一份提案写的是“智能体”,模板就应强制提案作者说明:当无人看管时,这个工具会做什么,以及它被允许接触什么。这一步就能避免大多数错误采购。
话虽如此,这是我的版本。咱们离开那间会议室吧。我知道个更好的去处。
任务简报:一周,一座宫殿,零容错空间
想象一下。你以修复失灵流程为生。你的经理把你叫进她的办公室。
“我们要派你去乌代布尔的一家遗产宫殿酒店。湖景、惊艳的客房、出色的员工。但他们的运营一团糟,他们需要在下一周五之前扭转局面。”
下一周五。这样的扭转通常需要几个月。有时要一年。
这就是为什么不能等。这家酒店正在承办全国最大电影明星之一的婚礼。三天的活动,数百位 VIP 宾客,而且你们公司的 CEO 也在嘉宾名单上。如果搞砸了,到周日每个娱乐网站都会报道。如果做好了,酒店的预订可能借这波势头吃上一年。
“你不会一个人去,”她补充道,“你会得到三名新队友。”
它们不是人。它们是三种 AI:一个助手、一个 copilot 和一个智能体。而且还有第四位队友,目前没人提到过。
第一天,上午 9 点:助手告诉你该看哪里
你在露台上见到总经理。下方的湖面波光粼粼。她则不然。
“哪儿都在着火,”她说,“而且我们的客人评分还一直在往下掉。我甚至不知道该从哪儿下手。”
她打开笔记本电脑。这家酒店运行在一整套系统之上:物业管理系统、销售终端、CRM、库存与采购、人力排班。数据全都在那里。但没人有时间去深挖。
于是你把助手接入这些系统,问出一个尖锐的问题:
“本周我们该重点抓什么,才能最大程度提升客人满意度?”
几秒钟后,你得到两条建议,都能在一周内落地:
解决前台的等待时间问题。大部分投诉都来自那里。
解决厨房的出餐流程问题。它正在悄悄拉低整个酒店的餐饮评分。
它还会展示自己的推理过程,这样总经理就能核查。她读完后点点头。“没错,就是这样。”
需要数周的分析,不到一分钟就完成了。你很兴奋,让这个助手开始在前台处理客人咨询。
它做不到。它只给建议,不采取行动。
于是你把它用在它擅长的地方。你把它派到每一个部门。它提出了更好的泳池躺椅归位和泳池吧运营方式,重新安排了客房清洁排班,让更多房间能赶在提前入住前准备好,根据一年的预订数据重新设计了水疗项目表,后来甚至给园丁提供建议。
这个助手,用一句话概括:针对特定任务或问题给出指导。
能做:访问公司实时数据、无需被要求即可在后台运行、解释自己的建议,并可搭建在任何 LLM 之上。
做不到:无法执行它自己推荐的操作,也无法随时间自行改进
它只能看到各系统所能看到的东西。如果库存系统不知道某个冷库出了问题,助手也不会知道,而它仍会基于错误数据自信地给出建议。垃圾进,精致的建议出。
建议没有责任人。助手产出的是建议,而不是问责。如果每条建议都没有指定负责人和截止时间,你得到的只是一份没人会看的、极其昂贵的待办清单。
权威性蔓延。因为它解释得很到位,人们就不再核查。“展示推理过程”这一步是团队必须保持的习惯,而不是工具替你保留的功能。
背景噪音。无需提示即可运行是一种优势——直到它生成一连串没人有时间分流的建议。设定节奏和阈值,否则它就会变成一笔没有出口的成本。
第一天,上午 11 点:copilot 清空了队列
接待处美轮美奂。开阔的庭院,到处是三角梅,还有喷泉的水声。
以及一长队疲惫、恼火的客人。
前台团队被现有住客、即将到店客人和婚礼策划师的问题淹没。投诉直接涌向总经理。入住、退房和礼宾服务的评分一落千丈,网上评价也不客气。
根因很简单。员工把大部分时间花在不同系统里翻找信息上。每个回答都要花上几分钟。电话排队的情况同样糟糕。
你给这个 copilot 相同的系统访问权限,并让团队什么问题都问它。他们一开始用得很慢,随后便一拥而上:
“湖畔草坪上晚餐能坐多少人?”
“机场有多远,以英里和公里计?”
“酒店范围内有多少棵树?”
“酒吧里备有哪些威士忌?”
“有一家人要在四个不同的日期抵达,没人记得谁订了什么。我们能调出他们的预订吗?”
“我们能给客人的猫准备早餐吗?”
每个回答都即时返回,往往还附带一条有用的下一步建议。在团队批准后,Copilot 会查清婚礼前该囤哪些威士忌,为这一家人分批抵达设置提醒,还会写出一份对猫安全的早餐食谱。
员工松了口气。排队的队伍消失了。
接着有人问:“能拿到婚礼晚宴食物过敏宾客的最新名单吗?”
Copilot 指出,有几位宾客在过去 24 小时内更新了 RSVP。它主动提出通知酒店内相关的各个团队,随后又调出附近可提供替代菜品食材的供应商。
你得寸进尺:“你能也给这些供应商打电话,把送货一并安排好吗?”
不能。这是一项涉及谈判、排期和后续跟进的多步骤任务。它超出了 Copilot 的能力范围。
原文较长,译文为节选;译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。
查看英文原文(AI Assistant vs. Copilot vs. Agent, and When to Use Each)
The meeting that broke me
It's 2:15pm. The room has no windows, the AC has given up, and the person at the front has been presenting for 45 minutes. We're on slide 31. Of 90.
Every slide throws another term at us. Agentic AI. LLMs. RAG. ReAct. Fine-tuning. GenAI. NLP. Orchestration. And three words keep coming back like a chorus: assistant, copilot, agent.
I look around. Twenty colleagues, twenty polite faces, and not one person who could explain the difference if you paid them.
"The age of agentic AI is here," the presenter announces.
Nobody moves. Someone's laptop fan spins up. The deck rolls on.
If that sounds familiar, this post is for you.
This isn't about vocabulary. It's about ROI.
ChatGPT went public on 30 November 2022. Since then the tools have multiplied, and the jargon has multiplied faster. Most of us now use ChatGPT, Gemini, or Claude every day. Far fewer of us know how to turn that into something a business can actually measure.
The gap is real. MIT’s Project NANDA reported in 2025 that 95% of the organisations it studied were seeing no measurable return from their generative AI spend. Gartner went further and predicted that over 40% of agentic AI projects will be cancelled by the end of 2027, mostly because of rising costs and unclear business value.
Part of the problem is language. Vendors use “assistant”, “copilot”, and “agent” as if they mean the same thing. They don’t. And if you can’t tell them apart, you’ll buy the wrong one for the job and wonder why the ROI never shows up.
So here's the mental model I use. By the end of this post you'll know:
the difference between an assistant, a copilot and an agent
what orchestration technology is
how assistants make useful recommendations
how copilots fetch answers and handle small actions
how agents reason and act on their own
how orchestration gets them all working as one team
and how each one maps to real business processes
A note on the labels before we start
One caveat. The three-way split below is my mental model, built from the deployments I’ve worked on. It is not an industry standard, because there isn’t one. Gartner’s staged model, for instance, has no “copilot” tier at all; it goes from embedded assistants straight to task-specific agents. Several vendors use “copilot” as a brand name rather than a category. And even the UC Berkeley team that studies why agents fail opens its work by noting that the formal definition of an agent is still debated. Ask an analyst, a vendor, and a researcher, and you’ll get three diagrams.
That’s not a reason to give up on shared language. It’s a reason to agree on one inside your own organisation and write it down. Three things that have worked for me:
Define by behaviour, not by name. Four questions sort almost any tool: Does it act, or only advise? Does it run without being prompted? Does it chain several steps towards one outcome? Does it learn from what happened last time? Record the answers next to every tool you own or are evaluating, and put the vendor’s label in brackets.
Pick one reference vocabulary and stick to it. If your organisation already buys analyst research, use those definitions as the baseline and note where yours differ. If not, use the cheat sheet at the end of this post, or any other, as long as everyone in the room is using the same one.
Bake the definitions into the business case template. If a proposal says “agent”, the template should force the author to state what the tool does when nobody is watching, and what it is allowed to touch. That one step prevents most mis-buys.
With that said, here’s my version. Let’s get out of that meeting room. I know somewhere better.
The brief: one week, one palace, zero room for error
Picture this. You fix broken processes for a living. Your manager calls you into her office.
"We're sending you to a heritage palace hotel in Udaipur. Lake views, stunning rooms, brilliant staff. But their operations are a mess, and they need to turn it around by next Friday."
Next Friday. A turnaround like that normally takes months. Sometimes a year.
Here's why it can't wait. The hotel is hosting the wedding of one of the country's biggest film stars. Three days of functions, hundreds of VIP guests, and your company's CEO is on the guest list. If it goes wrong, it's on every entertainment site by Sunday. If it goes right, the hotel's bookings could ride that wave for a year.
"You won't be going alone," she adds. "You're getting three new teammates."
They aren't people. They're three kinds of AI: an assistant, a copilot and an agent. And there's a fourth teammate nobody has mentioned yet.
Day one, 9am: the assistant tells you where to look
You meet the general manager on the terrace. The lake is glittering below. She is not.
"Everything is on fire," she says, "and our guest scores keep dropping. I don't even know where to start."
She opens her laptop. The hotel runs on a stack of systems: property management, point of sale, CRM, inventory and procurement, workforce scheduling. The data is all there. Nobody has the time to dig through it.
So you plug the assistant into those systems and ask one sharp question:
"What should we focus on this week to improve guest satisfaction the most?"
A few seconds later you have two recommendations, both doable within the week:
Fix the waiting times at the front desk. That's where most complaints come from.
Fix the kitchen delivery process. It's quietly dragging down catering scores across the whole hotel.
It also shows its reasoning, so the GM can check it. She reads it and nods. "Yes. That's exactly it."
Weeks of analysis, done in under a minute. Excited, you ask the assistant to start handling guest queries at reception.
It can't. It recommends. It doesn't act.
So you put it to work where it shines. You send it round every department. It suggests a better way to reset the pool loungers and run the pool bar, reorders the housekeeping schedule so more rooms are ready for early check-ins, rethinks the spa menu using a year of booking data, and later even advises the gardeners.
The assistant, in one line: it gives guidance on a set task or question.
Can: access live company data, run in the background without being asked, explain its recommendations, and work on top of any LLM
Can't: carry out the actions it recommends, or improve on its own over time
It only sees what the systems see. If the inventory system doesn’t know a cold room is broken, neither does the assistant, and it will recommend confidently on bad data. Garbage in, polished advice out.
Advice with no owner. An assistant produces recommendations; it doesn’t produce accountability. Without a named person and a deadline attached to each one, you get a very expensive to-do list nobody reads.
Authority creep. Because it explains itself well, people stop checking. The “show its reasoning” step is a habit the team has to keep, not a feature the tool keeps for you.
Background noise. Running unprompted is a strength until it generates a stream of suggestions that nobody has time to triage. Set a cadence and a threshold, or it becomes a cost with no outlet.
Day one, 11am: the copilot clears the queue
The reception is gorgeous. An open courtyard, bougainvillea everywhere, the sound of a fountain.
And a long line of tired, irritated guests.
The front desk team is drowning in questions from current guests, incoming guests and the wedding planners. Complaints are going straight to the GM. Scores for check-in, check-out and concierge have crashed, and the online reviews aren't kind.
The root cause is simple. Staff spend most of their time hunting for information across different systems. Every answer takes minutes. The phone queue is just as bad.
You give the copilot the same system access and tell the team to ask it anything. They start slowly, then pile in:
"How many people can we seat for dinner on the lakeside lawn?"
"How far is the airport, in miles and kilometres?"
"How many trees are on the property?"
"Which whiskies do we stock at the bar?"
"A family is arriving across four different days and nobody remembers who booked what. Can we pull their reservations?"
"Can we do breakfast for a guest's cat?"
Every answer comes back instantly, often with a useful next step. With the team's approval, the copilot researches which whiskies to stock up on before the wedding, sets a reminder for the family's staggered arrivals, and writes a cat-safe breakfast recipe.
The staff relax. The queue disappears.
Then someone asks: "Can we get the latest list of guests with food allergies for the wedding dinner?"
The copilot flags that several guests updated their RSVPs in the last 24 hours. It offers to alert the right teams across the hotel, then pulls up nearby suppliers who could provide ingredients for alternative dishes.
You push your luck. "Can you call those suppliers and arrange the deliveries too?"
No. That's a multi-step job with negotiation, scheduling and follow-through. It's beyond a copilot.
You ask the assistant who should take it. The answer comes straight back: the agent.
The copilot, in one line: it reasons and carries out simple tasks.
Can: recommend and execute simple actions, access live company data, and work on top of any LLM
Can't: work without being asked each time, or improve on its own over time
Fast and confident, including when it’s wrong. “How many trees are on the property?” is only safe if there’s a record to pull from. Where there isn’t, a copilot without grounding will invent a number in the same friendly tone. Insist on answers that cite their source system.
Everyone’s access is a data leak waiting to happen. A copilot that answers anything for anyone will happily tell the front desk what’s in payroll. Permissions have to be scoped per role before the tool goes live, not after the first awkward question.
It’s only as good as the questions. Value depends on people knowing what to ask. Adoption often plateaus after the early enthusiasts, and the same question gets asked a hundred times because the copilot doesn’t remember answering it.
Scope creep in the moment. Staff will push “simple actions” towards multi-step jobs, exactly as we did with the suppliers. A copilot that half-completes a complex task is worse than one that declines it.
The bill is per query. Cheap to pilot, surprisingly expensive at scale, with no learning curve to bring the cost down.
Day one, 3pm: the agent fixes the kitchen
You find the food and beverage director by the pool, looking as worn out as the GM.
When the wedding was booked, she decided to refresh the menus across all three restaurants. Great idea on paper. In practice it meant dozens of new suppliers to coordinate, and the chaos spread fast: food waste, last-minute delivery premiums, costs ballooning, stressed staff, and a dip in food and service quality that guests have definitely noticed.
"I just want to get back to running my team," she says.
The agent asks for access to every system tied to kitchen procurement and suppliers. Then it asks for something bigger: permission to talk to suppliers and book deliveries without checking back each time.
She hesitates. Fair enough. That's a lot of trust to hand over. But without that autonomy, an agent is just an expensive copilot. She agrees, and the agent asks exactly the right follow-up: are there any constraints it should know about?
The loading bay can only take two trucks at a time.
One of the cold rooms is broken, and the inventory system doesn't know yet.
A few minutes later the agent turns the laptop around. A full delivery schedule, every slot already confirmed with the supplier.
"Perfect," she says. "Oh, one thing. We can't take any deliveries the day before the wedding."
The agent replans in moments.
Then she asks the question that will matter later: "Could you also meet the trucks when they arrive and show them where everything goes?"
The agent happily says yes.
Both of the hotel's big problems, solved on day one. The week looked impossibly tight this morning. Turns out it was too long.
The agent, in one line: it reasons through a plan step by step and acts on its own to reach a set outcome.
Can: reason sequentially to make decisions, carry out complex actions in sequence, run in the background without being asked, access live company data, work on top of any LLM, and if it's advanced enough, improve itself over time
Can't: reliably work towards more than one outcome at a time
Autonomy means blast radius. An assistant that’s wrong wastes a meeting. An agent that’s wrong books forty deliveries. Errors compound because it acts on its own output. Irreversible actions (spending money, cancelling orders, sending messages to suppliers) need an approval gate or a hard limit, however much that slows it down.
It only knows the constraints you tell it. The broken cold room and the two-truck loading bay were in people’s heads, not in any system. Real operations run on tribal knowledge, and an agent will optimise straight through whatever nobody wrote down.
Looping and hallucination under load. Give it a goal it can’t satisfy, or two goals that pull against each other, and it will go round in circles, then start asserting things that aren’t true. You’ll meet this on the morning of the wedding.
Hard to see what it did. Multi-step reasoning is opaque by default. If you can’t replay an agent’s decisions afterwards, you can’t audit it, and you can’t tell the F&B director why the trucks went where they went.
Brittle at the edges. When a supplier changes its ordering portal or a data field gets renamed, an agent can fail silently rather than loudly. And “improves over time” cuts both ways: a system that learns can also drift away from what you set it up to do.
The meter runs. Reasoning step by step burns far more compute than answering a question. A stuck agent is an expensive loop until someone notices.
Remember that limitation about one outcome. It’s about to bite.
The morning of the wedding: the agent falls apart
The rest of the week is a dream. Scores are climbing, suppliers love how organised the hotel has become, and the palace is transforming: marigold garlands, fairy lights over the courtyard, a mandap taking shape by the lake.
Your manager calls. She's pleased, but nervous. "Don't let anything slip. The CEO will be there."
At dawn on the big day, there's a knock on your door. It's the GM.
"You need to come now. The agent has been sending trucks to the wrong storage areas and double-booking supplier slots. A whole batch of food has spoiled."
You find the agent going round in circles, mixing up schedules, and confidently stating things that aren't true.
You ask the assistant what's wrong. The diagnosis is instant: the agent has been given two different jobs. Planning the deliveries and receiving them are separate outcomes. Overloaded, it loops, and eventually it starts to hallucinate.
The fix is simple. Give it one job.
You take receiving off its plate. It snaps back into focus and immediately reschedules deliveries for later that day to replace the spoiled stock.
But someone still has to meet those trucks. And the wedding is tonight.
The missing teammate: you, holding the baton
You ask the assistant who could possibly help now. It points straight at you.
The missing piece was never a smarter agent. It was coordination. Orchestration.
Your manager has sent extra agents. Instead of asking one of them to juggle, you give each one a single job and wire them together:
Agent one keeps planning the deliveries.
Agent two takes that schedule and receives the trucks as they arrive.
Agent three waits for each delivery to be marked complete, updates the inventory system, and pings the kitchen.
Each agent works from live hotel data and from the output of the agent before it. Nobody is juggling. The whole thing flows, and prep wraps up hours early.
That's what orchestration technology does. It:
triggers tasks and actions in the right order
manages AI tools across an entire end-to-end process
keeps behaviour predictable and consistent through a rules engine
connects to any system, tool or AI platform
runs in the background without being asked
gives AI tools the framework they need to reason and act
needs initial setup, like everything else here
Orchestration, in one line: it automates complex workflows across every way work gets done, by people, systems, and AI.
Bad output flows downstream. If agent one produces a wrong schedule, agent two will faithfully receive trucks against it. Every handoff needs a check, and the Berkeley researchers found that missing verification steps are one of the three big families of multi-agent failure.
Agents misunderstand each other. The second big family in that study is inter-agent misalignment: one agent assumes the previous one finished, or withholds a detail the next one needed. Orchestration doesn’t fix this by itself; it just makes the gaps visible.
You now own a system, not a tool. Retries, timeouts, what happens when agent three never hears that a delivery is complete: this is software engineering, with monitoring and on-call to match. Vendors sell it as a feature. Budget for it as a platform.
Accountability gets blurry. When three agents and two people shared a decision, who signs off when it goes wrong? Decide that before go-live, and write the human override into the rules engine.
Integration is the real cost. Every system the orchestrator connects to is a connector someone has to build and maintain, and the more it connects, the harder it becomes to swap any one piece out later.
The wedding goes off without a hitch. During the sangeet, the CEO finds you, still in his suit despite the heat, and shakes your hand. “Remarkable work. Head office will hear about this.”
You tell him it was a team effort. It was.
Back in the meeting room
We're back in the windowless room. Slide 58. Finally, someone asks the question everyone has been thinking: "Sorry, what's actually the difference between these three?"
Silence. So you stand up and say it plainly:
"All three can plug into live company data. An assistant recommends, nothing more. A copilot answers questions from your data and handles simple follow-ups when you ask. An agent reasons step by step and acts on its own to hit one outcome. Give it two and it starts going in circles. And when you need several of them working together, you need orchestration to coordinate them across people, systems and tools."
The room exhales. Someone grabs you at the coffee machine afterwards: "I think a copilot could fix a project I'm stuck on. Got five minutes?"
Accesses live company data
Explains its recommendations
Runs in the background without prompting
Needs a prompt every time
Reasons step by step to make decisions
Executes complex actions in sequence
Can improve itself over time (if advanced enough)
Orchestration sits above all three. It runs in the background, connects to any system or AI tool, and coordinates the whole workflow.
How each one plugs into your business
All four start from the same base: an LLM plus your business data and context. What changes is what they add and what comes out.
Assistant: LLM + business data, producing suggestions for your people and systems. You: "What needs fixing before the event?" Assistant: "Optimise the kitchen delivery process."
Copilot: LLM + business data, producing messages and commands to your systems and people. You: "Please alert the right staff about the guests' food allergies." Copilot: "Sending now."
Agent: LLM + agent instructions + business data, producing automated actions. Agent: "I've adjusted the delivery schedule based on the latest supplier availability."
Orchestration: LLM + orchestration scenarios and desired outcomes + business data, producing workflow orchestration that directs the other three. You: "Optimise the process for on-time delivery and guest satisfaction." Orchestrator: "On it."
The hotel story is neat on purpose. Real deployments are messier. Here’s what I’d add from building and advising on this stuff.
1. The labels are slippery. Gartner calls it “agent washing”: vendors rebranding chatbots, RPA, and assistants as agentic AI. Its estimate is that only about 130 of the thousands of vendors claiming agentic AI offer the real thing. So ignore the label. Ask what the tool can do when you’re not watching.
2. Assistants are the on-ramp, not the destination.Gartner’s August 2025 forecast describes a progression: assistants embedded in most enterprise apps first, then up to 40% of enterprise apps featuring task-specific agents by the end of 2026, up from under 5% in 2025. Note the word task-specific. That’s the one-outcome rule from the story, showing up in the market.
3. More agents doesn’t automatically mean better.UC Berkeley researchers studied why multi-agent systems fail and catalogued 14 distinct failure modes across three categories: specification and design problems, inter-agent misalignment, and weak task verification. Their finding: most failures come from system design and agents misaligning with each other, not just from the underlying model. In other words, orchestration is where you win or lose. The taxonomy and the data are open source if you want to use them as a checklist.
4. ROI comes from fit, not features. The MIT figure has its critics. Wharton’s Kevin Werbach, among others, questioned how transparent the methodology was: the report’s own explicit figure was that only 5% of custom enterprise tools reached production, which is a narrower claim than “95% of all AI pilots fail”, and the underlying data was never released. Critics also pointed out that the report’s diagnosis (AI that can’t remember or learn) happens to describe the kind of system NANDA itself builds. But even the sceptics agree most AI pilots stall before production. Gartner’s advice is blunt: only pursue agentic AI where it delivers clear value. Pick one painful process, use the simplest tool that solves it, and measure it.
Which one do you actually need?
You don't know what to fix yet. Start with an assistant.
Your people are drowning in questions and small admin. Use a copilot.
You have a multi-step process with a clear goal and clear rules. Deploy an agent, and give it real permissions and real constraints.
You need several of these working across one end-to-end flow. Design the orchestration first.
Stop asking "should we use AI?" Start asking "what's the job?" Give your AI a job description, not a buzzword.
I hope you’ve enjoyed this and learned something new. I’m always open to suggestions and discussions on LinkedIn. Hit me up with direct messages.
Till the next one, happy exploring!
A practical deep dive into declarative AI programming
June 23, 202514 min read
Learn how to apply coding agents in parallel to work more efficiently
April 6, 20269 min read
Part 2: Prompts for Advanced Model Development
November 9, 20258 min read
Build a more powerful coding agent setup with a model ensemble
June 30, 20267 min read
Enterprise Document Intelligence [Vol.1 #B00] - Retrieval answers one kind of question. Classifying a request, matching free text to a reference list, reading a table, cleaning OCR noise: each has a cheaper method that works, and the engineering is knowing which one to reach for
August 29, 202615 min read
A practical guide to identifying, restoring, and transforming elements within your images
February 26, 202621 min read
How to consistently parse outputs from LLMs using Function Calling of Open AI API and LangChain. Methods evaluation with advantages and...
September 21, 202312 min read
Learn how to make your LLM applications more robust
July 15, 20257 min read
In the age where everyone uses ChatGPT for work and school, I am taking advantage of that to help me study in my university course
July 19, 20249 min read
原文为英文,正文由自动抓取并保留原文。
原文发布于 Towards Data Science(AI Assistant vs. Copilot vs. Agent, and When to Use Each),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。
