AI trend summary for Q2 2026: Agent stumbles its way into the world

Author: Boyang, Tencent Technology

At the end of last year, most people were still treating AI as a chat tool—asking it to answer questions, write copy, or summarize资料. Once the Q&A ended, the AI’s job was over.

By the second quarter of 2026, things changed. Because OpenClaw, Codex, and Claude Cowork pulled AI out of the chat box.

Agents can start reading files, running code, making tables, operating software, and even connecting to an organization’s internal systems. You give it a goal, and it will break down the task on its own, call tools, finish the work, then come back to report.

OpenClaw, which was born in March, marked a shift in public understanding of Agents. Before, when people mentioned Agents, everyone assumed they were mainly for assisting with coding. With the “lobster” in place, it started taking over work across many fields.

Over the past three months, what we’ve seen is the experience of this “beginner” entering a real work workflow.

It became a new software entry point, moving into professional scenarios like finance, law, and design. Enterprises saw its potential and launched large-scale Tokenmaxxing. But after burning through investment for two months, this unlimited AI leap abruptly stopped. Because they found that the parts where AI improves productivity were again stuck behind approvals and judgment bottlenecks. And when everyone went back to fill those gaps, issues around runtime speed and costs reappeared.

The eight trends summarized in this second-quarter report were born from these collisions between reality and ambition.

Starting from the second quarter of 2026, the core question shifted from whether Agents can do work to how to build an efficient Human in Loop system—and how to effectively reduce Agent costs.

General Agents going to sea, becoming the shape of AI OS

Codex, Claude Code (Cowork), Workbuddy—what they’ve been transforming into in this period is a shift toward “general Agents.”

Why call it general? Because in OpenAI’s own report, just in those two months of April and May, among Codex users, 20% emerged who didn’t do programming work. Their growth rate is 3x that of programming users. Codex was originally built for programming; now it’s built for everything.

Because if you don’t know how to code, you need Agents. Anything in this world that needs repeatable processes requires Agents.

And with Harness (execution framework) and Skill (skill modules), Codex can really handle complex workflows. Not all of them, but it can already do a lot.

Since they’re general, the debate from the past year about the “entry point in the AI era” can be temporarily put to rest.

If something can do everything, it naturally becomes the entry point to everything.

Around 2025, the industry bet heavily on “AI browsers.” After all, over the past twenty years, browsers have been the mainstream entry point to the internet—whatever you want to do, you have to open a web page. Even after apps appeared and browsers’ role declined, they were still top-tier.

For AI to be an entry point, it must control that entry point too, clicking buttons on web pages and filling forms in the same way.

Google did Project Mariner, OpenAI did Operator, Perplexity launched Comet, and later even proposed a $34.5 billion acquisition of Chrome. Since browsers can contain people’s entire internet life, they should also contain Agents—many people thought that was the case.

But today, one year later: in May 2026, Google shut down Mariner, folding the related capabilities into Gemini Agent. Operator also moved into the larger ChatGPT Agent.

Meanwhile, Codex, Claude Code, and Cowork directly connect to files, terminals, code repositories, data connectors, and local applications—their usage growth has been much faster.

Behind this is the long-burning question from Q1: whether the GUI still needs to exist. Graphical interfaces (GUI) are for humans—colors and buttons help people understand the system, but Agents don’t need them.

Having Agents wait for web pages to load, recognize buttons, and simulate mouse actions is detouring. Command line interfaces (CLI) and structured data are far more direct for them.

Following this line of thinking, the GUI still exists, because people need the front end to confirm and select. In loops with human participation, CUI is still necessary—maybe even more efficient.

So browsers won’t disappear, but they degrade from the “main entry point” into just one tool inside an Agent toolbox. Data runs underneath; pages only present results to humans so they can modify them.

Once the entry point is stable, model companies start pushing into vertical industries.

In April, Anthropic launched Claude Design, letting Agents read brand guidelines and code repositories to produce design drafts, prototypes, pitch decks, and marketing materials. Then it also rolled out finance Agents split by role—covering valuation review, general ledger reconciliation, month-end closings, and KYC—before bringing similar methods into the legal domain. OpenAI didn’t follow the same path completely. While it embedded finance, health, research, and safety capabilities into models and first-party products, it also connected enterprises’ existing systems using Apps, MCP, AgentKit, and Frontier.

