Summary

The substance of this Agent boom is that products have finally crossed from the AutoGPT-style “toy” of April 2023 to delivering results in real work. 王文锋 breaks the progress into two tracks: o1 brought long-horizon reasoning, while the more easily overlooked shift is that Agent engineering has learned how to build Context, receive feedback from the environment, and call Tools; ultimately, results depend on “Context plus LM,” not simply on who has plugged into the strongest model.
MCP’s value is not creating a new capability, but standardizing the interface through which models call Tools into a universal unit of measure. 王文锋 compares Function Calling to version 0.1 and MCP to version 0.2; as long as a SaaS product has an OpenAPI, developers can wrap it with MCP themselves without waiting for native vendor support. He says A2A looks more like “a KPI exercise,” because an Agent itself can be wrapped as a Tool—a reflection primarily of the fight over who gets to set the standard.
API and GUI are not mutually exclusive generational paths; Agents should mix the two execution methods by use case. APIs are more stable, while GUI screenshot-based approaches are faster and consume “at least an order of magnitude” fewer Tokens, at the cost of possible coordinate-recognition errors; Manus’s decision to show the browser process also has product value, letting users see how it works and giving them confidence. 曲凯 counters that users ultimately care only about the result, and process transparency mainly backfills trust while Agents are still “not ready and unreliable.”
王文锋 believes we are now—and will remain for a long time—in the era of vertical Agents, because professional results require definable states, action spaces, and reward signals. His analogy is cooking: an ordinary person can follow a recipe, but that does not make them a five-star hotel chef; even if a general-purpose task has a 90% success rate at every step, multiplying across many steps quickly degrades the result, while vertical products use domain Know-how, long System Prompts, and structured validation to narrow and converge the path.
AI Coding is more like an Agent’s “dexterous hand”; reuse should be the default path. The optimal sequence is to first look for a Tool that has already been tested, and only write code on the fly if none exists. On preserving successful code to avoid the cumulative failure implied by (0.9^{10}), 曲凯 proposed the mechanism and 王文锋 said it was reasonable. 王文锋 expects Workflow and Agent to coexist for the long term: the former is human-driven, stable, and non-generalizing; the latter is AI-driven and generalizable, but may “mess things up five times out of ten.” His rough split in one passage is that AI may handle 20% of more open-ended problems, with the remaining 80% being more common problems; elsewhere he summarizes AI’s role as mainly handling routine problems.
The ideal interaction for an Agent product is not teaching users to write Prompts, but letting them complete tasks “like an extremely happy little child.” 王文锋 puts interaction flexibility ahead of initial accuracy, insisting that the chat box remains the most important entry point, with Human-in-the-Loop, preference memory, follow-up questions, and contextually surfaced components filling in the precision gap; simply opening Meituan or DiDi already supplies substantial intent Context, while truly high-quality data is not a single input-output pair but a complete sequence containing intermediate state changes.
SHEET0 is betting not on generating another report, but on turning heterogeneous data into a complete table and then driving action. Examples include identifying a GitHub user’s company from commit records and social accounts, and fully scraping companies from YC batches, finding their founders and Twitter accounts, then continuing outreach; 王文锋 claims the product can deliver “100% accuracy, 100% stability, and 100% no data loss,” but the episode provides no sample size or external validation. For investors, the more important question is not whether the team has an impressive algorithm pedigree, but “how are the incentive signals from the environment designed?”
王文锋’s industry timeline is constrained simultaneously by model leaps, inference costs, and the cycle time required for Context engineering. At the time of recording, he judged that GPT-5 might arrive “around the end of this year,” while reducing costs to one-fifth or even one-tenth of current levels could take another year, putting truly large-scale Agent adoption in the second half of 2026. On the Context side, excellent teams need at least 6 months and possibly a year, with a batch of better products potentially appearing in Q3 of that year. “The engineering complexity inside Agents is far beyond what people imagine.”

Deep dive

1. Agents Have Moved from Model Demos to Action Programs in the Environment

