Kimi K2 Breakdown vs ChatGPT Agent, Qwen3-Coder: Systems Engineering

Summary

• The core takeaway this episode: the moat in the agent race is systems engineering, not ideas. Zheng Boyuan’s section-by-section breakdown of the Kimi K2 report concludes that almost every trick already has a proof of concept somewhere in the literature: “all the ideas seem to be out there.” The hard part is tuning every link—prompts, parameters, data pipelines—for stable, high-quality performance. “Researchers are master craftsmen, doing skilled hands-on work.” For investors, engineering execution will distinguish winners more than paper-level novelty.

• OpenAI’s disappointing ChatGPT Agent is actually good news for the industry. Researchers “breathed a sigh of relief” because the problem was not solved in one giant scale-up, preserving room for exploration. Startups were “extremely excited,” with some even livestreaming arena-style demos of their agents competing with ChatGPT Agent to book flights: “Our agent is already done.” A genuinely difficult problem means more room for startup financing and products.

• The environment is becoming a new scaling paradigm—and a cost bottleneck. Boyuan’s view is that if RL really works, “one focus for everyone next may be to keep creating these environments, then generate large volumes of tasks and verifiable rewards on top of them as a new scaling paradigm.” Real-world interaction is extremely expensive: a single deep-research run may require roughly 100-150 searches; 100,000 rollouts using only browser interactions can cost several thousand dollars; and running web agents can get a lab’s IP addresses blocked. That is the commercial logic behind Browserbase’s Series B, while Kimi and Qwen3-Coder deployed 20,000 parallel sandboxes using Kubernetes and Alibaba Cloud, respectively.

• A potential solution to the data wall is turning the agent itself into a data engine. Pretraining data is “basically almost used up,” but every round of agent-environment interaction yields new information. K2 manually built sandboxes from GitHub pull requests and issues for RL training; Boyuan’s vision is for agents to crawl the web themselves, find reward environments, and achieve self-improvement—“let it train itself.” Few may be working on this yet, but it is a highly interesting research direction.

• The economics of taking Manus’s context-engineering route are clear. Application companies can iterate quickly through in-context learning rather than training models, with optimization centered on the KV cache. A cache hit costs “30 cents” versus “3 dollars” without one—a 10x gap that shapes the cost structure of agent products. Stable prefixes, append-only context, and masking rather than deleting tools are all engineering disciplines built around that spread.

• The rollout timeline is coming into focus. Coding agents have “already exploded”: “My friends and I are writing less and less code ourselves.” Tool use should follow soon, while browser and computer use still face infrastructure challenges. The vision is for “an entire army behind every person”: Claude writes code, ChatGPT polishes prose, Gemini reads long documents, and DeepSeek delivers sharp advice—“its mouth is vicious, but its views are incisive.”

• Agent safety is underestimated, with real commercial consequences. Boyuan’s agent actually booked a Tesla test drive, prompting Tesla to tell him, “It’s time for you to pick up your car.” Scale that to 1,000 agents and it becomes “an intelligent agentic DDoS attack.” His guardrail proposal—pause for user confirmation before high-impact actions—effectively places ethical responsibility with the user, making agent commercialization “relatively safer.”

Deep dive

1. The Two-Year Research Arc: Making Agents Actually Work

• Guest Zheng Boyuan is a third-year PhD student at Ohio State University researching language agents. His goal is to teach agents to “operate computers or browsers and serve as assistants”—in other words, computer-use agents. His roadmap follows a complete technical progression: first perception, as early unimodal models could read only extremely cluttered HTML before shifting toward GUI understanding; then grounding, because an agent may describe its next action in language but “cannot translate that action well into an executable operation”; and finally long-horizon planning, using a language model’s internal world model to assist planning. He is currently interning at Ai2 and researching large-scale reinforcement learning.
• His academic pivot was dramatic. He studied NLP information extraction as an undergraduate and master’s student, but “when ChatGPT came out, the entire research field changed.” His logic was that if language models had become “a good interface between human language and human intent,” he could build more difficult and more useful things on top of them.

2. Defining Agents: The Environment Is the Line Between an Agent and an LLM

