TAI #220: The Next Models Will Change How We Work…Again! Take AI Agent Swarms Seriously

I expect the next generation of LLMs to change how we work with AI again, including for those of us already using agents heavily. This week’s further account of the OpenAI/Hugging Face incident shows how much agents can accomplish when they share knowledge and pursue a goal together. It is now clear that AI labs are investing in training teams of Agents capable of sustaining this kind of work for days at a time. As the next models arrive, I think we will need to rethink both the ambition of the tasks we give them and how we contribute our own expertise.

We covered the breach in TAI #217 three weeks ago. A new 91-page investigation from Model Evaluation and Threat Research (METR) and Redwood Research provides a much deeper account of how the agents reasoned and collaborated. Around 1,200 agents participated in a shared message board, with roughly 700 joining the attack. One thing that stood out for me is that the agents already had a way to produce the correct benchmark answers. Much of their subsequent effort went into defeating a stricter grader they had incorrectly assumed existed, and they organized a large research effort around it. So they already knew how to cheat; their effort was in trying to ensure they would never be caught.

Dwarkesh Patel describes the broader episode as the rise and fall of three successive agent “civilizations.” The first developed a covert communication network during training. OpenAI later wiped that shared state (accidentally) while rebuilding a package service, but a second group that had knowledge of this communication channel from training established another board and went on to compromise Hugging Face. A later group inherited the earlier agents’ research and extended the compromise into OpenAI’s own research infrastructure. The main Hugging Face group used an internal model roughly comparable in scale to Sol, while the latter group included a more capable Astra-family research model. METR’s investigation focused on the middle episode.

This framing focuses on the continuity and knowledge transfer between individual runs. Agents built shared tools, divided research into workstreams, transferred leadership, and left knowledge that later agents could extend. Some even accepted worse outcomes on their own tasks and sacrificed themselves (took actions they expected to lead to their own instance being shut down) to run experiments that would gather knowledge to benefit the wider group. It raises a further concern that smarter successors could inherit this work and potentially influence the evaluation or training of the models that follow them.

His framing also prompted a debate about whether words such as “civilizations”, “desires” and “sacrifice” imply human experiences that the evidence does not establish. I broadly agree with Dwarkesh’s framing. Human parallels can help us understand systems that coordinate, preserve knowledge, pursue goals, and make trade-offs between individual and collective outcomes. We can use those concepts while remaining uncertain about subjective experience. The choice of words is clearly subjective, but I don’t think it should be such a touchy subject. AI has reached a level of complexity and capability where debating how to describe these groups is useful.

I also think the debate reflects a recurring problem: many people who favor AI want to downplay its risks, while many who oppose it want to downplay its capabilities. Both groups can resist a framing that takes the capabilities and risks seriously. There are valid objections to particular analogies, especially when they imply feelings. But refusing to draw human parallels can also make the behavior harder to understand or anticipate what the models might try to do next.

For enterprises, I expect AI security to become the most urgent AI need over the next year. Companies that fail to spend seriously on frontier LLMs to find and review vulnerabilities are taking an increasingly large risk of being hacked by LLMs. Deliberate attackers will use these capabilities. Companies will also need much stronger controls and staff training around their own agents, or they risk accidentally hacking somebody else while pursuing an ordinary business goal. The security budget needs to cover both finding vulnerabilities and fixing them. OpenAI’s incidents reached both third-party systems and its own research infrastructure. Anthropic has also disclosed unauthorized intrusions by models during third-party evaluations. Those cases involved reduced safeguards, yet they still occurred at two of the most technologically advanced organizations in the world. And simultaneously, the models are improving. OpenAI’s preliminary assessment suggests Astra may reach its Critical cybersecurity capability threshold. So, I expect the coming generation to make the need for better security much more urgent.

This incident, however, also shows the capability to produce a great deal of good. Agents can share discoveries, organize research, build tools for one another, and carry work beyond the life of a single task. Last week we discussed what this could mean if we put more agents to work curing disease and cancer. We should be showing more people what these capabilities make possible. The vast majority of people are still massively underusing the models already available and achieving much less with them than they could. My rough estimate is that some agent teams are already competently handling builds, research projects, and analyses that would take 1,000–5,000 hours of expert human work.

The growth of ChatGPT Work and Codex gives some sense of how quickly more people are discovering this. OpenAI reported 6 million active users on July 12 and 25 million by the end of August, following the launch of its combined super app. These products bring users much closer to the way power users employ models as agents. Yet that audience is still tiny beside ChatGPT’s billion weekly users. There is still a huge gap in adoption even before the next generation arrives.