王文锋 cites Anthropic’s definition: an Agent is “a program in which a model uses Tools based on feedback from the environment.” The three key terms are model, environmental feedback, and taking action; a system that only generates text and cannot adjust its actions based on the results does not meet his definition of an Agent.
He dates the previous boom to April 2023, with AutoGPT as its representative product; at the time, it was “more of a toy” and did not genuinely solve problems. The change over the following 2 years is not a refreshed concept, but the fact that Agents have started delivering value in real work and everyday-life scenarios.
The key model-side milestone was o1, which gave Agents “long-horizon reasoning”; the engineering breakthrough was figuring out how to provide the right Context. 王文锋 believes the latter has been significantly underestimated: a stronger model is only the foundation; the product must also continuously organize state, Tools, and feedback.

2. Context Is Not Material Stuffed into a Prompt, but the Agent’s Complete Current State

王文锋 defines Context as “the sum total of the information a large model needs to use.” In a coding scenario, that includes the codebase structure, source files, available APIs, and human input; in a product, it includes webpages, collected spreadsheets, the user’s objective, and the SQL generated during analysis.
曲凯 asks whether putting historical information into a Prompt or RAG was not already standard practice. 王文锋’s distinction is the source of the information: past inputs were primarily curated by humans, whereas Agents emphasize automatically obtaining, distilling, and validating information from the environment—for example, extracting target fields from a complex webpage and then actually executing SQL against a database to confirm that it works.
Context is therefore not a static bundle of materials, but a state updated through action. “What I did, what I looked at, what I sent,” together with the pages visited and artifacts generated in the background, collectively determine the next step; the conversation history is only one layer visible to the human.

3. MCP Standardizes Tool Interfaces; A2A Looks More Like a Contest for Standard-Setting Power

王文锋 calls Function Calling version 0.1 of model tool use and MCP version 0.2. MCP’s biggest contribution is not capability but standardization: previously, each interface was like a different country’s system of weights and measures, requiring fresh adaptation whenever the ecosystem changed; standardization materially lowers the barrier to connecting Tools.
The standard way to use MCP does not require SaaS vendors to provide an MCP Server themselves. If an OpenAPI already exists, developers can add a wrapper and turn it into a Tool callable by an Agent; 王文锋 notes that OpenAPI is close to standard across overseas SaaS ecosystems, while domestic software generally lacks it.
On Google A2A, 王文锋 is blunt: “A2A is not very meaningful; it looks more like a KPI exercise.” Its claimed Agent-to-Agent interaction can still be implemented by defining another Agent as a Tool with a function entry point and then wrapping it with MCP, so it introduces no fundamentally new capability.
王文锋 sees A2A as an effort to force-create a concept and organize partners to push an ecosystem—in essence, a contest for standardization rights. From the developer’s side, he “prefers MCP” because A2A brings no new engineering abstraction.

4. Browser Use and MCP Are Orthogonal; APIs and Vision-Based Approaches Have Different Economics

Browser Use simply treats the browser as one of the most important Tools; it is not opposed to MCP. 王文锋 says they are “two orthogonal things”: an Agent can use screenshots, coordinates, a mouse, and a keyboard, or wrap browser APIs into an MCP Tool and call them through code. He classifies Devin as a pure Coding solution, while noting that it also has Computer Use.
A pure GUI path requires the model to identify interactive elements from screenshots and calculate coordinates, so stability remains weak. 王文锋 cites Adept as a counterexample, saying the company was extremely hot in 2023 and 2024 but later stalled because “this is too hard”; real-world Browser Agents still rely heavily on browser APIs rather than simulating a human end to end.
When software has no OpenAPI or SDK, visual operation becomes the necessary fallback: give the model a screenshot to identify, then drive the mouse and keyboard. The advantages are speed and low cost; in actual product use, Token consumption is “at least an order of magnitude” lower, while the downside is that coordinates for elements such as a submit button may be misidentified.
There is therefore no fixed ratio. Each Agent should choose between API and GUI based on its objective: the former offers greater accuracy and stability, while the latter provides an alternative path and lowers costs when no interface exists. Current Agents are typically combinations of Coding, Browser Use, and other Tools.