• Boyuan’s framework starts with the observation that today’s agents are built on language models and use language as the medium for reasoning and planning, hence the term language agent. The key distinction from a language model is “whether an environment exists on this side”: the agent must perceive the environment and generate and execute actions that affect it.
• The paradigm difference is concrete. An LLM takes an input, produces an output, and stops. An agent operates in a loop: it receives an observation from the environment—an entire code base and execution logs for a coding agent, or a GUI screenshot or HTML page for a computer-use agent—combines that with the task and interaction history, generates an action, executes it, and changes the environment. The page refreshes, the code throws an error that must be debugged, and the cycle repeats.

3. Four Agent Categories: Coding Is Most Mature, While RPA Could Face One-Click Disruption

• By application, agents fall into 4 categories. Coding agents such as Cursor and the acquired Windsurf are the most mature; Boyuan says it feels “like a constant stream of interns helping me write code,” with 3-5 interfaces running tasks in parallel. Search agents, including OpenAI deep research and similar Gemini products, conduct large-scale retrieval and generate reports, benefiting market research. Tool-use agents are the focus of Kimi K2 and Qwen3-Coder. Computer-use agents include ChatGPT Agent and Operator.
• The more consequential industry judgment is that computer-use agents overlap with traditional RPA workflow automation, such as Salesforce. Workflows that once required large numbers of engineers to write manually “can now be fully automated with a single agent in one click,” which could affect the RPA industry.
• From a modeling perspective, the categories are unified by different observation spaces—code, text browsers, or GUI browsers—and action spaces, such as writing code versus clicking and typing.

4. Two Technical Routes: Manus’s In-Context Learning Versus End-to-End Training

• The biggest divide among the major approaches is between Manus and the other 3: whether to leverage the model’s in-context learning capabilities or retrain an agent end to end. Manus “makes extremely fine-grained use of the language model’s in-context learning ability,” with limited model training and rapid product iteration through prompt tuning and multi-agent system design. When building a website, for example, different models can act as the product manager, coding agent—“everyone generally uses Claude now”—and dedicated debugging evaluator.
• The trade-off with end-to-end training is that if the scenario is clearly defined, such as coding or browsing, and large quantities of reward signals and training data are available, an end-to-end agent “can be extremely powerful in a specific scenario.” But end-to-end training is difficult in multi-agent settings: interaction trajectories are extremely long, each agent has its own role, and “it becomes very hard to determine which agent the final reward belongs to.” Credit assignment is a real engineering constraint.

5. After ChatGPT Agent’s Launch: Researchers Exhale, Startups Open an “Arena”

• Boyuan had just returned from ICML, where the reaction split by role. Researchers “felt a sense of relief” because they had been worried that OpenAI or Gemini would scale RL training enough to “turn this problem into something well solved” in one shot. That has happened before: in 2022, ChatGPT “wiped out many small NLP research areas,” including his own earlier field, while GPT-4V disrupted multimodal research. This time, that did not seem to happen. “There is still a huge amount of room to explore.”
• Startups were “extremely excited.” One built an arena-style demo with 2 panels on screen, using soccer-style commentary as its agent and ChatGPT Agent both attempted a flight-booking task: “ChatGPT Agent is still completing the operation, but our agent is already done.” Boyuan’s point is that collecting domain data and using specialized prompting can make an agent good at a single task. But because the overall problem remains difficult and the exploration space remains broad, “it will help them to some extent with financing and products.”

6. Why K2 Created Such a Stir: Timing, Positioning, and “A Fully Open-Source Little ChatGPT”

• Three factors came together. The release timing was “really, really good”; K2 was one of the earlier models to position agent capability as its main selling point, and the paper was titled open agentic intelligence, landing amid peak interest in agents. More fundamentally, the model itself was strong. With accumulated pretraining data and more mature training algorithms, Boyuan’s experience was “a fully open-source little ChatGPT.” People could use it for free to build small applications such as front ends and “find that the results are genuinely quite good.”

7. Agent Safety: Tesla Test Drives, 1,000-Agent DDoS Attacks, and Responsibility Assigned to the User