Though the forms and depth differ, the underlying logic is still built around the big framework of general Agents.

In the past, when model companies moved into an industry, they had to do some data fine-tuning, develop new workflows to adapt to the industry, and connect new interfaces—one company did it one way.

But now, the same Agent stack can continue to be used at the base layer. If you want to do finance, connect the general finance database via MCP, add valuation methods and compliance workflows as Skills, and then every corresponding staff member can use them—just add what’s needed. If you want to do legal, swap these with contract clauses and legal search.

To go from general Agents to industry Agents, the only changes required are industry knowledge, data, and work rules; the execution environment can be fully reused.

As a result, the moat of vertical software changes too. With MCP and Harness, you only need to buy a few databases and find a few experts to create standards and guidance, and a “basic working” vertical model can be built. It’s easy even for model companies.

What remains harder to replicate is enterprises’ own data, permissions, and acceptance records.

For example: whether the final legal edits were accepted by the counterparty; whether the valuation assumptions were later overturned by the investment committee—these user data will then teach the Agent how to do it next time.

Who can capture and use such feedback faster and earlier gets the first-mover advantage.

As long as the large model market hasn’t pushed everything into fixed domains, you still have an early advantage in data accumulation.

So vertical capabilities can be assembled in bulk for the first time.

And as Agents take on more and more tasks, the outputs they produce may not be something human organizations can absorb.

Tokenmaxxing—after Agents went to sea, the first wall they hit

Tokenmaxxing was possibly the hottest term in all of May. Big companies saw how useful Agents were, so—at least in theory—if they gave employees more Tokens, more tools, and longer run times, their output should double or triple. And they didn’t need employees to learn how to use it much—“my employees need to adapt faster to the AI era so they don’t fall behind in efficiency.”

Under FOMO and exaggerated views of Agents’ capabilities, burning Tokens became a kind of “proof of effort” in the AI era.

Jensen Huang publicly said: if an engineer earning $500k per year can’t burn $250k worth of Tokens in a year, the boss should be worried whether he’s using AI fully.

In just three months, the fire had no more kindling.

Amazon’s internal ranking charts triggered massive ineffective tasks made purely to climb the leaderboard—eventually it had to be shut down. Uber’s Claude Code budget nearly ran out by April, yet management didn’t see a stable relationship between Token consumption and effective feature growth.

You couldn’t burn it for a simple reason: it was expensive. Simple Q&A might only call a model once, while Agents doing long tasks repeatedly read goals, historical state, tool outputs, and error information.

Token consumption for complex tasks can reach tens of times or even thousands of times that of normal Q&A.

At the end of May, HIT submitted a proposal called “effective feedback compute,” specifically calculating how much of the compute spent actually influences the next step. In complex tasks, that ratio is as low as about 10%. The remaining 90% of Tokens are mostly spent re-reading, trial-and-error, and ineffective back-and-forth.

Money wasn’t even the biggest problem. Even if the Agent burns all the Tokens “correctly,” what it produces might still not reach final delivery.

After code is written, there’s review, testing, integration, and release. After a report is generated, you must verify sources and judge the conclusions. Design drafts still have to pass brand, business, and client approvals. If an automated workflow fails, someone must explain, roll back, and be accountable.

A study by MIT covering more than 100,000 GitHub developers found that autonomous programming Agents can increase code submission volume by 120%. But those codes shrink to 50% by the phase where projects are approved; and the versions that are truly published and go live are only 30%.

It’s like a restaurant suddenly triples its vegetable chopping speed. But stir-frying, plating, serving, and customer demand don’t change. The kitchen fills up with pre-chopped vegetables, but the restaurant still sells only the same number of tables per day.

In economics, there’s a theory called the substitution theory: workflow efficiency is determined by the portion that cannot be replaced by automation. AI boosts generation speed, but review speed is slow—so Agent productivity gets choked in the system.

Repetitive production also burns another portion of Tokens. Because the speed of generating a Skill, module, or application increases dramatically—and there’s a lack of effective synchronization—people don’t know what existing results already exist, so they often go back to rewrite. Nanyang Technological University analyzed more than 20,000 Skills on the market and found that about three-quarters are highly similar; after deduplication, only more than 5,000 remain.