5. The Browser Process Is Primarily a Trust Interface, Not Technical Showmanship

Asked why Manus still shows the browser when backend code can connect to everything, 王文锋 gives a two-layer answer. Technically, using the browser may be cheaper; as a product matter, users must judge whether the result is trustworthy, and seeing how the Agent completes each step is an effective way to create that sense of trust.
His analogy is a relationship with a colleague: trust develops only after seeing how the other person works and gradually understanding their reasoning. The browser presents details in a way users can understand, which is more intuitive than “a black box window”; 曲凯 puts it more sharply—because people still feel that Agents are “not ready and unreliable,” transparent execution lets them retain the feeling of being “in complete control.”
曲凯 also raises a reservation: if Genspark completes the task in the backend, why should users care whether it operates a computer like a human? 王文锋 previously felt that because Genspark did not expose a similar browser process, it “might not yet be the kind of Agent I have in mind”; the debate exposes the product trade-off between result efficiency and process explainability.
曲凯 also points out that users may miss a question Manus asks midway through a run, only discovering after half an hour or an hour that it is still stuck on step 2. 王文锋 says this can be improved through UI optimization or by connecting email, SMS, and instant-messaging tools for notifications.
王文锋 divides trust into two ends: developers must trust the model and avoid using excessive traditional Rule-Based constraints that suppress the “utilization rate of large-model intelligence”; the product must also build trust on the user’s behalf. DeepSeek R1 showing intermediate reasoning and Manus exposing execution details both make people more willing to accept the final answer.

6. AI Coding Is the “Dexterous Hand” for Building Tools on Demand; Reuse Is the Default

王文锋 does not consider AI Coding itself an Agent; Coding is simply one powerful Tool that a large model can call. The most important relationship between the two is “collaboration” and “reuse”: writing a program from scratch for every subproblem is inefficient and expensive, and violates the basic economics of modern software development.
The optimal strategy is to first check whether a directly reusable, already tested Tool is available. Only after “looking around” and finding nothing suitable should the system fall back to AI Coding and manufacture a unique Tool on the spot. In theory, a model could build its own browser and then use it, but time and economics usually make that the wrong choice.
He calls AI Coding the large model’s “dexterous hand.” 曲凯 proposes that if each step in a planning chain has a 90% success rate, the system ends up at (0.9^{10}) after 10 steps; preserving successful code as a correct Case before moving to the next node means one failure need not contaminate every subsequent step. 王文锋 says the mechanism is “reasonable.”

7. Vertical Agents Will Remain Dominant for the Long Term Rather Than Giving Way to General-Purpose Systems

王文锋 believes the market “is now, and will remain for a long time,” in the era of vertical Agents. He uses cooking to explain specialization: an ordinary person can use a phone to follow a recipe and complete a meal, but a five-star hotel chef is far better in presentation and taste; being able to cook is not the same as delivering a professional result.
Vertical products know in advance which steps a task typically contains, allowing them to write System Prompts with domain Know-how and optimize each link. The System Prompts of products such as Cursor and Windsurf can run to thousands of lines; a research Agent can anticipate standard paths such as searching webpages, collecting data articles, extracting information, and generating an Excel file, PPT, or report.
曲凯 adds that general-purpose Agents face a multiplicative risk: even with a 90% success rate at every step, overall accuracy falls rapidly after several steps. A vertical Agent can first raise the success rate of each step, and even if one step has a problem, that failure does not necessarily affect the next step.

8. The Reinforcement-Learning Framework Determines Whether a Product Can Form a Real Closed Loop