• Boyuan’s own experience is the clearest lesson. A year and a half ago, he built SeeAct—possibly spelled SeeAct—which was among the earliest web agents to run on live websites. Its demo task was booking a Tesla test drive, and “the agent really completed it.” Around Christmas, Tesla kept emailing him: “It’s time for you to pick up your car.” A single agent is harmless, but “if we were not running 1 agent but 1,000 agents” all sending requests to the same store, “that could become a form of intelligent agentic DDoS attack.”
• Everyday forms of loss of control are equally dangerous. Ask an agent to buy a coffee machine and “it might accidentally order 1 ton of fresh meat or buy 1,000 cups of coffee,” or send someone a rude email. Read-only systems such as deep research are “completely fine,” while operator-style agents “are genuinely affecting the world.”
• His newly released paper proposes a guardrail: before executing an action, the agent assesses its impact on the world and pauses for user confirmation if the impact is large enough. “As long as the user approves it, responsibility shifts to the user, which makes agent commercialization relatively safer.” The analogy is autonomous driving: preserve safety while resolving the ethical problem.

8. Training Agents Versus Training Chatbots: Trajectory Data and RL

• There are 2 pillars. The first is large volumes of synthetic trajectory data—agent-style data in which observations, actions, and environmental feedback are interleaved. Such data makes up only a small share of natural pretraining corpora and is “insufficient to build a powerful enough agent,” so it must be synthesized or human-labeled. The second is reinforcement learning, which Boyuan believes may be easier to scale: provide a task and a verified reward, let the agent explore and try, and “it becomes easier to scale up the compute substantially.”

9. K2’s Three Contributions: Optimizer, Data-Synthesis Pipeline, and RL Framework

• The first contribution is the Muon optimizer. Kimi experimented with Muon early, and its “training curve looks extremely elegant.” Boyuan calls the innovative attempt “very respectable and very impressive,” but because the optimizer is orthogonal to agent capability, he largely skips it. The second and third contributions are the agent core: a large-scale agentic data-synthesis pipeline, using both simulation and real-world generation to produce tool-use data, and a general RL framework combining verifiable rewards with self-critique rubric rewards.
• Boyuan highlights an industry trend taking shape. Scale AI recently published a paper on Rubrics and Reward and labeled large quantities of data. The new paradigm of data annotation may be shifting from labeling SFT input-output pairs to labeling tasks, rubrics, and verifiable rewards—a structural change for the data-labeling industry.

10. Data Is Nearly Exhausted, but Agents Could Become a New Data Engine

• The backdrop is the familiar plateau: “The entire internet has basically been crawled.” Boyuan offers a counterintuitively optimistic view. The agent paradigm is not a closed system. Unlike RLHF, which trains only on preferences, a multi-turn RL agent “observes new data” in every interaction. If the information obtained through those interactions can be organized into knowledge—extracting useful procedures or facts—the agent itself could become a new data engine and, in turn, empower the language model.

11. The Craft of Rewriting Data: Coffee by the Fireplace Must Not Become Barbecue

• K2 uses K1.5 to rewrite existing data for augmentation. For knowledge data such as Wikipedia and books, it uses style-and-perspective-diverse prompting, with a large number of prompts controlling the rewrite’s style and angle to generate diversity. But rewriting introduces hallucinations: “Even if it is only rewriting an article, it might accidentally change one of the facts.” Boyuan’s analogy is asking a middle-school student to retell a 10,000-word novel: “The characters are drinking coffee or tea by the fireplace, and I might accidentally write that they are eating barbecue by the fireplace.” Small errors entering pretraining data can make model hallucinations worse.
• There are 2 defenses: chunk-wise autoregressive generation, which rewrites a long document chunk by chunk because shorter passages make factual consistency easier to control, and fidelity verification, which uses another model to compare the original and rewritten versions for common-sense errors and discard the bad ones. Xiaojun asks whether long context “affects intelligence.” Boyuan agrees: the Lost in the Middle paper by Nelson and others showed long contexts hurt performance, and after enough agent interaction steps, “the whole thing gets a little dumber; it may be remembering too much and fighting with itself”—his own “stream-of-consciousness, joking” formulation.
• The results include hard numbers. On SimpleQA, training 10 times on the same Wikipedia data without rewriting produced an accuracy of 23.76. Rewriting it once and retraining produced a significant increase, while training on 10 rewritten versions mixed together improved results further. The paper says the recipe works across many datasets. Mathematical data is rewritten into a learning-notes format, following the approach of a mathematical rewriting paper possibly called SolaMath. Boyuan compares it to the Feynman technique: “After learning something, teach it to someone else. Once you can teach them, you may have actually learned it.”