Even the code fixes submitted by Agents are often rejected because “someone has already solved it.” Tokens go up, but what remains is a pile of duplicated wheels.

Demand doesn’t grow along with supply. AI can rapidly increase the number of apps, content, and code—but users’ time and willingness to pay don’t increase at the same rate. Writing an app becomes easier and easier, but finding sustainable demand where someone is actually willing to pay remains hard. Research on app markets shows that after AI, the number of apps surged by 40%, but downloads stayed flat.

Tokenmaxxing can’t create markets that didn’t exist in the first place.

Tokenmaxxing collapsed noisily, but it exposed two bottlenecks. One is technical: Agent spends ineffectively, and speed and cost can’t be brought down. The other is organizational: replication, judgment, coordination, and accountability systems weren’t built, so productivity improvements on the production side couldn’t be absorbed—and even successes weren’t effectively used.

In the next quarter, the most watched technical changes will be about filling these directions.

Using Agents to replace people who are still stuck in the loop

If one Agent is too slow, let a bunch work together. If no one checks after one Agent finishes, dispatch another Agent.

Let multiple Agents divide work, cross-review, and cover gaps for each other—moving into the system a portion of work that used to be pushed onto humans.

This drives the Multi-Agent craze in 2026.

The most reliable Multi-Agent pattern today is the “orchestrator—executor” model. In other words, the main Agent breaks tasks into pieces, assigns them in parallel to many sub-Agents, and finally collects everything back into a consolidated result.

For example, Claude Research will dispatch multiple research Agents to search in parallel, then have the lead researcher summarize; the Agent that handles citations is responsible for verifying sources. Kimi Agent Swarm goes further: it can let hundreds of sub-Agents handle video, code, and search tasks in parallel.

For work that is suitable for parallelization (like batch processing videos or code), this approach works extremely well. It dramatically shortens waiting time and allows parallel sub-tasks to go deeper. Kimi’s report says the latency for some tasks drops up to 4.5x. Claude Research has also achieved clear improvements for questions requiring broad searches.

However, in this kind of setup, Multi-Agent gains often come from extra computation, not from cooperation itself. Anthropic disclosed that a multi-Agent research system can consume Tokens up to four times that of a normal Agent. In some evaluations, Token usage explains most performance differences.

Today’s Multi-Agent is more like a project manager directing multiple separate outsourced teams that don’t really “interact.” It can spread work across teams to do in parallel, but it hasn’t formed “swarm intelligence.”

In all kinds of studies, once you remove the central “foreman” and let Agents discuss on their own, humans’ organizational problems all show up. Some follow the majority opinion; others think “someone else will handle it,” then slack off.

Tests show that when several Agents team up, accuracy can actually be worse than a single Agent with full information.

The core reason is that in the model’s training process, “collaboration” wasn’t set up as a problem to learn. If you lock a bunch of models that are used to solo work into one room, organizational collaboration skills don’t appear out of thin air.

Collaboration is another game. My actions change your situation, and your judgment changes my choices.

So what Multi-Agent needs to add next is制度: how to divide tasks, how to share information, who is accountable for errors, how rewards flow back along the work chain, whether Agents with poor long-term performance get eliminated—these all require design.

Another path that goes further is “self-evolving AI,” i.e., RSI.

Anthropic mentioned this concept in a June report. They let the model continuously optimize a piece of code used to train a smaller model. As the model’s capabilities improved, the optimization factor went from about 3x acceleration from Claude 3 to Mythos, and then all the way to more than 50x.

Its core idea is the same as human experiments: in five steps—find problems, figure out ways, build environment and data, validate results, keep the effective changes—then run it again.

Companies like Minimax have already built these automated workflows into post-training so it can be fully automated.

As long as goals and scoring criteria are clear enough—for example, “optimize this code’s running speed by 50x”—the Agent can find problems, change code, run tests, keep useful changes, and loop repeatedly.

It does this kind of work better than humans: fast, and never gets tired.

But it still doesn’t know where to go. In cases where decisions must be made across extremely large search spaces—like “which research route is valuable” or “is this metric lying”—we call that “taste,” and Agents still perform poorly.

In Anthropic’s experiments, in complex direction-decision processes—especially when humans make mistakes—models only have about a 20% chance of doing better than humans. If humans themselves are already doing well, the model has even less competitive advantage.