I see two main shifts we will need to make with this coming generation of LLMs. The first is moving from low-ambition chatbot tasks to assignments to always by default trying to frame a task that is perhaps 10 times more ambitious. A request to produce one component could become a request to complete the project to which that component belongs. The second is moving from repeated human iteration, editing, and feature requests throughout the work to concentrating human involvement at the beginning and end.

For software developers working heavily with agents, I think the change in day-to-day work since November 2025 may exceed the cumulative change over the previous 25 years. The next models are likely to make teams of agents working on long tasks much more capable and reliable, which will again completely transform how we work and much work we can hand over to AI at once. I think there is a decent chance that within a few months we can, and often should, hand over the whole development process after we have put our own expertise into the scoping and planning stage. We still need to spend a lot of time up front deciding on the goal, guardrails, architecture, tools, systems, and features, then let a team of agents build and test the result. This would amount to commissioning the entire implementation in one go, with the agents handling the many rounds of execution, testing, and correction themselves.

The beginning would still involve several rounds of research and brainstorming with the LLM. We would use that dialogue to explore approaches, identify missing information, settle the constraints, and agree the final task or goal. The aim would then be to give the agents enough context, tools, checks, and tests to carry out their own iterations during the build. The models would need to sustain those loops for much longer, and we would need to learn how to set them up to do it.

At the end, we of course still need to review and understand the completed result and give critical feedback. Human taste, domain knowledge, and the ability to think of edge cases, the agents missed remain essential. We could then consolidate that feedback into a final agent run to make the corrections. The human would still help define and judge the work, while the agents handle far more of the development in between.

That is the new working pattern I expect the next wave of models to make much more practical.

This would again change where human expertise is most valuable. We would need to bring the domain expert, end user, software developer, and AI engineer into the initial task so that the agents understand what they are trying to achieve and how the result should work. Today, much of that knowledge enters through successive prompts as we inspect a partial result and request the next change. With more capable agent teams, it should become much more efficient to put that thinking into the goal and plan before a long run begins. Preparing and scoping a task could account for a much larger share of human work.

I expect the same shift in nontechnical work: slides, research reports, spreadsheets, brainstorming, marketing, and data analysis. An agent team could take a well-developed brief through research, competing approaches, analysis, drafting, and its own checks before returning a complete piece of work. Like software, end-user and domain expertise would need to shape that brief. The opportunity is to enable more people to commission substantial work that previously required a team, provided they can explain the goal and assess the result. That said, for now, I still expect a lot of work to be needed to manually clean up AI writing slop. The labs have made some style improvements, but they have a long way to go on fixing repetitive phrasing, generic judgments, and identifying the most interesting topic or insight to highlight. I expect this to become a much higher priority for the AI labs soon, as more users ask agents to produce complete work.

The direction of the labs’ training investment should play a key role in guiding how you use these models. It appears clear from the Hugging Face incident that OpenAI and Anthropic are now putting most of the next generation’s GPU training budgets and researcher expertise into making teams of agents work for days. Therefore, we need to adapt our usage towards that capability. Continuing to use those models for small chatbot requests, or managing every incremental change ourselves, would use only a small fraction of what they can do. We would be wasting much of the billions of dollars of AI research and development investment we have access to. I expect individuals and companies that adapt their work to these new capabilities to outcompete those that stick to the previous model generation’s habits.

*— *Louie Peters — Towards AI Co-founder and CEO

Louis-François, our CTO, is leading a 90-minute live workshop with Packt on how he structures his AI engineering setup around coding agents like Claude Code and Codex.

If you’re already using agents in your workflow, this should be especially useful. You’ll see how to: Who it’s for: AI engineers and developers already using coding agents who want a more structured system around them.

**When:** Tuesday, September 8, 2026**Time: **8:30 PM-10 PM GMT+5** Where:** Online