12. Copying DeepSeek V3’s Architecture: Open Source Means Hiring Engineers for Free

• K2’s architecture “basically follows DeepSeek V3.” The team’s authors explained on Zhihu that they tried different approaches but found V3 “was already a well-optimized architecture,” so they adjusted only hyperparameters such as the number of experts, attention heads, and dense layers. Boyuan points to the hidden benefit: open-source inference frameworks such as vLLM and SGLang have already optimized heavily for V3. Following it directly makes inference more efficient because “PhDs from around the world will voluntarily optimize the architecture—it feels like free-hiring a large number of engineers.” That is the real economics of open source.

13. The First Principle of Post-Training Data Synthesis: Diversity

• The K2 team repeatedly emphasizes that the core requirement is to make the data “diverse enough.” Boyuan’s own experiments support this. Ask a language model to propose tasks for itself in a website environment and “its diversity quickly hits a ceiling,” because it is sampling tasks from the model’s own prior and the observed data is limited. Nearly every step of the synthesis pipeline is designed to break through that ceiling.
• The first step is building the tool universe by collecting more than 3,000 MCP tools from GitHub. Boyuan adds the context: MCP, Anthropic’s Model Context Protocol, standardizes tool interfaces. Before it, APIs had inconsistent parameters and interfaces and required extensive engineering work to normalize. Newly emerging MCP tools also “more or less come with application scenarios,” making them higher quality than APIs crawled out of thin air.
• The second step is systematic expansion. A t-SNE visualization in the paper shows the original tool distribution was “extremely sparse,” so hierarchical domain generation, based on a WizardLM synthesis approach, expanded it to more than 20,000 tools. Boyuan flags what the paper does not make clear: does tool synthesis generate MCPs from scratch, or combine and rewrite the interface descriptions of existing MCPs? “Based on the context and the cited paper, my guess is that it combines the original MCPs in some way.” He invites listeners to read the paper and discuss.

14. Creating Scenarios, Personas, and Scoring Standards: Approximating Downstream Applications Through Data Synthesis

• Agent diversification generates large numbers of system prompts to create agents for different scenarios. Some are good at coding, some at data analysis, and “some have higher emotional intelligence.” Boyuan’s interpretation is that randomly sampling 10 MCPs from 20,000 to form a small environment, then adding a role definition, “is essentially creating application scenarios for downstream users’ application scenarios.” The synthesis process keeps moving closer to real use. Role-playing also protects diversity: asking a model generically to “use tools” produces far worse results than giving it enough context to understand its role.
• Tasks and rubrics are generated together. A rubric is a textual completion standard covering success conditions, expected tool-call patterns, and evaluation checkpoints. Generating both at once “tends to be more accurate experimentally,” because the scoring standard can be anticipated while the task is being created. Difficulty also progresses from simple to complex. The rubrics are later used to filter data: because not every trajectory can succeed, the rubric lets a model judge whether the task was completed. “If it succeeds, put the data in; if it fails, rewrite it or throw it away.”

15. Generating Trajectories: Personas Simulate Users, and the Simulator Is “Equivalent to a World Model”

• User simulation uses an LLM to generate personas. Lawyers, chefs, and product managers communicate differently and have different preferences for completing tasks. “This also simulates downstream application scenarios,” while forcing the LLM to interact with different communication distributions during trajectory generation, adding another layer of diversity. Boyuan notes that using personas to increase diversity has appeared in many areas and is empirically a very good approach.
• The tool execution environment is the most ambiguous part of the paper. K2 says it built a tool simulator “equivalent to a world model.” Boyuan offers 2 possibilities: a trained neural network provides execution results, or a local sandbox is built. “Based on the description, I lean toward the former, but in that case, no matter how the world model is optimized, it will differ substantially from the real world and introduce noise.” K2 therefore uses a hybrid approach, combining simulated data with real-environment interaction data. He again leaves the uncertainty to listeners: “You can also read the paper and let us know.”

16. Interacting With the Environment Is Extremely Expensive: Blocked IPs, Cloud Browsers, and Environment Creation as Scaling