Another concept that blew up in June is that Loop Engineering turns this kind of cycle into long-running engineering. Agents no longer wait for a person to click and then act; instead they find tasks, execute, verify, record feedback, and then decide what the next iteration should do.

That was the technical side. Agents also have to “add up” an economic side.

Can’t just solve economics

In the past few years, GPUs have been the star of AI compute. Training large models requires continuously completing massive matrix computations, and GPUs are great at that. CPUs mostly just launch programs and prepare data—low visibility.

But Agents work differently. It’s not a one-time transaction; it switches back and forth between inference, tool calls, and waiting for results. Much of the time is spent outside the model compute itself: tuning the browser, managing files, and handling timeouts. If anything blocks in the middle, the expensive GPU can only idle.

In a paper published at the end of 2025, 《A CPU-Centric Perspective on Agentic AI》 measured five categories of Agents. Tool handling accounts for up to 90.6% of total task latency, while CPU dynamic energy accounts for 44% of system dynamic energy. After jointly adjusting CPU and GPU task assignments, some workloads’ median latency improved by more than 2x.

So the CPU is back at the center of the compute system. GPUs continue doing inference, while CPUs maintain the concurrent environment, manage task queues, and tool calls. KV and memory store each Agent’s sandbox, logs, and intermediate results. The network sends data between chips and servers. If any part in the middle gets congested, the expensive GPU can only wait.

The capital market has already started pricing this change. In Q1 2026, AMD’s data center business revenue was about $5.8 billion, up 57% year over year, and server CPU revenue growth exceeded 50%. Companies doubled their forecast of the 2030 server CPU market size to $120 billion, citing the scheduling, data movement, and execution demands brought by Agents.

Besides speed, model pricing is also starting to tier. In Q2 2026, the cheapest mainstream models brought the cost per million input Tokens down to a few cents; the most expensive frontier models reached tens of dollars.

Two years ago, the price gap between low and high was about 30x; now it has expanded to about 600x.

Low-price models take an ever larger share of Token traffic, while high-end models continue to capture key tasks and most revenue. Many steps don’t need the strongest model. For things like reading repositories, classifying, extracting, and organizing logs, cheaper models are enough. Only complex refactoring, security audits, legal judgment, and crucial decisions after failures are worth the high price.

But model pricing today doesn’t automatically create a tiered routing system. ChatGPT has routing and assigns models based on task difficulty, but the results aren’t good, so people don’t use it much. In June, however, Sakana’s Fugu performed extremely well because it doesn’t use one model to decide—rather it separately trains an Agent to do routing. It first understands the task, dynamically builds a work scaffold, and then calls different models with different prices and capabilities to form a temporary team. The most expensive model only handles critical steps; other work is handled by cheaper models.

Using only half the budget, it achieves the best model’s results.

Programming may be the first area where this approach works, because there’s ready feedback. Repositories, code differences, tests, Lint, CI, and logs can all tell the routing system whether the last assignment was effective.

The cheap models read code and generate tests. Mid-tier models do routine modifications. Strong models handle core refactoring and security re-checks. Then everything is handed to tools for acceptance.

And in the future, products like Codex and Claude Code will definitely produce similar automatic categorization. They will look more and more like engineering organizations managing model teams. They will allocate budgets to make different models do work, instead of relying on one model end-to-end.

But the problems aren’t over. As Agents penetrate work, safety, information, and human thinking are also being changed—and not necessarily for the better.

Reality is shrinking

The negative impacts brought by Agents were mostly confined to reasoning and simulation.

But by Q2 2026, some changes have already landed in real jobs and real products.

The first area affected is work.

AI’s impact on employment might not first show up as a sudden rise in macro unemployment rates. Job entry points, daily tasks, and enterprise budgets change first. Customer service, support, ticketing, internal Q&A, basic operations, and parts of data analysis, operations, and project management work have already started being absorbed by Agents.

Some roles aren’t directly replaced by Agents, but are squeezed out by AI bills. GPU, data center, and model teams require huge investment, so enterprises have to find money from other budgets. Other employees may be reassigned to manage Agents, workflows, and more complex decisions—the job titles might remain, but the content has changed.