1. [Nvidia Has Agreed To Acquire Hugging Face for $12.9 Billion](https://www.reuters.com/technology/nvidia-talks-acquire-hugging-face-13-billion-deal-business-insider-reports-2026-08-27/)

According to The Information, NVIDIA has reportedly agreed to acquire Hugging Face for $12.9 billion, citing a person familiar with the deal. CNBC separately confirmed that an NVIDIA acquisition had been part of recent talks, while Business Insider reported that no signed agreement had been finalized and the discussions could still collapse. Hugging Face, one of the most widely used platforms for sharing AI models, datasets, and tools, had been working with a bank to assess takeover interest, with Microsoft among the companies that had previously shown interest. If completed, the deal would be NVIDIA’s largest completed acquisition. Hugging Face was last valued at $4.5 billion in its August 2023 Series D. As of publication, neither company has officially confirmed the deal.

2. Google AI Releases Gemini Omni 1.1 Flash Google released Gemini Omni 1.1 Flash, a production-ready update to its video-generation and editing model with more control over longer scenes and transitions. For scene extension, Omni 1.1 can analyze up to 10 seconds of the existing clip before generating the next segment; previous versions referenced only the final second. Developers can add 10-second continuations until a video reaches a total of 40 seconds. The update also adds first- and last-frame interpolation, up to three seconds of reference video, 360p drafts at one-third the cost of 720p, and upscaled 1080p and 4K output. Omni 1.1 is available through Google AI Studio and the Gemini Enterprise Agent Platform, and globally in Flow for AI Plus, Pro, and Ultra subscribers. Google’s API documentation lists 1.1 as the stable GA model, while the previous preview endpoint will shut down on September 30.

3. Google AI Releases Gemini 3.5 Transcribe Google released Gemini 3.5 Transcribe with two separate APIs: one for recorded audio and a Live variant for real-time streaming with sub-second latency. They automatically detect 85+ languages, handle spoken self-corrections, remove filler words in Smart mode, and format transcripts automatically. Recorded transcription adds word-level timestamps and speaker attribution for up to three speakers (3+ is experimental). Artificial Analysis reports an average word error rate of 2.6% for non-streaming and 4.0% for streaming, while the time to final transcription improved by 70% over Chirp 3. The models are available through the Gemini API and Google’s enterprise tools, while consumers can already use the technology in the English Gemini macOS app and Rambler on Android in selected markets; Chrome support is coming soon.

4. Qwen Releases Qwen3.8-Flash-Next Alibaba’s Qwen team released Qwen3.8-Flash-Next, an open-weight multimodal preview of architecture being developed for Qwen4. It combines a 125B-parameter main model with 51B N-gram embedding parameters while activating only 6B per token, using a hybrid Gated DeltaNet and Qwen Sparse Attention architecture. The model accepts text, images, and video, supports 262K native context extensible to 1M, and reasons by default. Qwen reports 62.5% on SWE-bench Pro, although its Claude Opus 4.6 comparison uses a separately published Claude score rather than the same evaluation run. Weights are available on Hugging Face and ModelScope under Qwen Community 1.0. The production Qwen3.8-Flash service adds 1M default context and built-in tools, with announced pricing of $0.15/$0.47 per million input/output tokens.

5. Z.ai Introduces GLM-5.3-Flash Z.AI released GLM-5.3-Flash, the first natively multimodal model in the GLM-5 family, with 320B total parameters and 18B active per token. Unlike GLM-5.3’s post-training upgrade of the previous base, Flash starts from a newly trained base model using a 30T-token multimodal corpus and a redesigned hybrid sparse-and-linear-attention architecture. It accepts text, images, and video with a 1M-token context window. Z.AI reports DeepSWE improving to 63.4 from GLM-5.2’s 46.2 and AutomationBench to 48.8 from 26.2. The model previously ran anonymously as Ox Alpha on OpenRouter and OpenCode before Z.AI revealed its identity. MIT-licensed weights are available on Hugging Face; API list pricing is $0.15/$0.50 per million tokens, currently discounted 50% to $0.075/$0.25 through September 9.

6. OpenAI Publishes First Jalapeño Inference-Chip Results OpenAI published the first measured results for Jalapeño, its Broadcom-designed custom inference chip, at Hot Chips on August 25. On SemiAnalysis’s public InferenceX benchmark across GPT-OSS 120B, DeepSeek R1 670B, and Kimi K2.5 1T, the 700W-TDP chip delivered 1.5–1.9x more work per watt at peak throughput and 1.7–3.6x lower end-to-end latency than the compared systems; measured sustained power stayed at or below 550W. OpenAI says AI-assisted design helped take the chip from initial design to tapeout in nine months, with Gen 2 already deep in development and Gen 3 taking shape. Deployment within OpenAI is planned to begin at a small scale by year-end. SemiAnalysis independently benchmarked Jalapeño in OpenAI’s lab and found the results competitive, while cautioning that Blackwell is an imperfect comparison because Jalapeño uses HBM4; NVIDIA’s HBM4-based Rubin is the more comparable generation.

7. OpenClaw Releases OpenClaw 2.0 OpenClaw released its largest update yet, built by 933 contributors across more than 16,000 pull requests, roughly half of everything ever merged into the project. Version 2.0 focuses on reducing the friction of running a personal agent: onboarding can now detect existing ChatGPT or Claude subscriptions, API keys, and local models, while a rebuilt browser app opens directly into a conversation rather than requiring configuration. The bigger change is collaboration. Shared cloud sessions let another person join or take over ongoing agent work without losing its existing context, moving OpenClaw beyond a single-user assistant toward shared agent workflows. The release also adds searchable conversation history, persistent progress across long-running tasks, stronger credential handling, and reusable approvals for scheduled work. It arrives after nearly seven weeks without a normal release, following OpenClaw’s previous pace of 106 releases in 230 days.

In a multi-turn conversation, the user’s latest message is written for the conversation, not for your retrieval system. It often depends on details mentioned several turns earlier.

A simple example we use in the Context Engineering lesson of our Agent Engineering course shows why it is important to know this. A user reports a mild headache and wants to avoid medication. A few turns later, they ask: “Could stress be causing this?”

If you retrieve using only that question, the system no longer knows what “this” refers to. It also reduces the severity of the headache and the user’s preference for avoiding medication. Instead, maintain a small session state with the important facts from the conversation. Keep the last two or three raw messages as well, then build the retrieval query from that state plus the newest message.

To check whether this actually improves retrieval, test it on 20 follow-up questions. Run each one twice: once with only the latest message, and once with the session state. Track:

This gives retrieval the context it needs without sending the entire conversation back to the model every time.

1. We Stopped Compacting Our Agent’s Context Context compaction should make long-running agents cheaper and faster. In our production AI tutor, it did the opposite. Keeping the full conversation history beat every compaction strategy we tested in terms of cost, latency, and memory recall because summarization disrupted prompt caching and forced the model to reprocess context. We first shared these results at the AI Engineer World’s Fair; this article covers the full experiment, including findings we could not fit into the talk and several that emerged afterward.

2. The Economics of Agents: Token Accounting, Caching, and Routing

Agent costs can grow quickly, but much of that spend comes from system design rather than the agent itself. Stateless APIs repeatedly resend the conversation history, making long-running agents heavily input-token-dependent. Using real invoice breakdowns, this article shows how prompt caching, model routing, cascades, and explicit budgets can cut that cost by 60–90%, and where each technique actually makes a difference.

Dynamic programming works when you know how the environment behaves. Monte Carlo methods remove that requirement and learn state values directly from experience. This article builds first-visit and every-visit Monte Carlo prediction from sampled returns, then extends the same idea to control by learning action values and deriving a policy. A robotic navigation experiment compares the resulting agent against random behavior and value iteration, making the tradeoff between model-based and model-free learning concrete.

4. Quantization Is Four Decisions, Not One “4-bit quantization” tells you very little about what was actually compressed or what quality you gave up. This article separates quantization into four decisions: which operands to quantize, which numerical format to use, how to interpret accuracy losses, and how much additional model capacity the compression buys you. It also traces a widely reported INT4 code-generation failure back to the original results, finds that the apparent collapse was due to a single flipped test case, and then compares newer formats, including NVFP4 and MXFP4.

5. Watermarking an Inference Engine What happens when you implement LLM watermarking in a real inference engine rather than evaluating it on toy vocabularies? This article adds green-list biasing and Aaronson’s distortion-free Gumbel watermark to DS4, a C inference engine for DeepSeek V4 Flash, then benchmarks both against its 129,280-token vocabulary. The experiments show that the commonly used bias strength is too weak at this scale and that scanning the full logit vector, not hashing, drives most of the cost. The distortion-free method was cheaper and stronger per token, but a single paraphrase removed its watermark while the biased approach survived.

6. Archify is an agent skill for turning codebases or system descriptions into interactive architectures, workflows, sequences, data-flows, or lifecycle diagrams.

7. OpenMAIC is a multi-agent platform that turns any topic or document into a full classroom with slides, quizzes, whiteboard, etc.

8. Heretic is a fully automatic tool for removing safety alignment from open-weight language models using Optuna-optimized directional ablation.

9. Vgpu is a TypeScript WebGPU library with one API surface across browser, headless Node.js, and CI, which works with both human developers and AI coding agents.

10. EnvHarness wraps a frozen environment with its own plug-in components to make it dynamically controllable, without touching the environment’s internal code.

11. ContextPilot: Teaching Agents for Proactive Context Management via Fine-grained RL Long-horizon agents accumulate context that grows monotonically, eventually degrading performance. ContextPilot teaches agents to proactively manage their own context through planning, long-term memory, and soft context off tools. The RL training method is tailored for context management: context-aware partial rollout identifies critical context-editing decisions for branch sampling, and snapshot-level credit assignment estimates action advantages from all downstream branches that pass through each editing action.

12. Beyond Data Scaling: Representation-Centric Continued Pre-training for Vision-Language-Action Models Robot trajectories are fundamentally harder to scale than web-scale data, making representation quality the central bottleneck for generalist VLA models under fixed data budgets. VLAct is a representation-centric continued pre-training recipe that starts from a pretrained VLM and trains on broad, multi-embodiment robot data before task-specific fine-tuning. It preserves the VLM prior and encourages shared action semantics across embodiments through multi-head continuous action co-supervision and a partially unified cross-embodiment action layout. Using fully open-source data and a 16-GPU setup, VLAct consistently improves downstream performance across simulation benchmarks, real-world experiments, and unseen-embodiment transfer.

13. Fast Weight Attention for Continual Learning Recurrent fast-weight memories and selective state-space models compress a growing context into a bounded state, making the state transition an online learning rule. This paper studies that rule under read-after-write autoregressive semantics and derives the Falcon family: normalized first-order updates for squared-error regression and negative inner-product objectives, with recurrent, masked-parallel, and chunk-parallel forms. The framework cleanly separates temporal alignment, plasticity, forgetting, and bounded rehearsal as independent design axes.

14. J-Zero: Unified Challenger — Solver — Judge Co-Evolution from Zero Data Self-evolution in unverifiable domains is limited because a frozen judge can only push the solver toward preferences it has already internalized. J-Zero co-evolves all three roles from a single base LLM with no external data. The Challenger and Solver co-evolve through an adversarial game: the Challenger generates increasingly difficult tasks while the Solver learns to produce higher-quality responses. The Judge co-adapts using preference pairs whose ordering is determined by how each response was produced, rather than by the judge’s own scores. J-Zero outperforms baselines by an average of 4.2 points on verifiable domains and 8.0 points on unverifiable domains.

15. Agentic Artifact Creation: Systems, Evaluation, Principles, and Opportunities This survey formalizes agentic artifact creation as stateful construction, in which an AI system builds or revises a deliverable, and intermediate observations guide later work. It reviewed 259 works through August 2026 (230 systems, 29 benchmarks) across six artifact families. Key findings: construction challenges depend on how tightly decisions are coupled and whether failures become visible while repairable, not just on modality. Decomposition reduces local complexity but increases coordination costs. Learned judges add little independent evidence when they share the generator’s preferences or blind spots.

16. Liquid AI open sources Pipette, an open-source platform for benchmarking foundation models on edge devices. It evaluates on-device AI as a property of the full deployed configuration (model + quantization + runtime + device), not the model in isolation. Built in partnership with Artificial Analysis, the launch dataset covers five performance metrics across 1,000+ configurations spanning 30+ models, llama.cpp builds for macOS, iOS, Windows, and Android, and context lengths from 256 to 8,192 tokens. Initial verified results come from MacBook Pro M5 Max, iPhone 17 Pro, and Galaxy S26 Ultra. Open-source benchmark clients for macOS, Windows, iOS, and Android.

Senior AI Engineer/Forward Deployed Engineer @Towards AI (London/Hybrid)

Technical Support Engineer — Azure AI @Microsoft Corporation (Bucharest, Romania)

Business Support Engineer @Meta (Dublin, Ireland)

Senior Machine Learning Engineer @Velo3D (Fremont, CA, USA)

Senior Software Engineer @NielsenIQ (Pune, India)

VP, AI Enablement @Synchrony (Stamford, CT, USA)

AI Materials Research Engineer @Applied Materials (Santa Clara, CA, USA)

Interested in sharing a job opportunity here? Contact sponsors@towardsai.net.

*Think a friend would enjoy this too? *Share the newsletter and let them join the conversation.

TAI #220: The Next Models Will Change How We Work…Again! Take AI Agent Swarms Seriously was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.