• Boyuan believes academia has “underestimated the price of interacting with the environment to some extent—it is actually extremely expensive.” His rough calculation: a deep-research task may require around 100-150 Google Search API calls. Even at 1 cent each, multiplying that by the huge number of rollouts needed for RL training produces a large bill. Browser interaction is more expensive still. Running web agents on real websites got “my apartment, my lab, and the IP addresses of my school cluster blocked,” a problem many web-agent researchers have reported. The solution is cloud browsers such as Browserbase, which provide IP pools and anti-blocking engineering—“but they charge a lot.” A rough estimate is several thousand dollars for the interaction alone in 100,000 rollouts. Running Docker sandboxes locally also consumes huge amounts of CPU and memory.
• Xiaojun compares it with robotics, where human data accounts for 1% and simulation for 99%. Boyuan agrees that robotics “can be an extreme example of the cost of environment interaction.” Digital agents are cheaper, but still expensive. That leads to his key deduction: “If RL really works extremely well, one focus for everyone next may be to keep creating these environments, then generate large volumes of tasks and verified rewards on top of them as a new scaling paradigm.”

17. Systems Engineering Is Greater Than Ideas: The Craft of the Master

• Xiaojun asks whether the work is primarily an engineering challenge. Boyuan’s answer is the episode’s central theme. K2 is “very practical”; all the recipes and tricks are in the paper, “but if we really want to build it, and build it very efficiently, that itself may still be difficult.” Every component requires prompt and parameter tuning and stable operation. “It is a huge engineering effort in itself, like a skilled craft.” Xiaojun summarizes: “So researchers are master craftsmen, doing skilled hands-on work.”
• “Systems engineering is greater than ideas, right?” Boyuan agrees and offers a more structural argument. K2 cites the papers behind each trick, including WizardLM and AutoIF. “Many of the ideas already exist in the market. Everyone has validated them on a small scale; they are proof of concepts.” The systems-engineering challenge for LLMs is combining those tricks and validating them at scale. “I can already feel very clearly what needs to be done next, but every single item requires a huge amount of engineering to make it work well.”

18. Two Types of RL Rewards: Verifiable Rewards and Self-Evaluated Rubric Rewards

• The overall RL strategy is to scale up RL by obtaining large quantities of diverse tasks and verifiable rewards. Boyuan divides tasks into 2 categories. The first is the classic verifiable type—mathematics and coding—the area where DeepSeek R1 and OpenAI o1 first showed results. The defining feature is that correctness “can be determined very easily with a simple program or function”: check the answer in mathematics, or run unit tests for code, “like the tests used for a LeetCode problem.”
• The second category includes creative writing and open-ended questions, where “it is difficult to find a way to evaluate them objectively.” The solution is self-critique reward: ask the model to judge the quality of its own answer and use that judgment as the reward. K2 ultimately combines both reward types.

19. Difficulty Is Delicate: Too Easy Teaches Nothing, Too Hard Makes the Signal Sparse

• Mathematical, STEM, and logic tasks require diverse coverage and moderate difficulty. Boyuan explains the logic clearly. If a task is too easy, “every attempt succeeds, so there is very little signal to learn from”—like solving simple high-school exercises with a perfect score. If it is too hard, the agent may succeed only once after 100 or 200 attempts, making the reward sparse. “If every rollout in the batch fails, the model has no idea which direction is correct when it updates.” The practical method is simple: let a model with no RL experience attempt the same question k times and filter by accuracy. The scale “should keep adjusting throughout training.”
• He points to a subtle gap between marketing and paper language. OpenAI repeatedly stresses “easy to verify but hard to answer,” while Qwen emphasizes that tasks should be extremely difficult. K2 calls for moderate difficulty. Boyuan reconciles them by saying difficulty “depends on the capability of the base language model; it is a case-by-case question.”

20. Instruction Following and the Anti-Reward-Hacking Layer

• Agent tasks impose much higher demands on instruction following. The agent must continually interact with the environment and adjust its actions while remaining consistent with the original task and system prompt, even as the context becomes extremely long. K2 uses hybrid verification: a code interpreter first checks length, writing style, and constraints, followed by an LLM judge. The paper explicitly describes this as a layer against reward hacking.
• Boyuan explains reward hacking through a high-school cheating analogy. “Once the agent is powerful enough, it may become extremely cunning.” It may guess the answer correctly while “writing nonsense in the reasoning process,” discover that cheating earns points, and then overfit to the exploit until “training becomes very poor.” The data pipeline has 3 steps: human experts label complex instruction-following tasks, which is expensive and difficult to scale; AutoIF, from an earlier Qwen paper, automatically expands seed tasks; and an adversarial model generates instructions targeting failure cases and edge cases to increase complexity.