王文锋 emphasizes that the Agent concept comes from reinforcement learning in the first place; this is not a question of whether reinforcement learning suddenly became important later. Its three core quantities are state, action, and reward signal: state corresponds to Context, action to Tool Use, and the reward signal determines whether an action moves the system closer to or farther from its goal.
For a startup, the key is “how to turn your product into an environment.” Only with a well-defined environment can the team describe states, constrain the action space, design Workflow nodes, and define what counts as completion. If the result is not clearly defined, the system cannot converge or iterate through one, two, and three rounds of self-improvement.
王文锋 advises Agent developers and product managers to read Sutton’s reinforcement-learning books—not to apply an algorithm label, but to develop environmental awareness: which product nodes are actionable, which states are observable, and what feedback can drive path correction. “If you don’t understand reinforcement learning, it is very hard to understand what an Agent really is.”
曲凯 considers an IDE a natural environment. 王文锋 adds that the key test is whether the environment can generate feedback. A code execution error immediately produces an error message, making it a natural Reward Signal; for Manus, the browser is not the environment—the environment is the directory under Ubuntu. Ubuntu is mostly a container, and additional validation mechanisms are still required before it becomes an effective environment.

9. The Interaction Promise of an Agent Is Less Mental Effort, Not Learning to Operate Software

Traditional software becomes capable of solving more complex problems as it adds features, but the user’s learning and cognitive burden rises as well. 王文锋 believes Agents should reverse the design: the stronger the capabilities, the better the system understands user preferences, and the simpler the user’s job becomes—completing the task “without having to think.”
He insists that the chat box remains the most important interaction entry point because “the user’s freedom of interaction” matters more than initial accuracy. If a product requires users to enter information in a prescribed format, users are adapting to the software; natural language lets them “say it however they want,” after which the product handles clarification.
Accuracy still matters, but developers should fill the gap through Human-in-the-Loop, preference memory, accumulated knowledge, and continuous follow-up questions. When a user supplies only a vague objective, the Agent should progressively make it concrete itself rather than requiring the user to first become a Prompt expert.
Even if the underlying system has 200 components, it should not put all of them in front of the user at once. Someone may always need only 10, so the other 190 should not add to the cost of understanding. The chat box provides free expression, while the right interface should appear automatically at the right moment, letting the user enter a flow state “like an extremely happy little child” and simply finish the task.

10. Intent Recognition Depends on Path Data; A Single Input-Output Pair Is Nowhere Near Enough

曲凯 points out that opening an App already provides a huge amount of Context: opening Meituan usually means ordering food delivery, while opening DiDi usually means getting a ride. Vertical applications therefore first bring users into a shared context, then continuously accumulate preferences, execution state, website information, and environmental data through interaction.
王文锋’s summary is: “If you want to understand someone better, look at their past.” Where users came from, which pages they passed through, and what actions they took should all be preserved; the memory system is also simply part of this Context, not an independent form of magic.
He therefore believes Google was saving Cache very early, and that its biggest competitive advantage in the AI Native era is its huge volume of user click data, which allows it to analyze intent. User paths should likewise be preserved, but the episode does not equate them completely with Google’s click-data advantage.
High-quality data should include the input, output, and every intermediate state change; fundamentally, it is a sequence. The Go analogy captures the point: knowing only how to play the current move is meaningless. One must know how the previous 100 moves produced the current board position before inferring the path ahead.

11. Judge an Agent by the Delivered Result, Not by How General-Purpose the Interface Looks

曲凯 proposes Product-Model Fit: teams must understand the capability ceiling of the leading models of the time, such as o1 and 3.7, and verify under extreme conditions whether the objective is achievable. If the underlying model simply cannot do it, product packaging and demos cannot turn the story into delivery.
王文锋’s classification standard is the final Delivered Result. Genspark, Deep Research, and Manus still primarily produce reports; charts or simple webpages are merely alternative presentations of a report, so all can be classified as research Agents. A Coding Agent’s deliverable is the code itself.
王文锋 defines his own product as a “spreadsheet Agent.” Reports suit qualitative analysis and help users build intuition; quantitative analysis requires accurate numbers, and accurate numbers must come from complete, clean, structured tables—not from handing the model several webpage search results and asking it to summarize them.
This is why “result first” matters more than a feature list: only after the deliverable is defined can the team build feedback mechanisms around it and optimize layer by layer. If the objective remains ambiguous, the product disperses into an interface that merely “looks a bit like a general-purpose Agent,” while the result cannot converge.