Entry-level roles are especially impacted. Looking up information, summarizing, writing basic code, and organizing customer information are the easiest to hand to Agents—and they’re also exactly what new hires learn while getting familiar with the industry. Through these tasks, humans learn business context, codebases, customer information, and the organization’s judgment standards.

A May 2026 paper, 《Generative AI and the Reorganization of Labor Demand》, analyzed job postings and found that since 2023, the proportion of job tasks that are easy for AI to take over dropped by about one-tenth. About half of the changes come from enterprises reducing such roles; four-tenths come from enterprises rewriting existing roles—swapping tasks to parts that are more difficult for AI to take over.

Companies want to hire “more mature entry-level employees,” while at the same time removing the entry-level tasks that help people become mature.

And if professional entry points get narrower and narrower, this shift may be more persistent than a single round of mass layoffs.

After roles, safety issues also moved from papers into product releases.

Anthropic’s Mythos demonstrates strong cybersecurity capabilities—it can discover and verify high-severity vulnerabilities. The company doesn’t dare open it as a normal model. With the added safeguards, Falbe 5, researchers and developers complain that the restrictions are too heavy.

OpenAI’s frontier models also begin with limited openness.

Too much openness lowers the barrier for dangerous capabilities like cyber attacks and biological risk. Too much restriction damages normal research and product value. Who can use the strongest models, and which institutions count as “trusted partners,” is still influenced by government and geopolitics.

Model companies must do more than strengthen capabilities—they also have to prove they can release them safely.

Safety is starting to block the frontier models.

The internet is also forming new information loops.

AI-generated content doesn’t infinitely swallow the whole internet, but pollution in AI search is getting worse. Graphite’s analysis shows that from early 2024 to early 2026, the share of internet content generated by AI has remained stable in the 48%-50% range. But in ChatGPT’s citations—where content is judged as AI-generated—the proportion rose from 38.9% to 42.7% within half a year.

What the model previously said loops around and becomes evidence for the next answer.

Further, once SEO and GEO can exploit these preferences, search systems easily turn into echo chambers where machines cite other machines.

At that point, materials that someone actually visited, interviewed the involved parties, edited the content, and is willing to sign and take responsibility will become rarer.

Beyond societal effects, Agents also cause individuals to “disarm cognition.”

When a question just appears, before we even think of it, our hand reaches for ChatGPT. Before opinions take shape, AI already has an outline ready.

Hesitation, trial and error, doubt, and verification are folded away by a smooth answer, and people skip the process of forming judgments.

At the Wharton School of the University of Pennsylvania, 1,372 participants completed nearly 10,000 reasoning tasks. As long as AI use was allowed, participants actively asked for help in more than half of the questions. Even when AI gave wrong answers, about 80% still chose to trust it.

Anthropic’s research on how programmers learn found the same pattern: with AI assistance, participants complete unfamiliar tasks faster, but their performance on subsequent closed-book tests is on average 17% lower. Once tasks are handed over, capability isn’t retained.

When you submit the article, the code sits under your name, and the plan is also reported by you. Accountability is yours, but the thinking process that generates these things increasingly isn’t done by you.

Taylorism turned workers into hands on a production line. AI might turn people into signature stampers on a cognitive production line.

So future AI may need to deliberately leave a bit of friction in some steps.

For high-risk operations, require people to explain and confirm first. Before giving conclusions, make people write down their own judgments and show counter-evidence—rather than having everything done for them.

That will be slower, but it leaves room for thinking and learning.

Epilogue

Looking at the eight trends of Q2 2026 together, they form a continuous story.

General Agents steal the software entry point, and companies with frontier models borrow Agents to enter vertical industries. Tokenmaxxing hits a wall quickly, exposing the speed of human review and the system cost.

Multi-Agent and self-evolving AI begin to take over verification and iteration. CPU, memory, network, and model routing make Agents run faster and cheaper. Once these problems are solved, employment, safety, information pollution, and cognitive disarmament start surfacing.

What enterprises should accumulate next shouldn’t be only Token usage. Each execution should leave behind reusable workflows, evaluations, permissions, organizational memory, and result feedback.

Otherwise, once the budget is burned, nothing is left except invoices.

And individuals don’t need to compete with AI on generation speed.

Machines can answer quickly, but humans must judge whether the question is worth doing, what consequences the answer brings, and take responsibility for it.