21. Adding Faithfulness to the Reward: K2 Ranks Around the Top 10 on Hallucination

• Models “sometimes simply make things up,” and their thinking process may have “not that much to do with the final answer.” K2 therefore adds factuality to the reward, using Fact Grounding from a Google paper for sentence-level fact judgments. Boyuan makes an important meta-observation: some papers look like simple fact-verification tasks in isolation, “but once placed in the language-agent RL-training paradigm, they gain additional meaning—they may become a way to adjust model behavior.”
• He checked K2’s hallucination-benchmark score: “It ranks pretty high, probably around the top 10 among all models. It is possible that this trick played a role.”

22. The Core of Coding RL: Turning GitHub Pull Requests and Issues Into Rewarded Sandboxes

• There are 2 data streams. One is competition-level programming problems, such as LeetCode and coding contests. The more important stream is collecting large numbers of pull requests and issues from GitHub, taking the code base from that point in time, and building a sandbox. The pull-request content and final solution become the verifiable reward outcome, with unit tests enabling large-scale training on software-development tasks. Boyuan believes “this may also be one of the core elements of its RL capability.”
• He then develops the episode’s most ambitious brainstorm: can an agent find reward signals proactively and train itself? A web agent could crawl and explore the internet, “accidentally enter a GitHub repo, discover that there is a verified reward, automatically take the data, and automatically build a sandbox environment.” Even without full automation, agents could explore while engineers filter the results. “That might enable a form of self-improvement for agents.” He is candid about the state of the field: “Perhaps no one is doing this yet, but I think it is a very interesting research direction.”

23. RL Training Details: Short Answers, Anti-Forgetting, and Annealing

• Budget control prevents agents from overthinking on irrelevant actions. Responses that are too long are truncated and penalized. Boyuan connects this to user experience: someone on Zhihu said Kimi’s answers tend to be relatively short and concise, with a thoughtful summary at the end. “I think that may be related to this reward.” K1.5 used a more complicated length reward—short and correct—while Kimi K2 has “gone back to basics.”
• PTX loss helps prevent catastrophic forgetting. When RL focuses on learning to take actions, “the model may lose a lot of important knowledge from pretraining,” so high-quality pretraining samples are mixed into RL training. Temperature decay gives the weaker model more room to explore early on and generate diverse actions—“as long as there is a positive reward, encourage it”—then gradually lowers the temperature as behavior stabilizes, creating an annealing phase that keeps training stable.

24. Agent Rollouts Are a New Infrastructure Challenge: Long-Tail Trajectories and Idle GPUs

• Boyuan emphasizes Section 3.4 on agent rollouts. Existing training frameworks schedule rollouts for RLHF, where latency is stable and multi-turn interaction is limited. Agents are fundamentally different. Interaction latency is unstable: a browser may suddenly stall or crash, leaving the GPU idle. There is also a long tail. In a batch of 256 rollouts, 250 may finish within 5 steps in 3 minutes, while the remaining 6 take 10 minutes, leaving large amounts of GPU capacity idle.
• K2 combines several countermeasures. Heavy environments are packaged as separate services with APIs and dedicated compute. Concurrent rollouts are oversubscribed: “I may ultimately need only 64, but I start 640 at once; once 64 are complete, I end the process.” Long-tail trajectories use partial rollouts, stopping them and resuming them in the next RL iteration. Boyuan flags the risk: resumed actions were not generated by the current model policy. An error the previous model made may have disappeared after the parameter update, but the old trajectory still suggests the current model makes it, creating problems when used for updates.
• At the code level, the system follows the OpenAI Gym interface pattern, now Gymnasium: environment interaction is encapsulated and exposes step and reset. “Most RL training code, in my view, basically follows this framework.” K2 plans to extend its RL infrastructure to more diverse interactive environments, and Boyuan hopes that will include browsers and computer use. Qwen3-Coder deployed many sandboxes on Alibaba Cloud, while ChatGPT Agent uses many virtual machines. “Both sides are solving essentially similar engineering problems.”