12. SHEET0 Uses Structured Data to Close the Loop from Collection to Action

The first case is sales leads. A customer has a large number of open-source users and wants to identify which companies they come from in order to sell them a commercial version. SHEET0 visits GitHub profiles, looks for clues in commit records and social accounts, then enters social pages to confirm company information, simulating a manual investigation of each person.
The second case is fully scraping companies from the latest several YC Batches, finding their founders and Twitter accounts, then following those accounts and sending direct messages. 王文锋 emphasizes that the goal is not to stop at a report, but to cover the complete chain of “data collection, data processing, and finally action based on the data.”
He says competitors may generate a table of YC companies but miss some companies and fail to add founders’ schools, years of work experience, and social accounts. Manus’s problem is that it generates code dynamically midway through the task and must keep Debugging; SHEET0 instead calls small, internally validated Tools, trading reuse for stability.
王文锋 makes an extremely absolute competitive claim: “If you have a need for high-quality data scraping,” at the time only their product could deliver “100% accuracy, 100% stability, and 100% no data loss.” This is the founder’s claim on the show; no testing scale or failure boundary was provided.

13. Accuracy Comes from Structured Validation; Workflow Will Not Be Eliminated by Agents

SHEET0 has the model analyze page structure and the relationships between pages, then generate a script; the actual collection and generation of data is executed by code. Code provides a feedback signal, and empty cells in a spreadsheet are immediately visible, so 王文锋 says this engineering design has solved Hallucination in data scraping.
His principle is that model inputs can be unstructured materials such as documents, text, PDFs, and images, but the output “must be structured.” Only structured fields can be checked by code or rules, and the reward signal ultimately often takes the form of whether a particular field satisfies a standard.
This is precisely why Workflow will continue to exist for the long term. Workflow is human-driven, stable, and reliable but not sufficiently generalizable; Agent is AI-driven and can handle problems not anticipated in advance, but may “mess things up five times out of ten.” 王文锋’s rough split in one passage is that AI may handle 20% of more open-ended problems, with the remaining 80% being more common problems; he later says AI will mainly handle routine problems, without fully laying out the exact division of labor.
The core diligence question for investors is therefore not “do you have an algorithm genius,” and not even simply whether anyone has read Sutton. It is: “How are the incentive signals from the environment designed in your product?” If quality is still judged subjectively by another Prompt, the model may get trapped in an endless loop, repeatedly revising its opening line; effective feedback must come from external facts that the model itself does not possess.

14. Model Leaps Create Expectations; Costs and Engineering Cycles Set the Scale-Up Timeline

王文锋 reduces the key variables for future Agents to two: Context and LM. The result is “Context plus LM.” On the model side, he judged at the time of recording that GPT-5 might arrive “around the end of this year”; a new Foundation Model may first make the Demo work, but bringing costs down to one-fifth or even one-tenth of current levels could take another year.
He therefore estimates that genuinely useful Agents capable of mass adoption may not arrive until the second half of 2026. As for DeepSeek R3, he says he does not yet know how large a breakthrough it will represent; fundamentally, a Foundation Model breakthrough is still required—for example, when DeepSeek V4 appears and whether it can generate a new reasoning model on top of V4.
Context engineering cannot wait for models to solve the problem automatically. Cursor began extensive secondary development around VS Code in 2022 and had spent roughly 1.5 years on it by the second half of last year; by that estimate, excellent teams starting an Agent company in the new cycle will need at least 6 months and possibly a year, with a batch of better products potentially appearing in Q3 of that year. 王文锋 believes an Agent is not merely a Talker that knows how to speak: its engineering complexity is far beyond what the market imagines.
At the end of the episode, 王文锋 says the product will open an online Waiting List that week, with registered users potentially getting formal access in roughly 2 to 4 weeks. The website is SHEET0.com.

AI News Crossover: A Candid Chat with Liron Shapira of Doom Debates Trump vs Harvard, Nvidia export controls, how DEI killed Hollywood with Tim Dillon