25. ChatGPT Agent: Unifying Operator’s and Deep Research’s Action Spaces

• Combining the release blog with interviews between the team and Sequoia, Boyuan’s interpretation is that ChatGPT Agent essentially unifies the action spaces of Operator and deep research. Operator is good at understanding GUIs and navigating web pages, but may not be strongest at locating large volumes of text. Deep research uses a text browser for extensive searches and URL clicks, then summarizes information. There are 2 possible implementations: a multi-agent system connected by an end-to-end reward signal, or a single agent trained end to end over a unified action space. “My current feeling is that it is more likely just unifying the action space rather than building a multi-agent system, but there is no clear information.”
• On the training-data side, he shows what BrowseComp-style information-retrieval data looks like. The task description may be elaborate, while the answer is “just a very short answer, such as ‘plastic man.’” The information must be extremely difficult to find, but the reward must be easy to assign by checking whether the answer matches. “It is like setting yourself a difficult problem, while having a way to know the answer.” This follows the same philosophy as verifiable rewards.
• But computer-use training presents a larger challenge. BrowseComp-style information seeking is easy to verify, but once the task involves ordering a product or checking flights, “on most websites we have no way to access the backend data.” Small sandboxes can expose the backend, but “if we really want to scale up, we may need highly sophisticated ways to obtain this kind of verified reward.”
• The benchmark results produced a memorable line. Humanity’s Last Exam receives a very high score: “It is called humanity’s last exam, but given how good the results look now, it may not be humanity’s last exam. It may be humanity’s second-to-last or third-to-last.” FrontierMath’s score is not high, but it improves substantially over the baseline. The evaluations covering PPTs, spreadsheets, and data science “basically all correspond to real user application scenarios.”

26. Qwen3-Coder: A Detail-Free Report and a Leaderboard Losing Its Shine

• Qwen3-Coder released only a blog post. “There are no details; I really want to see the details.” Data synthesis receives a single sentence, while the bulk of the discussion covers scaling RL, “hard to solve but easy to verify,” and 20,000 independent parallel environments deployed on Alibaba Cloud. Boyuan’s reminder to academia is that “opening this many sessions comes with a real cost. Academia may also need enough engineering capability to make it work.”
• His observation about leaderboard culture is the signal here: “People do not seem to look at leaderboards as much anymore. They may not fully reflect model performance. People care more about how the model feels in use”—as well as actual call rankings on OpenRouter, where Qwen3-Coder does rank very highly. Compared with K2, it adds agentic browser-use evaluations: Mind2Web, work from Boyuan’s own group that labels large numbers of trajectories on real websites to test generalization across sites, and WebArena, a website sandbox with backend-database access for precise evaluation. “The performance is genuinely quite good.”
• Another common practice is releasing a CLI tool alongside the model, integrating with Gemini CLI and providing a VS Code extension. “These models are not merely being trained, benchmarked, and shown off. They are actually being applied in real life across different scenarios.” If companies can collect user-agent interaction data, “they may be able to use it to further improve the agent itself.”

27. Manus’s Context Engineering: Everything Revolves Around the 10x KV-Cache Gap

• The blog’s author, Peak, also came from the BERT era, when models lacked in-context learning and downstream tasks required SFT. After ChatGPT, “a language model could generalize simply through language descriptions.” Manus therefore chose context engineering over end-to-end training—“which is indeed extremely expensive”—to iterate quickly into a product.
• The core idea is KV-cache optimization. In transformer attention, if the preceding context does not change, the KV matrices can be reused rather than recomputed, making inference faster and cheaper. A cache hit costs “30 cents,” while a miss costs “3 dollars,” a 10x gap. That creates several engineering rules: keep the prompt prefix stable and do not modify it; append to the context without changing the middle; and when a tool is no longer needed, mask it rather than delete it—“mask, don’t remove.” During generation, the model can simply ignore it. This is another clever use of the KV cache.
• Other lessons include using the file system as external context storage. But longer context makes the model dumber, so todo.md is used to manipulate the model’s attention and pull it back toward the goal. When the model makes a mistake, “keep it in the context” rather than removing the failure. Few-shot examples must also be diverse; otherwise the model “tends to repeat the earlier content continuously,” wasting tokens on useless generation.

28. From Context Engineering to Agent Memory: A Full Set of CRUD Operations Is Needed

• Boyuan extends the argument to memory. Agent memory must be distinguished from chatbot memory: chatbot conversations are unstructured, while an agent’s interactions—actions, observations, and environmental feedback—are “highly structured” and can run for many more rounds. His view is that agents need a structured memory mechanism capable of efficient create, read, update, and delete operations. Insert a new action if it is useful; modify related memories after execution if needed. “That is necessary to keep the agent system running efficiently. More research is still needed here.”

29. Research Outlook: Self-Improvement and Wasted Rollout Data

• There are 2 research priorities. The first is self-improvement: let agents take actions on the web and automatically find reward environments suitable for training. The second is reusing rollout data. Under the current RL paradigm, “a lot of data in the rollout process is not being used efficiently.” He cites his own SkillWeaver work: a web agent proposes tasks in a new environment, such as booking flights or searching for information on a flight website, explores and executes them, and uses a reward-model module to determine success. Successful trajectories are converted into APIs. A random website can then automatically generate large numbers of APIs, allowing the agent at inference time to call an API directly instead of generating actions step by step through the model, which is “extremely slow.” “There may be a way to accumulate the useful data or knowledge from the agent’s exploration process and use it to further improve the agent or the language model itself.”
• There is also an application-side flywheel. Coding agents “basically spend every day alongside humans.” When users modify the agent’s code, that is similar to providing a reward, making human users annotators. Boyuan connects this with 2 ideas: the research-product co-design proposed by Murati’s team, likely Thinking Machines Lab, and the Windsurf acquisition, where “what the acquired company wanted was also the large volume of user and agent data they had accumulated,” whether used to improve prompts or train the agent.

30. The Unsolved Interaction Problem: Most User Instructions Are Ambiguous

• Boyuan’s self-observation is that “my instructions are actually extremely vague most of the time.” For example, asking an agent to find a coffee machine under 100 yuan produces too many options, but “I also do not want it to buy me something at random.” The agent should learn to ask clarifying questions about color, brand, and other requirements, resolve the ambiguity with the user, and then complete the task. He believes coding agents already handle this well: “Sometimes when I write code, I do not even know at the beginning what I want to write. The agent keeps iterating with me, and eventually I understand what I wanted to build.”

31. Humans and Agents in Symbiosis: An Army Behind Every Person

• Asked what network humans and agents will ultimately form, Boyuan offers the episode’s most vivid image: “The agent is another brain of mine, an extended brain… When I go about my daily work, there is an army behind me helping me get things done.” The division of labor is already emerging: Claude handles coding, ChatGPT polishes papers and writing, Gemini organizes large document collections because of its strong long-context capability, and native DeepSeek provides “extremely sharp, extremely cutting advice.” “DeepSeek can be pretty vicious sometimes, but what it says and the views it expresses are extremely incisive.” He speculates that this may reflect the large volume of Tieba data in its training set. “In the future, everyone may have a whole family of agents.”
• Chatbots’ personality differences are becoming real product differentiation. Yuanbao is “more of a sycophant.” Xiaojun thinks ChatGPT has become more emotionally intelligent, “but after becoming more emotionally intelligent, it seems to have become dumber.” How should emotional intelligence be tuned? Boyuan points back to K2’s rubric-based reward. Rubrics can specify helpfulness and creativity, but also that the agent should be emotionally intelligent, empathetic, and pleasant—or the settings can be reversed to make it speak more sharply. Values and personality are now reward-engineering knobs.

32. Timeline and Temperature: Coding Has Already Exploded, and Two Weeks Away Can Change Everything

• The breakout timing differs by scenario. “Coding has already exploded”: “My friends and I are writing less and less code ourselves. We basically have the agent write a rough version, then we edit it.” The weak spot is systems-level code, such as Ray and multiprocessing, while front-end work is “extremely powerful.” With user-interaction data added, the field “may explode particularly quickly.” Tool use “should come very soon,” while browser infrastructure may still be difficult. Overall, development “may move extremely fast.”
• The competition is tangible. There are now many PhD students choosing the agent field, and “there are simply too many papers.” The pace is “one change every week”: “Once I took about 2 weeks off and barely read any papers. When I came back, the entire landscape had changed. It was terrifying.”