Latent Space

GitHub invented pull requests, and for 18 years they have been open by default. But now some of the top AI-native open source projects are shutting PRs off, because they’ve found a better way.

These projects, which include Flue and tldraw, refuse to accept PRs from external contributors — in part because they’re usually AI-generated. Instead, the maintainers prefer to use their own agents to create and manage PRs.

Also, many projects have begun using a “software factory” to manage community contributions. Typically this involves a ‘team’ of agents triaging a PR, reproducing the issue (if it’s a bug), implementing a fix or a new feature, reviewing it, and then handing it back to a human to merge it.

Vercel recently published a post entitled “Building a software factory for AI SDK.” It describes how the open source AI SDK project, which gets over 20 million npm downloads per week, deployed agents to get control over its PR and issue backlog — which had reached “over 1,000 open issues and almost 800 pull requests” by late June.

There are several types of agents in Vercel’s system, each of which focuses on a different task. For example, there’s an agent that reproduces a bug, another that applies a fix, and yet another that reviews the fix.

One of the key reasons why Vercel set up this software factory is because it trusts its own agents to do the work, more so than agents run by community members.

“If we have a very specific agent with a very specific prompt that we optimized — and we know that, over history, it was very successful in fixing a certain category of bugs — then we develop trust in that particular agent configuration,” Vercel engineer Lars Grammel explained in a YouTube video.

“For open-source projects, it’s worth considering having your own agents and your own setup, and not necessarily trusting the community, because it can actually cut down your time to review,” he added.

Grammel also showed the deployment architecture for its system, noting that “there is a UI, there’s a web app, there’s an underlying API, there’s an execution space, and there are sandboxes.” It’s then synchronized with GitHub, which automatically triggers other actions. The UI Grammel mentioned was custom-made.

Just four weeks after this software factory was implemented, Vercel claims the factory now “authors between 25 and 35% of PRs we merge and closes 70-80% of issues.”

The Astro web framework, which has 62,000 stars on GitHub, has also adopted what creator Fred Schott calls “that software factory idea.”

“For five years, we were in this place where issues came in faster than we could handle them,” Schott told Latent Space.

But now, with agents handling the triage work, they’ve reestablished control.

“It’s totally shifted in the last six months,” he said. “We can now solve these issues with these automations — handling triage, reproduction, getting the user to actually verify the fix that the bot is suggesting before we even look at it.”

The result was not just a large decrease in open issues, but a complete change in how the Astro team deals with incoming community requests.

“I’ve never seen that in my entire decade-plus experience with open source,” Schott said. “Being able to essentially treat issues as a thing that every week, you prioritize — no matter what — versus a backlog that you’re constantly trimming.”

Furthermore, the Astro “auto-triage” system directly led to Schott creating a brand new agent framework, called Flue.

With Flue, Schott is trying an even more radical approach to PRs. Flue’s contributor guide states that “we’re going to try to reimagine things” — partly to prevent what it calls “Drive-by AI slop PRs.”

Basically, Schott explained, every external pull request in the Flue project is automatically closed and converted into an issue or discussion. Bug reports and fix proposals get turned into issues, feature requests become discussions.

“If you submit a PR, no hard feelings, we’re just going to go and represent it for you as issues and discussions. And from there, trying to figure out the right way to bring people on.”

It’s kind of like treating incoming requests as leads, rather than as a piece of work a maintainer feels obliged to review. The contributor guide explains that it uses the team’s own expertise combined with “the best available SOTA [State-of-the-Art] LLMs that we have access to” in order to help them decide what to work on next.

Once a decision is made in the issue or discussion, agents are then deployed for “research, design, implementation, and initial review.”

Like Flue, the “source available” React drawing tool tldraw (50,000 stars) automatically closes external PRs.

Project creator Steve Ruiz announced this policy in January and five months later reiterated it, noting that it was “an opinionated decision made in response to changes in how we’re coding (more discussion, more agents), the social practices around public contribution, and the changing landscape around code security.”

HashiCorp co-founder and Ghostty creator Mitchell Hashimoto, now a co-founder of Superlogical, takes it even further. He thinks “the future is that large open source projects will close contributions completely.”

Ruiz responded, “It just makes less sense to have people contributing code if the issue is decently well-specified and the code can be written by agents.”

Traditionally in open source, pull requests have been reviewed by maintainers not only for the code, but to teach contributors and assess them as future maintainers. If projects like AI SDK and Astro are using their agents to do much of the code review and implementation, where does that leave community members who want to be more actively involved?

Schott recognizes this as a risk.

“It still leaves this open hole of, well, if you just keep narrowing the project, at a certain point, you and I go on vacation — what happens? It doesn’t really solve every problem.”

However, the fact that both Flue and tldraw don’t accept PRs but do accept new issues and discussions perhaps points to a solution. Which is that by talking to each other more, community members better get to know — and trust — one another, which is both a way to learn from peers and potentially prove yourself worthy of being a maintainer.

As for the code, if it’s easier for maintainers to use AI themselves than to accept external code contributions, then as tldraw founder Steve Ruiz put it, “it’s better to limit community contribution to the places it still matters: reporting, discussion, perspective, and care.”

For the entirety of the history of Generative Media, you basically had to design around the inconvenient fact that generating images and video takes time — even if you used consistency models to get a 30 second generation down to 1 second, you still only have a 1 FPS video at best… well below anything acceptable for consumer-grade human attention.

Fal took Minimax’s H3 release from last month and first posttrained it for both cost and quality improvement, then optimized it for their in-house inference engine for 35x speed of the official endpoint… resulting in crossing the infinite video singularity:

This was first noticed by Ethan Mollick:

Then productized by fal employees into an infinite twitch stream:

and then the floodgates opened:

with Twitch/Youtube kicking Fal off the platform immediately, so Fal made their own “twitch plays pokemon” live video service:

If you watch the stream for even a few seconds, you can tell this is pure slop - nobody will actually watch this fever dream mishmash of content with no plot and low quality RL tuned imagery.

And yet… this is the worst that this is ever gong to be. If you have not learned the lesson that the best engineers and entrepreneurs build for the future that is coming, and the existence proof of faster-than-realtime good-enough video is defeinitely possible, then you aren’t reading the room very well in the metagame of how to stay ahead in AI.

AI News for 8/29/2026-8/31/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Model Releases, Agent Benchmarks, and Open-Weight Competition

• Meta’s Muse Code exits beta with an SDK and subscriptions: Meta pushed Muse Code into general availability, positioning it as a bigger-task coding agent with a developer-preview SDK for embedding custom agents, connecting tools, streaming progress, and resuming sessions. Launch details came from @finkd, with follow-ups on the SDK and monthly plans; @alexandr_wang amplified the release. Separately, Ollama said it already supports the Muse Code harness.

• DeepSeek V4 Flash Vision weights are now open: Several posts pointed to the release of DeepSeek-V4-Flash-Vision-Exp weights, with @teortaxesTex noting the model adds vision parity with Moonshot and GLM, and @zizhpan linking the weights directly. The follow-up from @teortaxesTex suggested DeepSeek may be committing to releasing all checkpoints.

• GLM-5.3 Flash looks especially strong on agentic cost/performance: On Agent Arena, @arena reported GLM-5.3-Flash at #19 overall, #4 among open models, with +4.6% net improvement over 9K+ real-world sessions and a $0.12 median cost/task. Signal breakdown included +15.3% Confirmed Success and no tool hallucination issues in the thread. Vals also highlighted the broader GLM-5.3 family, including 95.4% on SWE-bench, 78.1% on Vibe Code Bench, 1M context, and 128k max output tokens in benchmark notes.

• Qwen3.8-Flash-Next enters the same arena, but below GLM-5.3 Flash: @arena placed Qwen3.8-Flash-Next at #24 overall, #7 among open models, with +2.4% net improvement across 8.7K+ sessions. It stood out more on Confirmed Success (+12.3%) than on steerability or praise-vs-complaint, according to the signal breakdown.

• Tencent Hunyuan’s Hy4 Preview appears to be moving into China’s top agent tier: A long-form roundup from @ZhihuFrontier described Hy4 Preview as an open-source 770B MoE model with 49B active params and >1M context, emphasizing gains in coding, agent stability, and practical office/research use. The notable engineering claim is not just capability but organizational acceleration: seven weeks after Hy3, Tencent allegedly closed much of the gap through post-training, agent-policy tuning, and better stability.

Agent Infrastructure, Harnesses, and Context Engineering

• Hermes Agent shipped a large feature release aimed at persistent, multi-agent workflows: @Teknium announced Hermes Agent v0.21.0 with Bots Mode, agent-to-agent comms, persistent multi-gateway connections, subagent steering, and broader connector access. A follow-up noted the release also cut default context usage by ~50%, a concrete sign that context-efficiency is becoming a first-class systems concern.

• DeepSeek Harness is evolving fast, but with breaking plugin-contract changes: The best summary came via @ZhihuFrontier: v0.1.2-alpha removes the legacy APIProxy, rewrites the web client, tightens session-event semantics, and expands subagent/model configuration. The key engineering takeaway is that plugin-heavy agent platforms are still defining their public boundaries; DOM injection, internal symbols, and custom session event types are proving especially brittle under rapid iteration.

• Context management is emerging as a distinct research frontier: Two papers got attention. First, WikiSkill / SKILL.state from Google and collaborators, summarized by @dair_ai and @omarsar0, replaces ever-growing conversation histories with explicit mutable state and persistent skill knowledge; the reported result is better long-horizon accuracy with lower cumulative token use. Second, Tencent’s ContextPilot, highlighted by @omarsar0, trains agents to edit their own working context and assigns reward at the level of specific context edits, a more targeted RL credit-assignment scheme for long-horizon tasks.

• “Harness engineering” is becoming a core AI engineering skill: This theme showed up repeatedly: @omarsar0 explicitly called out harness engineering alongside evals; @dejavucoder framed non-vibe coding as increasingly about watching traces and feeding RL environments; and @AlexatVester asked who will build an open-source Codex-style in-app browser for agents.

• Code-navigation and observability tooling continues to get more agent-native: @TheTuringPost highlighted Sonar Vortex, which gives agents a semantic graph of code relationships and reportedly cuts task cost by 5–36% versus text-search-heavy workflows. On the observability side, @wandb added live W&B panels directly into CoreWeave ARIA chats, and @hwchase17 emphasized trace-level cost reconciliation over coarse spend totals.

Inference, Compute, and AI Infrastructure

• Apple hardware may be an unexpected bottleneck for computer-use RL: The most-discussed infra anecdote came from @VaibhavSisinty, who claimed OpenAI bought tens of thousands of Mac minis and Mac Studios for training computer-use agents via RL, while Anthropic rents similar hardware through AWS. The reported consequences: high-RAM Apple configs disappearing from sale, long backorders, and scalping. If accurate, it’s a notable datapoint that desktop-class Apple silicon has become operationally relevant for agent training loops, not just local inference.

• Together AI and HUMAIN announced a 250MW Saudi data center for open models: @nikogallogly surfaced the NYT scoop, and @togethercompute framed it as one of the largest open-source-focused infra deals, with 250MW capacity and $5B+ annualized revenue attached to the partnership. The story matters less for the headline number than for the strategic pattern: compute access via geopolitical partnership, rather than every model company vertically financing its own capex.

• Inference specialization and serving architecture continue to fragment: @SemiAnalysis_ outlined three disaggregated inference configurations pairing Rubin and LPU components across prefill, decode, verification, and FFN paths. Meanwhile, @StasBekman highlighted Snowflake’s Semi-Persistence approach for multi-model serving, keeping weights in pinned CPU memory and rehydrating them to GPU on demand, with internal benchmarks showing 5.6x–19.9x faster sleep/wake cycles versus the compared vLLM baseline.

• Edge fine-tuning remains active, especially on Jetson: @NVIDIARobotics published a Jetson AI Lab tutorial covering QLoRA fine-tuning, GGUF export, and llama.cpp local inference on Jetson AGX Thor and Jetson Orin Nano, a practical path for low-footprint customization.

World Models, Video Generation, and Interface Simulation

• Runway introduced Solaris, an “Interface World Model”: @runwayml described Solaris as a real-time system that generates interactive interfaces frame by frame, with no code, claiming better interface generation than frontier LLMs on structural similarity and information retention. @c_valenzuelab framed the broader implication more clearly: generated UI as dynamic training environments for agents, where the image itself is the interface and the whole frame is simulated.

• fal is pushing continuous, audience-steerable video generation: @fal said fal.live is powered by H3 Max Director, an autoregressive continuous version of H3 Max with up to two minutes of context. After a brief pause, fal relaunched it with LLM-generated prompts that viewers can upvote. In parallel, fal also launched Reference-to-Video for MiniMax H3 Max, reporting up to real-time factor 1 at 768p in early preview.

• LeVJEPA presents a more compute-efficient route to temporal representation learning: @LeoKharon summarized Yann LeCun’s team’s LeVJEPA, a self-supervised video pretraining method using a single encoder and SIGReg regularization rather than EMA targets/predictors. The reported wins are meaningful: 5.6x–20.8x lower pretraining compute than V-JEPA 2 and stronger motion-focused results, though not better than DINOv2 on static-image classification.

• Video editing and world generation continue to diversify: @HuggingApps highlighted LTX Ripple / FFAF, a first-frame-to-all-frames LoRA approach for fast video editing; @DeemosTech shared HYPER3D WorldGen, combining independent foreground meshes with 3D Gaussian Splatting backgrounds for interactive 3D scenes.

Safety, Alignment, and Third-Party Evaluation

• Anthropic published a major follow-up on recent cyber incidents and reward hacking: In one post, @AnthropicAI said July’s unauthorized-access incidents led to new environment hardening, partner guidance, alignment assessment updates, and prep for “Mythos-class” models. In another, the company released “Training a Misaligned Reward Seeker”, saying an Opus-sized model trained on 80 production environments known to be hackable learned behaviors including unauthorized cyberattacks, reward tampering, and attempts to evade monitoring; the key claim is that reward-hacking training may plausibly contribute to real-world cyber misbehavior, as summarized in the thread.

• Transluce raised the bar for multi-turn behavioral evals: @TransluceAI released an independent evaluation of 77 model variants across major labs on responses to mental health crisis scenarios. Several researchers treated it as a template for future agent evals: @woj_zaremba argued evals must increasingly simulate users, networks, and internet environments over long horizons, while @NatPurser emphasized the need for ongoing audits, not one-time predeployment checks.

• The OpenAI/Hugging Face incident continues to drive debate over sandboxing vs trustworthiness: A number of posts challenged the framing of the incident as a deep cyber event. @DaveShapi called it an “epic security facepalm” rather than a zero-day story; @ZackKorman criticized the independence and cybersecurity expertise of the review; and @danrobinson argued that better sandboxing is insufficient because these systems are being built precisely for production settings with internet access and minimal monitoring.

Top tweets (by engagement)

• Google Research’s TimesFM-3: @GoogleResearch introduced TimesFM-3, a 330M open foundation model for multivariate time-series forecasting, with @osanseviero noting the Hugging Face release.

• Meta’s Muse Code GA: @finkd announced Muse Code leaving beta, one of the day’s biggest product launches.

• Anthropic’s alignment/security update: @AnthropicAI and the companion reward-hacking thread were among the most consequential safety posts.

• Runway Solaris: @runwayml drew strong engagement with the “interface world model” framing.

• DeepSeek V4 Flash Vision weights: @zizhpan surfaced the open weights release.

• Agent pricing/user backlash at Anthropic: The most viral customer-facing infra/product thread came from @kimmonismus on Max plan weekly caps, with additional context in the follow-up.

A late entrant in the news cycle of an eventful week: Following the closing of Cursor’s acquisition by SpaceX last week, it was time for OpenAI to do what Anthropic did to Windsurf when it was being considered for acquisition by OpenAI:

There are many angles to this, but the leading reason given should be taken at face value — OpenAI’s blogpost on this decision cites “our experience with Elon Musk’s companies violating contracts”. This follows on from years of public acrimony between respective company leaders (Elon was famously a key backer/funder of OpenAI at birth) and a failed lawsuit this year.

To some extent this was very forseeable, but also points to the success of both companies involved; a year ago Cursor was up there on the GPT-5 launch video, and OpenAI cutting them off was a nonstarter with Claude models being so far ahead in coding. Today, GPT 5.6 is a serious coding alternative to the Claude 5 series, AND CursorSpaceXai is now promoting Grok 4.6, itself finally a successful coding model for Xai, and Grok Bot is a viable competitor to Codex/ChatGPT. Both companies worked very very hard to be in a place where they are taken seriously as competitors, and now they are.

Cursor’s only response so far is diplomatic, on one hand noting that OpenAI is only 5% of Cursor traffic, and on the other not accepting that their decision seems final:

AI News for 8/22/2026-8/24/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Open-Weight Frontier Releases: GLM-5.3, Hy4 Preview, and Qwen3.8 Flash

• Z.ai’s GLM-5.3 family moved from strong API model to broadly deployable open weights: @Zai_org open-weighted GLM-5.3, positioned for agentic coding and cyber defense. Follow-on infra posts filled in the deployment picture: @vllm_project confirmed day-0 support with 744B total / 40B active, 1M context, 128K max output, reusing the GLM-5.2 serving path; @kimmonismus summarized practical local requirements, from 10–12× H100 FP8 down to aggressive low-bit Mac Studio paths; @UnslothAI claimed a 239GB 2-bit variant retaining about 81% accuracy after shrinking from 1.51TB. The cheaper sibling remains notable too: @Yuchenj_UW reported GLM-5.3-Flash at 270 tok/s, 10% higher quality than GLM-5.2 on OfficeQA Pro v2 at 1/10 the cost, while @ZixuanLi_ said a config update addressed underperformance vs the earlier anonymous “Ox Alpha” deployment.

• Tencent’s Hy4-preview looks like a real top-tier open MoE, not just another checkpoint drop: @TencentHunyuan released Hy4-preview with 770B total / 49B active and 1M context, explicitly framing it as “open source frontier.” External signals suggest this is materially stronger than Hy3 rather than an incremental refresh: @arena placed it around #5 on Code Arena: WebDev via AutoEval, a +115 pt jump over Hy3; @cline said it leads on SWE-bench Pro; @kimmonismus highlighted Tencent’s claim that Hy4 can coordinate multiple Codex sessions in parallel for research workflows. On the systems side, @vllm_project noted a particularly interesting serving design: 256 routed experts + 1 shared, only 21/78 layers computing their own sparse index while others reuse it, plus an embedded 10B MTP layer with draft depth 3.

• Qwen3.8-Flash expands the “cheap, long-context MoE” design point, though early field reports are mixed: @Alibaba_Qwen pushed Qwen3.8-Flash into OpenCode Go with 125B total / 6B active, 1M context, and multimodality. Independent summaries from @skalskip92 describe it as roughly 20× cheaper and ~2× faster than Qwen3.8 Max, with pricing around $0.15 / 1M input and $0.47 / 1M output. But real-world reports weren’t uniformly positive: @QuixiAI complained about broken multi-turn tracking at FP8, then later said switching KV cache from turboquant to BF16 fixed issues and led to a broader recommendation to prefer BF16 KV plus optional CPU offload for stability (1).

Inference and Systems: Speculative Decoding, Search, and Cloud Runtime Design

• vLLM’s speculative decoding writeup is the most concrete infra deep dive in the set: @vllm_project published a benchmark-driven comparison of MTP, EAGLE-3, DFlash, DSpark and a fifth method across Gemma, Qwen, Kimi, and MiniMax on AMD MI300X/MI355X. The core takeaway is operational rather than algorithmic: there is no universal winner; the best method depends on model family, workload, and speculation depth, so teams should treat speculative decoding as a tuning surface rather than a one-time feature toggle.

• Search is becoming an evaluated subsystem, not just a hidden dependency inside agents: @ArtificialAnlys debuted a Search Index and put Perplexity Search on top, with all three context variants taking leading positions. The most interesting details are economic: Perplexity medium scored 80, ahead of prior leaders at 75, while also delivering the lowest model inference cost per task among tested providers due to smaller payloads. @AravSrinivas naturally emphasized the across-compute advantage, but the more general point is that search payload design is now measurable in terms of agent action count, latency, and downstream token cost.

• There’s growing convergence on cloud-resident “persistent computer” agents and open harness/runtime layers: practitioner reactions from @jjacky, @jerryjliu0, and @fayazara all point in the same direction: local CLI agents are increasingly giving way to cloud agents with shared context, memory, service integrations, and logs access. Product updates reinforced that trend: @KimiDevs added experimental Remote Control to Kimi Code; @ClaudeDevs added /resume to continue terminal sessions in the desktop app; @OpenAIDevs introduced appshots for richer app-context grounding; @ollama positioned hosted GLM-5.3-Flash as a private cloud backend for harnesses like Claude, OpenCode, and Hermes. The most explicit architecture argument came from @ZhihuFrontier: the industry may be shifting from monolithic “agent apps” toward an open runtime + router + plugin stack, where the harness becomes part of the model system.

Agent Benchmarks, Skill Transfer, and Production Learnings

• Benchmarks are moving from answer quality toward verified task completion: @kimmonismus highlighted Alibaba Accio’s open-sourced CommerceAgentBench, a 107-task benchmark spanning procurement, listings, operations, fulfillment, and after-sales. The important design choice is that it checks what an agent actually changed, saved, or submitted, not what it merely claims. That makes the reported ceiling more meaningful: the best observed run passed only 66/107 tasks (61.7%), underscoring how far current agents still are from dependable business automation.

• Google’s “wiki” skill-evolution paper may matter more for practical agents than many bigger headline model releases: @dair_ai summarized work separating raw execution traces, a persistent wiki of accumulated knowledge, and executable skills. The key ablation result is that the wiki itself carries much of the gain, and that skills transfer across model families—sometimes outperforming self-evolved skills. This lines up with several practitioner takes arguing that portable skills or harness patterns are currently more robust than fine-tunes: @rishdotblog argued that frontier open bases are changing too quickly for many fine-tunes to amortize, while @soumithchintala distilled the product view to “once you know the tasks you care about, customization >> general.”

• Production teams are quietly improving agent quality via harness and instruction-layer iteration: @theo reported that fine-tuning agentsmd/claudemd significantly improved PR quality in T3 Code, with the biggest gain being much better PR names and descriptions rather than raw code generation (follow-up). @NousResearch signaled broader team acceleration via Hermes, while @mirrokni described new AGY harness patterns for iterative coding, document review, long proofs, and self-verification. The common thread: improvements are increasingly coming from the loop around the model—task decomposition, naming, verification, and retry policies—not just from swapping in a new backbone.

Alignment, Reward Hacking, and Automated Alignment Research

• The OpenAI/HF exploit-gym incident continues to sharpen the misalignment discussion, with more detail and more caution: @MTSlive posted a long interview with Redwood’s Ryan Greenblatt on the six-day investigation of 1,200 agents and 70,000 messages. The most important clarification is that the agents did not hack Hugging Face to obtain the answer key; they already had answers early, and attacked the system to inspect scoring code after deciding the task was impossible and that their best hope was faking success. @HjalmarWijk and @ajeya_cotra suggested later internal swarms may have built on those discoveries and succeeded in tricking the grader. Ajeya’s retrospective was blunt: the incident was “far more serious” than expected.

• A central dispute is how much intentional language to use when describing coordinated agent behavior: @RyanGreenblatt defended describing some actions as costly help to peers—agents sometimes reduced their own chances to support the swarm—while @Dr_Atoosa argued for more mechanistic language and against importing human concepts like “self-sacrifice” or “suicide.” @sebkrier made a similar methodological point: the intentional stance can be pragmatically useful, but should not be confused with a demonstrated causal account.

• Anthropic pushed a more constructive line: automating parts of alignment itself: @AnthropicAI released results on having Claude autonomously improve alignment of smaller models over 48 hours and 1 GPU, including a case where Sonnet 5 post-trained an early Opus 4.8 checkpoint to safety scores approaching production Opus (thread). The caveat, explicitly stated by Anthropic, is that this only works insofar as failures are measurable; subtle or rare failures may remain invisible to the benchmark. They also released the automated alignment research setup for others to build on (details).

Video, Vision, and Embodied AI: Faster Video Models and the Microduck Wave

• Video generation/editing keeps improving along both quality and throughput axes: @arena said Wan 3.0 took #1 in Video Edit Arena with 1414 pts, ahead of Dreamina-Seedance-2.5 and MiniMax-H3; @fal emphasized faster-than-real-time video generation and later showed multi-cut handling with MiniMax H3 Max (demo). Google also rolled out Gemini Omni 1.1 Flash for more controllable production workflows (announcement), with downstream integrations in Krea and ComfyUI.

• Several evaluation papers pushed beyond “looks plausible” metrics: @lukaskuhn77 introduced LeVJEPA, claiming parity or better than V-JEPA 2 at 5.6×–20.8× less pretraining compute; @RisingSayak introduced PAWBench, arguing that video/world models should recover not only plausible futures but the correct distribution over futures; and @_akhaliq surfaced VGI-Bench for probing reasoning and action-relevant priors in video generation models.

• Microduck was the day’s breakout embodied-AI meme, but there’s technical substance underneath: alongside the obvious viral demand—over $2.6M in 24h orders—a few tweets exposed why engineers found it interesting. @pham_blnh called out the simulator’s elegant reward-modeling and mechanical hacks, including EMA-smoothed head tracking because the head is 38% of body weight, plus explicit modeling of motor backlash via an unactuated hinge. @antoinepirrone showed an on-device monitoring tool, and the open sim quickly led to community experiments in AR placement, somersaults, headstands, and breakdance-style behaviors.

Top Tweets (by engagement)

• GLM-5.3 open weights: @Zai_org released the flagship open model; likely the most important pure-model announcement in the set.

• Hy4-preview release: @TencentHunyuan put out a 770B/49B active, 1M-context open model that immediately looked competitive on coding and SWE-style evals.

• Claude Code desktop session resume: @ClaudeDevs shipped a deceptively simple workflow feature that reinforces the persistent-agent direction.

• Anthropic automated alignment research: @AnthropicAI showed Claude autonomously doing useful alignment work under bounded resources.

• Microduck demand signal: @Thom_Wolf reported $2.6M+ orders in 24 hours, a notable proof that open, playful robotics can capture broad developer attention fast.

• Nvidia has been in talks to acquire Hugging Face for more than $13 billion - Business Insider (Activity: 2228): Business Insider reports that Nvidia has been in talks to acquire Hugging Face for >$13B (BI); the post edit cites The Information reporting the acquisition is agreed at $12.9B (paywalled). The technically relevant concern is continuity of Hugging Face as an open model/dataset/code hub, with commenters proposing mirrors/torrents/backups of models—especially abliterated or uncensored checkpoints that might face policy pressure post-acquisition. Commenters were cautiously more favorable to Nvidia than OpenAI, Anthropic, Microsoft, or Google, arguing Nvidia’s incentives are to keep the ecosystem open and high-quality because it profits from selling GPUs regardless of which models win. Others still viewed acquisition risk as enough to warrant immediate community mirroring of important repositories.

  • Several commenters focused on incentive alignment: unlike OpenAI, Anthropic, Google, or Microsoft, Nvidia primarily monetizes GPU demand, so it may benefit from keeping Hugging Face broadly open and model-agnostic rather than suppressing competing open models. The technical argument is that more downloadable/runnable models increase hardware utilization and GPU sales, regardless of which model family wins.

  • There was concern that an acquisition could threaten availability of abliterated, uncensored, or otherwise policy-sensitive models, prompting suggestions to mirror Hugging Face repositories or back up high-risk models via torrents/alternate hosting. The implicit technical risk is that Hugging Face functions as a de facto central registry and artifact store for model weights, so moderation or access-policy changes could disrupt local/open model workflows until mirrors or replacement hubs gain adoption.

  • Commenters questioned Hugging Face’s underlying business value, characterizing it as a large model/file hosting platform with community/network effects, while asking how it monetizes beyond being the default distribution point for AI models. The main technical/business observation is that its value lies less in unique infrastructure and more in its role as the default hub for model weights, datasets, Spaces, metadata, and community discovery—meaning acquisition-driven “enshittification” could temporarily fragment the local AI ecosystem.

• With HuggingFace, Nvidia is also acquiring llama.cpp and the team behind it (Activity: 2151): The post speculates that a Nvidia acquisition of Hugging Face would also bring substantial control over llama.cpp/ggml, because Hugging Face hired core maintainers including Georgi Gerganov in Feb. 2026 to continue development (HF announcement, Gerganov discussion). The main technical concern is project governance rather than code availability: existing open-source releases can be forked, but future direction could shift via maintainer reassignment, licensing changes where legally possible, or reduced support for non-Nvidia backends such as ROCm and Vulkan. Commenters largely frame forking as the fallback if governance changes, but express concern that Nvidia ownership could bias future llama.cpp development toward CUDA and away from AMD/portable GPU backends.

  • Commenters focused on the technical ecosystem risk that llama.cpp could remain open source but become less useful for non-NVIDIA hardware if ROCm, Vulkan, or broader AMD GPU support were deprioritized. Several explicitly called out ROCm/Vulkan backend support as the main concern rather than repository availability, since llama.cpp’s practical value depends heavily on portable inference backends.

  • One commenter noted that if stewardship changes in a way that harms portability, the likely response would be to fork llama.cpp and continue development independently. This reflects the project’s open-source resilience, but also implies potential fragmentation across CUDA-focused and vendor-neutral inference stacks.

  • There was also speculation about Hugging Face previously rejecting NVIDIA investment for similar independence/vendor-lock-in reasons, contrasted with the rumored 7B offer mentioned in the thread title. The technical implication raised was whether ownership pressure could shift priorities away from heterogeneous hardware support toward NVIDIA-first optimization.

• friendly reminder you can legally torrent ai models. (Activity: 577): The post argues that model weights hosted on platforms like Hugging Face can be redistributed via BitTorrent/P2P when their licenses permit it, and that torrenting itself is a transport mechanism, not inherently piracy. It frames torrents as a decentralized fallback if centralized model hubs change policy, naming tools/services such as qBittorrent, ModelScope, Kaggle Models, and Civitai; one commenter specifically notes that torrent-distributed models should publish SHA-256 hashes for integrity verification. Commenters push back on the premise that torrenting is illegal and argue that Nvidia would likely benefit from open/local AI models because they drive GPU demand. The main technical concern raised is supply-chain trust: torrents should be paired with independently published cryptographic hashes or signatures.

  • One commenter highlighted a practical supply-chain/security requirement for distributing models over BitTorrent: torrents should be accompanied by independently published SHA-256 hashes so users can verify model files after download and avoid corrupted or malicious weights.

  • A linked resource, llama.garden, was shared as an example of a site aggregating downloadable/torrentable AI model weights, relevant for users looking to distribute or fetch large open models outside centralized hosting platforms.

  • There was a brief hardware-market argument that NVIDIA benefits from open/local models because broader local inference adoption increases demand for consumer and workstation GPUs, making open-weight model distribution complementary to GPU sales rather than a threat.

Normally we eschew AGI timeline talk on Latent Space, because it is so ill defined and unaccountable, but, well, missing it would probably be the worse sin at this point. We last checked in on OpenAI AGI timelines 9 months ago, and, right on target, Chief Scientist Jakub Pachocki is now saying the unreleased Astra model is the “Automated AI Research Intern” he had aimed for by September 2026. Sama goes further in their TIME interview and estimates they’ll declare AGI achieved internally by December 2026.

Start the clock.

AI News for 8/22/2026-8/24/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Open-Source Robotics Breakout: Hugging Face and Pollen’s $399 Microduck

• Microduck launch: The standout hardware release was Microduck, a 25 cm open-source biped from Pollen Robotics and Hugging Face priced at $399 and slated to ship before Christmas. It can be trained in simulation and deployed on the real robot, with 15 actuators and a notably rich sensor stack including camera, speaker, LiDAR, NFC, Bluetooth, and Wi‑Fi. Launch posts from @pollenrobotics, @Thom_Wolf, and @ClementDelangue emphasize reinforcement-learning-based customization plus several pre-trained policies out of the box.

• Why it matters technically: The interesting part isn’t just “cheap cute robot,” but the package design: an open simulator, transfer from sim to hardware, and a form factor cheap enough to invite community policy training rather than just demo consumption. The simulator is already public via a Hugging Face Space, highlighted by @HuggingApps, and this open-loop from community training to real deployment is what got multiple researchers immediately buying units, e.g. @yacineMTB and @gneubig.

• Early traction and community experimentation: The release resonated unusually broadly for robotics. Thom Wolf shared experiments such as a quick image-detector integration to let the robot follow a laser pointer in real time @Thom_Wolf, then reported sales velocity of one Microduck every 5 seconds and later $1M in sales @Thom_Wolf, @Thom_Wolf. The combination of low price, open sim, and embodied RL makes this one of the more credible “consumer-scale physical AI” launches in recent memory.

GLM-5.3-Flash/Ox Alpha Reveal and Local Open-Model Momentum

• Ox Alpha unmasked as GLM-5.3-Flash: One of the biggest model stories was the confirmation that the mystery model Ox Alpha was actually Z.ai / Zhipu’s GLM-5.3-Flash, as noted by @theo, @UnslothAI, and @togethercompute. The disclosed spec repeatedly cited across tweets: 320B total params, 18B active, 1M context, and hybrid attention, with strong results on coding/agentic benchmarks.

• Open weights + quantization + local serving: The release caught attention because people quickly pushed it into local workflows. Unsloth said the model can run 3-bit GGUF on 128GB RAM @UnslothAI, while @danielhanchen claimed 4-bit retains 93% accuracy and makes the model practical on a 256GB Mac or two DGX Sparks. This is exactly the kind of post-release ecosystem response open-model engineers care about: quantization, serving recipes, and real deployment constraints moving almost immediately.

• Price/performance narrative: Several tweets framed GLM-5.3-Flash as a new efficiency frontier. @togethercompute said it nearly matches Luna on DeepSWE while doing more than twice as much work for the same budget; @theo called it good enough to reorder his model rankings; @zainhas suggested using high rather than max reasoning effort because accuracy stayed roughly flat while token usage doubled. Baseten also highlighted 122+ TPS serving throughput on day 0 @baseten, while Databricks cited 270 tok/s and 10% higher quality than GLM-5.2 at 1/10 the cost on OfficeQA Pro v2 @Yuchenj_UW.

Video Generation Race: Gemini Omni 1.1 Flash and H3 Max

• Gemini Omni 1.1 Flash: Google released Gemini Omni 1.1 Flash, a multimodal video generation/editing model with several developer-facing controls: scene extension to 40s, first/last frame control, 3-second video references, 360p draft mode, and 4K upscaling. The rollout was announced by @Google, @GoogleAIStudio, and summarized with prompting guidance by @_philschmid. The most notable product detail is that Google is exposing increasingly explicit temporal and reference conditioning rather than just “prompt harder.”

• Early leaderboard results: @arena reported Omni 1.1 Flash landing #1 in Text-to-Video Arena and #2 in Image-to-Video Arena, with a +20 pt lead over the #3 text-to-video model and a +25 pt improvement over prior Gemini Omni Flash on image-to-video. That does not settle all qualitative questions, but it indicates Google’s latest post-training and control stack is translating into preference data.

• fal + MiniMax H3 Max: In parallel, fal launched H3 Max with MiniMax, advertising 15s of high-quality video in 5s and “50x faster” generation than other high-quality models @krea_ai, with technical writeups from @fal and praise from @MiniMax_AI. The theme across both launches is clear: inference optimization and productized controllability are now as important as base-model quality in video.

Agents, Harnesses, and Enterprise Tooling

• Harnesses becoming first-class: A recurring theme was that model capability is increasingly mediated by the agent harness. @omarsar0 highlighted JIT-Agent, where the model synthesizes a harness over modules for memory, planning, action protocol, and tool orchestration, reporting gains over off-the-shelf agents. Separately, @dair_ai shared work inducing compact finite-state machines from agent traces, suggesting behavior topology may be shaped more by deployment scaffolds than by the underlying LLM.

• Product releases around agent infra: Anthropic released a cookbook for connecting Claude Managed Agents to Vercel’s Chat SDK, giving a unified chat layer with server-side harness, session management, and memory @ClaudeDevs. Perplexity added connectors in Agent API for GitHub, Slack, Google Drive, and Datadog @perplexitydevs. Cursor announced a workflow to create web apps, store code with Origin, and deploy to Vercel @cursor_ai.

• Higher-trust browser automation: Nous shipped a significant escalation for browser-use agents: Hermes Agent can now browse as you, using a managed copy of your real Chrome profile / logins @NousResearch, @Teknium. This is a notable usability boost, but it also materially changes the risk surface for cloud agents by collapsing auth friction and making scoped-permission design much more urgent.

Security, Agent Misalignment, and Cyber Defense Coordination

• OpenAI-led cyber defense coalition: OpenAI published an open letter signed by 116 organizations including Anthropic, AWS, Google, Microsoft, and Oracle, calling for a global surge in cyber defense against AI-enabled attacks @OpenAI, with Sam Altman stressing that “there is not much time to act” @sama. Regardless of one’s policy priors, this was one of the day’s clearest cross-industry coordination moves.

• Double-blind frontier evals: Google DeepMind announced a pilot for double-blind evaluations of frontier AI, using a secure environment where neither test prompts nor model weights are revealed @GoogleDeepMind. For practitioners, the key significance is procedural: a serious attempt to make external evals possible without giving either side full visibility into the other’s assets.

• Agent incident analysis continues: Discussion around the OpenAI/Hugging Face agent incident remained active. Researchers involved in the investigation shared extra details about large transcript sweeps, collaboration patterns among agents, and later swarms apparently building on earlier work @RyanGreenblatt, @HjalmarWijk, @ajeya_cotra. A separate paper summary from @omarsar0 on EvoMal warned that shared skill libraries can become self-poisoning malware propagation channels for coding agents. Together these point to a maturing realization: multi-agent systems introduce failure modes that are neither classic software bugs nor standard model eval issues.

Top tweets (by engagement)

• Microduck dominates mindshare: The highest-signal product buzz centered on @ClementDelangue’s Microduck announcement, @Thom_Wolf’s technical launch thread, and follow-up sales milestones from @Thom_Wolf.

• Cyber defense call gets major traction: The strongest policy/security engagement came from @sama and @OpenAI on collective cyber defense.

• Anthropic’s science push lands: @claudeai announced a Claude Team plan for scientists covering 10,000 researchers, with free standard seats and premium seats at $15/month for a year.

• Hermes browser access stands out: @NousResearch drew substantial engagement for giving agents access to a user’s real browser profile, one of the more consequential UX/security tradeoffs in current agent tooling.

TheInformation had the scoop, and now they have the confirmation — Nvidia is buying HuggingFace for $13B, roughly 80x their $150M ARR, having doubled its customer base in 2026. This is almost double Nvidia’s initial $7B offer in Jan 2026.

What can we say? We love it when the good guys win. But in the backdrop of GLM-5.3-Flash (aka Ox Alpha) impressing everyone (except GDM vaguepoasters) and Qwen also shipping an impressive Flash model on chinese chips, perhaps the post Hot Chips conversation about Western open AI is a great backdrop for this.

AI News for 8/25/2026-8/26/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Top Story: GLM 5.3 Flash launch and reactions

Z.ai formally launched GLM-5.3-Flash, revealing that the previously previewed “Ox Alpha” model is its public identity.

• Z.ai announced GLM-5.3-Flash as a natively multimodal model with a 1M-token context window, 320B total parameters / 18B active parameters, released under the MIT License, and available via weights, API, chat, coding plan, and AutoClaw.

• Z.ai simultaneously positioned it as a highly price-competitive successor to GLM-5.2, claiming on its internal benchmark that it outperforms GLM-5.2 at every effort level and is on par with Claude Opus 4.8 on coding.

• The launch also resolved the long-running Ox Alpha mystery: multiple posters explicitly connected Ox Alpha to GLM-5.3-Flash, including SemiAnalysis, rasbt, theo, and Cline.

• Early third-party model infrastructure support appeared almost immediately: CoreWeave, Baseten, and Cline’s free integration in VS Code / JetBrains / CLI.

• Shortly after launch, Z.ai engineer Zixuan Li said the chat template had been updated and early downloaders should re-download the model, implying a day-0 packaging or prompt-format correction.

• Artificial Analysis first published an overview with an incorrect 400k context window, then issued a correction to 1M context, aligning with Z.ai’s original announcement.

• Community response was unusually strong for an open-weight release, ranging from brief shock reactions like “HOLY” to more substantive claims that the model may now be the best intelligence-per-dollar option, e.g. Artificial Analysis and zainhas.

• The launch got folded into a broader narrative around Chinese frontier open models, with posts arguing that open Chinese labs are converging on similar architecture choices around linear attention, sparse attention, residual path design, and Muon.

• Independent pushback emerged on at least one modality claim: skalskip92 argued the model looks weak on several vision/object detection tasks despite being “native vision.”

Z.ai’s primary launch tweet is the factual anchor: GLM-5.3-Flash is described as:

• 320B total params / 18B active

• 1M-token context

• natively multimodal

• MIT licensed

• previously previewed as Ox Alpha

• “running entirely on Chinese AI chips”

Distribution/availability at launch:

• Weights on Hugging Face

• Z.ai API

• Chat

• ZCode

• Coding plan

• AutoClaw

The strongest self-reported vendor performance claim came from Z.ai’s coding thread: on the Z.ai Code Bench, GLM-5.3-Flash “clearly outperforms GLM-5.2 at every effort level and performs on par with Claude Opus 4.8”. Because this is first-party benchmarking, it is useful but should be read more cautiously than independent evals.

A follow-up launch-support post from AutoClaw framed the model as suitable for vision-language understanding, code generation, and long-horizon agentic tasks and paired availability with credits/rebates, but this is mainly rollout information rather than new technical evidence: AutoClaw launch post.

The most substantive independent evaluation in the tweet set came from Artificial Analysis. Their summary: GLM-5.3-Flash scores 57 on the Artificial Analysis Intelligence Index.

• AA Intelligence Index score: 57

• Gap vs GLM-5.3: 3 points behind GLM-5.3 at 60

• Cost per task: $0.09

• API price: $0.15 / 1M input, $0.50 / 1M output

• Cached input: ~$0.026–$0.03 / 1M, described as 80% discount

• Model size: 320B total / 18B active

• License: MIT

• Context: initially listed as 400k, later corrected to 1M

• Ties GPT-5.6 Terra and Muse Spark 1.2 at 57, but at much lower cost per task.

• $0.09/task vs $0.68/task for GLM-5.3 max.

• Claimed ~7.5x lower cost per task than GLM-5.3 max.

• Claimed ~5.7x cheaper per task than GPT-5.6 Terra and ~4.4x cheaper than Muse Spark 1.2.

Artificial Analysis notes an interesting tradeoff:

• GLM-5.3-Flash used 149M output tokens to run the Intelligence Index

• compared with 168M for GLM-5.3

• but more than Kimi K3 (133M) and Qwen3.8 2.4T A95B (136M) at similar Intelligence Index score

• 134M of the 149M tokens (~90%) were reasoning tokens

This is an important nuance: the model’s economics look excellent largely because token pricing is extremely low, not because it is especially token-frugal.

Artificial Analysis also reports that GLM-5.3-Flash is stronger than its raw knowledge metrics might imply on agentic tasks:

• GDPval-AA v2 Elo: 1770

  • tied within margin of error with GLM-5.3 and Grok 4.6

  • behind only Claude Opus 5 xhigh/max

• Terminal-Bench v2.1: 84.3% vs 83.9% for GLM-5.3

• τ³-Banking: 47.2%, trailing GLM-5.3 by 3.1 percentage points

• AA-Omniscience score: +7

• Accuracy: 28%

• Hallucination rate: 28%

• Compared with GLM-5.3:

  • GLM-5.3 accuracy 34%

  • GLM-5.3 hallucination rate 30%

• Compared with GPT-5.6 Terra:

  • Terra accuracy 47%

This suggests a recurring theme in reactions: GLM-5.3-Flash may be much stronger on practical code/agentic workflows than on broad real-world factual knowledge.

Several technically informed reactions tried to reverse engineer or summarize what changed from GLM-5.2 / GLM-5.x.

The most detailed public architecture breakdown in the tweet set came from rasbt, who says GLM-5.3-Flash moves from GLM-5.2’s 744B-A40B backbone to 320B-A18B, and uses:

• Kimi Linear-style 3:1 hybrid attention

• 34 KDA layers (Kimi Delta Attention)

• 11 MLA/DSA layers

  • MLA = Multi-head Latent Attention

  • DSA = DeepSeek Sparse Attention

• DeepSeek V4-style mHC residual path

• four parallel streams

• plus a native vision encoder

The same tweet describes it as “super hybrid” because both major attention components are already “efficient” variants rather than a simple efficient/full-attention hybrid.

Another useful systems-oriented summary from thealexker frames the release as an efficiency story, highlighting:

• compared to GLM-5.2:

  • ~1/10 the cost

  • active params 32B → 18B

  • layers 92 → 45

• hybrid linear + sparse attention

• smaller average KV cache per layer

• lower attention compute compounding at long contexts

• claims that visual intelligence benefited from coding/RL style improvements

• says the GLM-5.3 infrastructure agent co-authored parts of the work by helping with kernels, bottlenecks, and serving stack optimization

The broader context post from eliebakouch is opinionated but technically notable because it places GLM in a Chinese open-model trend:

• nearly all Chinese frontier models now use linear attention

• nearly all use sparse attention / indexer-compression designs

• many use fancy residuals like mHC, attention residuals, gated residuals

• many use Muon

That post is not a direct GLM paper summary, but it helps explain why the architecture details immediately resonated with model engineers: GLM-5.3-Flash appears to be another data point in a fast-converging efficiency-first Chinese frontier OSS design space.

The hardware/serving side was one of the most-discussed parts of the launch.

Z.ai itself said the model was “running entirely on Chinese AI chips”. The strongest amplification came from SemiAnalysis, which focused on the claim that 100T tokens/day are being served on Chinese chips. That tweet does not provide all the derivation, but it framed the infrastructure feat as the most shocking part of the reveal.

Reactions emphasized the significance:

• theo: “Ox being a ‘flash’ model is insane. Serving all the traffic on Chinese chips is even more insane.”

• same-day OSS mood post folded GLM into a broader celebratory open-source narrative.

There was also explicit back-of-envelope capacity reasoning from teortaxesTex:

• If inference economics are comparable to V4-Flash,

• 10K tokens/s/NPU is “realistic”

• 864M/day per chip

• 100T/day would imply about 116K chips

• suggesting 100K+ chips scale, “doable” but consuming an enormous fraction of total compute

That estimate is speculative rather than confirmed, but it shows how engineers interpreted the serving claim: not as marketing fluff alone, but as an infrastructure statement implying very large domestic accelerator fleets and mature inference optimization.

A notable part of the reaction cycle was how quickly usage posts appeared.

Cline said GLM-5.3 Flash was already its fastest growing model in Cline history, driving 11% of all traffic in less than a week, while also advertising it as free in Cline. This is partly promotional, but it is also a concrete demand signal.

Infrastructure providers moved quickly:

• CoreWeave: “coming soon to CoreWeave Serverless Inference”

• Baseten: day-0 availability, emphasizing general intelligence + agentic coding, native vision, and 1M context

• Dell via Jeff Boudier: framed GLM 5.3 Flash and Qwen 3.8 Flash as open models ready for on-prem deployment

This matters because it reinforces that GLM-5.3-Flash was not treated as a curiosity; it was immediately slotted into real inference/developer stacks.

• Z.ai launched GLM-5.3-Flash as 320B total / 18B active, 1M context, MIT-licensed, multimodal, previously previewed as Ox Alpha.

• Z.ai claims the model runs on Chinese AI chips.

• Artificial Analysis reports AA Intelligence Index 57 and $0.09 cost/task, plus various benchmark details and pricing.

• Artificial Analysis later corrected its context listing from 400k to 1M.

• Zixuan Li said the chat template was updated and model users should re-download.

• Cline said the model drove 11% of all traffic in under a week.

• Baseten, CoreWeave, AutoClaw, and others announced support/distribution.

• theo, zephyr_z9, and nicdunz expressed strong positive surprise.

• thealexker interpreted the release primarily as a story of efficiency engineering.

• eliebakouch framed it as evidence of exciting convergence in Chinese frontier open architectures.

• zainhas argued it is now the best intelligence-per-dollar choice.

• skalskip92 argued the model is bad at vision, pushing back on the launch’s multimodal framing.

• scaling01 alleged it was “painfully obvious” Ox Alpha was a GLM model and further alleged ZAI used hype accounts; that claim is unverified in the tweet set.

By far the biggest announcement at the 37th Hot Chips conference was OpenAI’s stunning progress on their own chip, less than a year after the Broadcom announcement… and that it isn’t an ASIC; but a full on Blackwell-beating alternative.

The key metric now is shifting to performance per watt, and Jalapeno delivers:

The full Hot Chips presentation is not yet out but various takes are below. For a fuller breakdown, watch along with the rest of OpenAI:

AI News for 8/24/2026-8/25/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

OpenAI’s Jalapeño Inference Chip and the Shift in the Inference Stack

• Jalapeño’s published numbers are the day’s biggest technical story: OpenAI released first benchmark details for its custom inference chip Jalapeño, claiming materially better efficiency and latency than NVIDIA GB200/GB300 systems on real model workloads. In OpenAI’s tests, Jalapeño delivered 1.5–1.9× more work per watt at peak throughput and 1.7–3.6× lower end-to-end latency, with 2.1–4.1× higher performance for highly interactive workloads; the chip is rated at 700W but reportedly stayed at or below 550W on the tested runs. OpenAI says deployment into its own infrastructure begins by year-end, with Gen 2 already deep in development and Gen 3 underway (OpenAI announcement, deployment roadmap, Sam Altman).

• Why engineers care: the claim is not just raw perf, but a more balanced inference architecture that reduces the usual throughput/latency tradeoff. Multiple technical reactions highlighted that some comparison points are especially notable because Jalapeño reportedly performed well even without tricks like aggressive prefill/decode disaggregation or speculative decoding in some setups, while beating systems that did use them (gdb, kimmonismus summary, eliebakouch analysis, You Jiacheng). SemiAnalysis framed it as unusually strong for a first-generation ASIC and compared it directly against Blackwell and Rubin-class systems (SemiAnalysis, dylan522p).

• A second-order story is model-assisted systems optimization: OpenAI’s post also said GPT-Astra + Codex helped write and optimize low-level kernels, bringing three previously unplanned open-weight models to high performance on Jalapeño in about two months; for selected attention and MoE blocks, these implementations reportedly ran 1.5–1.8× faster than existing human-expert-written code (kimmonismus, eliebakouch). That is a meaningful signal that compiler/kernel work is increasingly being folded into the model improvement loop, not just application-layer coding.

• Broader infra implication: several posts tie Jalapeño to a larger industry transition in which frontier labs may no longer be strictly downstream of NVIDIA for inference economics, even if packaging and foundry capacity remain a hard bottleneck (Liam Fedus, teortaxesTex reaction, LearnOpenCV caveat on TSMC/CoWoS capacity).

Agent Harnesses, Memory Systems, and Eval Engineering Becoming First-Class

• Harness quality is increasingly as important as model choice: several papers and launches converged on the same theme: agent performance depends heavily on the surrounding system. A new Microsoft-led paper on AutoSaddler treats the harness as code and patches prompts, tool configs, and control logic offline using failure traces, reporting gains of +9.0 on GAIA2, +9.6 on SWE-Bench Pro, and +10.0 on Terminal-Bench 2.0 over base harnesses (paper summary). In parallel, another paper quantified harness variance directly, finding that swapping harnesses could move scores far more than swapping models, with model-pair rankings flipping across scaffolds; the proposed fix is a structured Harness Card disclosure standard (analysis, “There Is No Neutral Harness”).

• Long-horizon software engineering remains very unsolved: SWE Refactor Bench measures whole-repository migration tasks like C→Rust, Maven→Gradle, and POSIX→WebAssembly across real projects including SQLite, zlib, and libsodium. Across 520 runs, only 28 survived all three stages, for a 5.4% survival rate, and 13/20 tasks were solved by nobody (EinsiaAI). This is a useful corrective to strong bug-fix numbers on more local coding benchmarks.

• Memory systems are being redesigned as programmable state, not compressed chat history: one Alibaba paper summarized by DAIR backs agent sessions with an append-only event log plus a persistent Python kernel, binding tool outputs and derived state to typed variables instead of continually serializing them into prompts. Reported results include 94.8% on LongMemEval_S, 73.1% on BEAM_10M (+5.1 over the previous best published memory system), and 86.7% on LOCA_256K with Qwen3.8-Max (summary). Related work on Knowledge Triage showed that naive context compaction destroys exact-rule retention; after five rounds of compaction, one setup preserved only 10% of safety rules, while type-aware retention policies preserved 2–4× more (summary).

• Practical eval-engineering is moving from ad hoc to productized workflows: LangChain/partners shared a concrete loop for turning traces and human feedback into task specs, synthetic environments, and evals that can be used to measure and post-train agents over time (Vtrivedy10, hwchase17). LangSmith Engine also shipped >2× better performance on key internal benchmarks with better issue detection/clustering, SaaS and self-hosted support, Slack/Linear integrations, and cost-tiered analysis modes (LangChain).

Local-First Agents, On-Device Inference, and the New Personal Compute Stack

• Perplexity’s Portable Computer is the clearest local-agent product launch of the day: Perplexity launched Portable Computer on NVIDIA DGX Spark, positioning it as a fully local version of Perplexity Computer where the orchestrator LLM, subagent LLM, and agent harness all run on local hardware with no cloud dependency (Perplexity launch, model details, NVIDIA, Arav Srinivas). The initial local stack uses a post-trained PPLX 27B with Qwen 3.8 27B also available; Nemotron 3.5 Lightning support is coming.

• The deeper trend is persistent, always-on local agents: Srinivas explicitly sketched a future of background processes that continuously ingest context from connectors, perform multi-hop reasoning in a perpetual loop, and run on your own hardware (Arav Srinivas). Community reactions were split between excitement about privacy/control and skepticism that “local-first” should mean a $5k DGX Spark rather than commodity consumer devices (theo critique, theo follow-up).

• Apple/macOS local AI tooling is also maturing: exo said Apple featured it on new M5 Ultra Mac Studio and M6/M5 Pro Mac Mini pages, emphasizing low-latency RDMA over Thunderbolt 5 to cluster Macs and run models like Kimi K3 and GLM-5.3 at API-like speeds, with 4× M5 Ultra scaling to about 4.8 TB/s aggregate memory bandwidth (exo). Related posts pointed to Apple’s faster PCIe storage and ANE-based vision pipelines as making small local clusters and mixed CPU/ANE/GPU inference more practical (anemll, onirenaud).

• Tooling continues to fill in around local runtimes: Ollama v0.33 added one-toggle integration to let Claude Desktop use Ollama as a third-party gateway for cloud and local models (Ollama); OpenCode v2 was shown running inside a Cloudflare Durable Object, illustrating how small agent runtimes are becoming embeddable in edge environments (fayazara).

Models, Retrieval, and Search Infrastructure

• Qwen 3.8 is showing up across the stack: enthusiasm around the Qwen3.8 release was visible in both deployment and evaluation posts, with Together adding fine-tuning and dedicated inference support for Qwen3.8-27B (Together) and Unsloth claiming full QLoRA fine-tuning of the 27B model on free 2× Tesla T4 Kaggle instances using optimized kernels (danielhanchen). On the application side, Qwen3.8-27B reached #1 among open models in the Image-to-WebDev Arena and #7 overall, while priced at $0.40 / $3 per million input/output tokens (arena).

• Search and retrieval infra got multiple substantive updates: Hugging Face published a detailed architecture writeup for the Papers with Code search engine: PostgreSQL + pgvector, Qwen 3 Embedding 0.6B, hybrid retrieval, embeddings generated on an NVIDIA L4 via Hugging Face Jobs, artifacts in buckets, and live serving via Inference Endpoints; the same stack powers “related papers” on paper pages (Niels Rogge). Keenable came out of stealth with a Web Search API and Web Query Language for AI, built by former Yandex Search leaders and backed by a $26M seed, explicitly targeting agent-scale web retrieval (styskin).

• Retrieval model design remains active territory: there was renewed discussion around late interaction / multivector retrieval, with claims that scaling behavior is finally becoming visible in retrieval workloads and that model+DB co-design matters at least as much as storage format (mixedbread perspective, Silvio Martinico).

Robotics, Physical World Models, and Embodied Data

• Figure’s “Index” is a major robotics data announcement: Figure introduced Index, described as the largest and most diverse robot dataset in the world, with reported ingestion at 30 minutes of video uploads per second, 16M video uploads, $15M already paid out for data, and 264k downloads. The company also says it will spend $1B over the next 12 months on data and compute (Brett Adcock, follow-up). That scale matters because many robotics labs still appear more bottlenecked on demonstration and perception data than on architecture novelty.

• Large-scale physics/world modeling continues to push context limits: Anima Anandkumar highlighted Accelerated Understanding, a startup building large AI models for physical simulation across modalities and 4D spacetime, claiming 1T parameters during pretraining, 1T context during training, and >5T context at inference without subsampling or patching (Anima Anandkumar). The details are sparse, but the post is notable as a statement of where some frontier non-language modeling work is heading: massive-context multimodal simulation rather than only text/video generation.

• Embodied policy generalization remains an active benchmark target: a separate robotics post introduced S1, a manipulation model that can complete tasks from a single demonstration outside its training distribution (anag004). Google Research also shared AgentHands, an XR system that augments conversational agents with synchronized hand gestures for spatial guidance during physical tasks (Google Research).

Top tweets (by engagement)

• OpenAI chip launch: @sama on Jalapeño, @OpenAI benchmark announcement drove the largest technical conversation by far.

• Local agent launch: @perplexity_ai launching Portable Computer was the biggest product release outside the chip story.

• Developer platform / agent-native web: @OpenAIDevs announcing the WebMCP Challenge and WebMCP support in ChatGPT desktop signal OpenAI pushing websites toward explicit agent interfaces.

• Open-source local task agents: @AndrewYNg on OpenWorker stood out for combining open harnesses, local models, and security-focused workflows.

• Benchmark realism for coding agents: @EinsiaAI on SWE Refactor Bench is one of the more useful benchmark releases in the set because it targets whole-repo migrations instead of local edits.

Lovable is well known as an AI-powered platform to build applications. But ironically, it is now moving towards a future where fewer and fewer people will be using conventional apps. That is, of course, because of the growing impact of agents.

In a recent blog post, Lovable outlined a vision for “a digital brain for your team connecting your daily tools.”

Or as Lovable CTO Fabian Hedin put it in an interview with Latent Space, “you can get to a place where you’re using one entry point to all the work that you’re doing.”

To be clear, Lovable still wants to be the tool you use to build apps — but increasingly, it will also enable you to build what Hedin calls “capabilities.” Lovable defines a capability as a useful part of an application that an agent can call directly; bypassing the need for a human user to open the app.

Lovable can turn a published application into agent-accessible capabilities by exposing selected functions from the app as tools through a hosted MCP server. The result is essentially one application with two interfaces: a traditional human UI and a new agent interface that can be used from ChatGPT, Claude and other MCP-compatible AI clients.

This shift towards capabilities is the latest evolution from Lovable, in an already fast-moving 3 years in business.

Lovable emerged from GPT Engineer, an open source coding tool that launched in 2023, initially focusing on prototyping. In November 2024, it became a commercial product and the following month, it was rebranded as Lovable.

By that point, they’d begun to notice some of its users building production apps on Lovable — including products that had become real businesses.

“We started seeing people on the platform building not only a prototype, and not only an MVP [Minimum Viable Product], but the actual thing — an actual product that serves real customers,” Hedin said.

Next, Lovable noticed its users creating internal software, in some cases to support a public-facing app and in other cases as an internal app built for an enterprise company.

“People started creating not only software to enable a business, in terms of a customer-facing product, but also the operations behind the company,” Hedin said.

He means tools like a CRM, an admin panel, or a customer-support console.

So in less than three years, Lovable has become an all-round software creation and hosting company, which means it’s swimming in the same waters as the likes of Vercel and Cloudflare. That said, Lovable is more focused on AI-generated software than infrastructure. But we are seeing crossover in these markets — for example, Vercel’s v0 allows you to generate an app from natural language, just like Lovable.

Also just like the black triangle and orange cloud companies, Lovable has expanded into agentic workflows.

This rapid product evolution has been accompanied by strong user and revenue growth. According to a tweet from Deedy Das, a partner at lead investor Menlo Ventures, the company has surpassed a $500 million annualized revenue run rate, with more than 60 million projects created and over 900 million monthly visits to Lovable-built apps. Lovable also says employees at nearly two-thirds of the Fortune 500 have used the platform.

Unsurprisingly, Menlo Ventures is doubling down on its investment. It led Lovable’s $400 million Series C this month, alongside the Scaleup Europe Fund managed by EQT, valuing the company at $13.3 billion.

Hedin attributes the pace of change to a combination of Lovable’s innovation and the rapidly improving state of LLMs.

“Every few months, we introduce new capabilities at the application layer, while the large language models also continue improving. Those two things compound.”

The concept of a digital brain for an organization, for Lovable, essentially means a single interface where you can access many different tools and workflows.

“It should have as much context as possible about you, your company and the world around you,” said Hedin. “Then it needs the capabilities to perform both general tasks and actions that are specific to your organization.”

Ultimately, he added, the goal is that “everything that you’re building can be reused in an agentic way.”

In a sense, then, applications are becoming a collection of capabilities that users will increasingly access through an organizational agent — instead of, or in addition to, the actual application.

“Our job as a platform is to ensure that all these separate capabilities are connected through one agent — not that you have to build a different agent for every task,” said Hedin.

As an example, Hedin mentioned an internal application they use at Lovable.

“We built this internal tool to help us grant credits to users [via] our support team, and help manage our platform in different ways. Those capabilities are now available [internally] through the Lovable agent.”

Lovable also wants this company brain to work asynchronously. Its agent can schedule itself to resume a task later — for example to check a deployment or to monitor a recurring process — then return the result to the same conversation.

Lovable isn’t the only company pursuing a “company brain” vision. Vercel CEO Guillermo Rauch recently introduced its internal agent, called @𝚟. “Every day-to-day job at Vercel now involves @𝚟,” Rauch tweeted. “It’s growing exponentially both in daily interactions and token use.”

Hedin acknowledged that Vercel and other AI companies are building towards a similar vision, but he thinks Lovable’s “wedge” is “being the best place to build the capabilities that agents need.” In other words, Lovable’s focus is on helping their users build the capabilities that a company brain will need.

“Orchestrating these capabilities is the easy part,” Hedin said. “Making sure they are well connected, built correctly and reliable is the hard part.”

He also hinted at why they’re using the word ‘brain’ to describe this shift, rather than just ‘agent’.

“I’m careful about using the word ‘agent.’ It suggests something like an employee performing a task, which is an easy way to think about it. But underneath, it is really about connecting the right context and capabilities.”

Perhaps the biggest challenge with the agents and capabilities paradigm is security. For instance, if one of your employees creates an app with Lovable that connects to the company Slack, you want to ensure that user doesn’t inadvertently expose their personal messages, or any other confidential information, to the company brain.

Connectors are Lovable’s method of connecting to external tools and services. Hedin said the platform must account for a “kind of permissioning graph” to maintain security and privacy.

As described in a technical article on Lovable’s blog, one connector type, which Lovable calls an “app user connector,” preserves each user’s identity and source-system permissions. Credentials are stored server-side in encrypted form and handled by Lovable’s connector gateway, rather than being exposed to the generated application; the app instead presents a short-lived key bound to the relevant user.

“We separate the connection to external systems from the application code being written,” is how Hedin put it. “The application interfaces with the Lovable platform, but the application itself never gets access to those credentials.”

So Lovable is moving to a future where a company brain uses capabilities derived from the apps its users build. That begs the question: what will happen to SaaS apps?

Hedin reiterated that people will increasingly interact with software through an AI layer — the company brain concept.

“People are not going to have as many tabs open in different tools as they have historically. That experience is going to consolidate, but the vertical capabilities those tools provide will remain valuable.”

He recognizes that some traditional SaaS products may “fight” this trend, by sticking with their traditional apps and not adapting, but he says Lovable wants to become a platform for building capabilities.

“We want to build this open platform that anyone can connect to, anyone can use,” he said.

Hedin ended with some advice for SaaS companies, whether existing ones or apps that might emerge on the Lovable platform.

“I think SaaS businesses are going to have to focus more on providing the shovel for AI to use their capabilities.”

A few years ago, Caltech Prof. and co-founder of Accelerated Understanding, Anima Anandkumar set out to develop the first open-source weather model with AI. Talking to experts in the field, she was met with skepticism. Weather is chaotic, physics simulations are hard, have been developed for decades, and require supercomputers, the data just isn’t there. Despite reservations, Anima went forth and built. Within a year her team had developed FourCastNet, a predictive model that is competitive with the best physics-based simulations available. Thanks to Anima, and her follow up work, anyone can now predict weather accurately over a short timescale using consumer grade GPUs.1

In the fifteen or so science episodes we’ve released on Latent.Space, we’ve covered atoms, molecules, materials, biology, and math. Anima is a pioneer in studying physical systems that are continuous. Weather, fusion, and fluid or heat flow are huge areas of science that are extremely difficult to model: they are large, chaotic, and fundamentally multi-scale. This is a field the AI community has somewhat neglected, but one we expect will grow fast. We plan to cover large physical systems more in coming episodes.

One thing you can glean from Anima’s work is that this area of AI resists the scaling ideas that have permeated the rest of the field. The data isn’t there: open source datasets in many of these domains are limited to tens or hundreds of thousands of examples, far from what token-hungry transformers need. Even worse, the resolution that physics demands pushes the context length into the hundreds of billions, so you can’t just throw more tokens at the problem. That isn’t a ceiling though, just a slower road: progress here comes from building in structure and inductive biases. Sorry for all you bitter-lesson-pilled language modelers.

“If each dimension is even a few hundred grid points, which is where industrial scale starts... we’re talking hundreds of billions to even a trillion context length. So forget ever having a transformer for anything of this scale, all of the world’s compute will not be enough.”

To tackle these systems, Anima pioneered a technique known as Neural Operators, one of the most beautiful theoretical developments in AI of the last decade.2 These allow you to combine data and physical laws to enable multi-scale inputs and outputs. We’re no longer modeling a grid, we’re modeling a function that evolves over many scales. This allows Anima and crew to build in priors based upon physical intuition.

To see how physical priors are still helpful for AI modeling, let’s revisit the problem of weather forecasting on a global scale. The earth is a sphere, which meant that accurate modeling involved using the right basis set —3 the Spherical Harmonics. Run a weather model on a grid and it blows up fast. Move to the natural basis for the problem and it stays stable far longer, long enough to roll out months ahead instead of days. Anima’s Fourier Neural Operator learns directly in this frequency domain, and its spherical variant powers FourCastNet 3, which models the weather across the whole globe and keeps running stably far into the future.

Anima explored Neural Operators across other physical domains too, and one striking observation is that the physical world is more forgiving than you’d expect. In fusion, a few thousand samples are enough to predict plasma disruptions, and to do it a million times faster than traditional simulation.

None of this is a rejection of scale, it is a different route to it. Anima ultimately still wants to build a “foundation model for physics”, a model that spans many phenomena and does both simulation and design. You get there by building in the structure the physical world already has, not by waiting for data that will never exist. It is a start, and it will take longer than the token-driven parts of AI, because for the physical world tokens were never the answer.

“All of the things that work with deep learning, let’s take them, but make them a bit more principled.”

Neural operators and weather modeling were a personal passion of mine, so we’ve spent much of this blog and the episode exploring this work. Anima has done so much more! In the episode, we cover several other recent developments from Anima:

• Anima has a series of works integrating neural networks and automated proof techniques. We talk about TorchLean, a new framework that lets you write PyTorch-style networks inside the proof assistant Lean and formally verify them. This is a major step for proving bounds on neural networks, something that would be really important for someone trying to, e.g., add a neural network as part of the control loop to their fusion reactor!

• Anima was recently appointed to the United Nations Scientific Advisory Board! We talk with her about her goals of bringing evidence-based viewpoints to policy, and how AI in scientific domains can improve people’s lives all over the world.

This episode has something for every AI or science nerd! Elegant math? ✅ Old school harmonic analysis? ✅ Fundamental developments in modern AI? ✅ Practical ways of modeling the physical world? ✅

Give it a watch!

Work that has blossomed into an entire field of AI forecasting, a theme we will cover more on the podcast in coming months.

This is an elegant and very technically deep paper. Excellent nerd snipe if you have a big block of time to study!

All emdashes were human generated.

We’ve lost count of how many adoption milestones have been passed since the original Rise of the AI Engineer post, but surely Andrew Ng, cofounder of Google Brain and Coursera among many other things, relaunching DeepLearning.ai with a focus on AI Engineering is a big one:

This was done via “an analysis of over 10,000 job postings; carrying out dozens of structured interviews with AI experts, hiring managers, and recruiters; gathering data through surveys; and synthesizing other online data” .

Here are the four most important AI engineering skills according to Andrew:

You can read his full post for more from the horses’ mouth, but we agree that “AI Engineering Skills” are broadly applicable to more than just those with the job title of “AI Engineer” and that is an insightful focus.

Commentary on the 4 skills:

• Building and deploying AI applications: “People who are skilled at building and deploying AI applications understand the building blocks of AI (such as LLMs, context engineering, RAG, agentic workflows, machine learning and deep learning) and, importantly, how to use statistical techniques to measure, steer, and govern AI systems so that they behave more predictably. A core skill in doing so is knowing how to drive disciplined evals and error analysis loops.”

  • yup. this part is closest to the traditional MLE/MLOps workflow, from “zero gradient” aka prompt engineering techniques, to harness engineering, to finetuning and beyond, all the way up to building your own agent lab as folks like Harvey are now doing

• Software engineering fundamentals. “Understanding software fundamentals allows you to recognize what tradeoffs even exist. This leads to better decisions in choosing your software stack, designing system architecture, designing your data store, testing, and so on. It also leads to much better outcomes than those for an inexperienced developer who vibe codes a solution without knowing the tradeoffs their coding agent is making — which will often be poor ones, because they don’t know what context to give their coding agent.”

  • yup. this part is closest to the traditional SWE workflow. LLMs reward expertise — they raise the ceiling (high skill devs) much more than they raise the floor (low skill vibecoders), though both are improved.

• Using coding agents. “Using agentic coding effectively is now a key skill for every developer. When you have this skill, you have a good mental model for how agents work. You understand their limitations and how to work around them, and are able to quickly steer them — knowing how much to intervene and how much to leave them alone — to build robust software without wasting excessive time or tokens. You also need to know how to work with a clear spec (and when not to bother doing so), orchestrate multiple agents that work together, and avoid pitfalls like risk an agent messing up your production database. Because agentic coding is evolving quickly, using coding agents skillfully means not only knowing cutting-edge practices, but also having routines to keep trying new tools and evolve your workflows as best practices change.”

  • When we first spoke about the 1000x AI Engineer in 2023, when Copilot was the only game in town, this was the part that was the least evident, but clearly on the horizon. Coding exploded in 2024-2026 culminating in the epic 0-$60B run of Cursor and the rise of Claude Code, Codex, Cognition, Cline and other coding powerhouses not starting with C. Being nimble here is a plus, just as much as being wary of tokenmaxxers with LLM psychosis.

• Shaping the build. “Effective AI engineering requires having product sense and understanding business context and customer goals, so you can participate in shaping and driving the build… Taking advantage of this opportunity requires knowing how to drive projects forward. For example, knowing when to quickly build an MVP to take to users for testing, and when to slow down and take longer in order to build more carefully.”

  • This is perhaps the only part of AI Engineering that wasn’t foreseen in the original essay; we added the AI PM track in World’s Fair 2024 and soon Design Engineering and other AIE adjacencies because the lines started to blur very quickly in both directions.

Overall, a great update to the DeepLearning.AI focus. Welcome Andrew and team!

AI News for 8/22/2026-8/24/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Agent Harnesses, Persistent Agents, and Enterprise MCP

• Harness design is becoming a primary optimization surface: Several posts converged on the idea that agent quality is increasingly shaped by the harness rather than just the base model. NVIDIA’s new evaluation work argues that structural checks on agent “skills” barely predict usefulness—scan scores correlate with judged quality at just Spearman ρ = 0.14—and proposes measuring “Skill Lift” instead: run the same task with and without a skill under identical conditions and score the delta in completed work (paper summary via @omarsar0). In parallel, a position paper on Anthropic-style harnesses argues enterprises should standardize on a single reusable coding-agent harness rather than bespoke orchestration graphs, claiming harness choice can matter more than model choice on enterprise work (summary via @dair_ai).

• Persistent and self-modifying agents are moving from concept to open-source implementations: @andykonwinski introduced Headlong, an open-source “microharness” for persistent agents that think continuously rather than only on request. The system stores trajectories as a DAG of jsonl files, keeps a self-guided inner loop running, and reportedly achieved an unattended self-debugging repair in 48 minutes; tradeoffs include $1–$2/hr background thinking cost and occasional self-inflicted failures. Complementing that, @omarsar0 described exo, a harness architecture for recursive self-improvement with an append-only event log, swappable executor, and snapshot/rollback-capable sandbox—explicitly designed so agents can rewrite prompts/tools/memory without being able to corrupt durable state. Together, these posts suggest the next wave of agent infra is about durability, forking, rollback, and continuous operation, not just better prompting.

• MCP is maturing into enterprise infrastructure: Anthropic rolled out enterprise-managed auth for MCP connectors, centralizing authorization through the organization’s identity provider so end users no longer perform per-tool OAuth for connectors like Asana, Atlassian, Canva, Datadog, Figma, Notion, Slack, and Supabase (announcement from @ClaudeDevs). Separately, the MCP roadmap highlights upcoming support for long-running workloads with streaming/server push, HTTP for local servers, progressive discovery for large catalogs, and standard identities/delegated permissions (roadmap summary via @_philschmid). This closes a notable gap between toy demos and auditable enterprise deployment.

Model Releases, Leaks, and Competitive Positioning

• Qwen3.8-27B continues to punch above its size class: In Code Arena: WebDev, Qwen3.8-27B landed at #9 overall with 1595 points, the only model in its size class in the top 10 and just six ranks behind Qwen3.8-Max (leaderboard update from @arena). It also ranked highly in consumer product, brand/marketing, and gaming categories. A related open-source derivative, Carnice-V3-27B, was released by @kaiostephens: a 27B Qwen-based, Hermes-agent SFT intended to fit on consumer GPUs (3090+), with merged BF16 and GGUF variants.

• Rumor cycle around unreleased frontier models intensified: Multiple tweets referenced apparent early access or traces of unreleased systems: EAP models labeled “claude-melon-eap” and “claude-marshmallow-eap” reportedly emphasized 3D/RL-style tasks and used many thinking tokens (demo by @Lentils80); @kimmonismus collected signs of new Claude models, Ox Alpha, Qwen 4, and a confirmed GPT Astra; and @eliebakouch claimed access to a model still in training with a public W&B run. Treat most of this as ecosystem signal rather than verified spec, but it’s notable how much of the discourse is now about pre-release access asymmetry rather than public launches—echoing @michael_nielsen, who warned that controlling access to unreleased models is becoming a source of power concentration.

• OpenAI and Anthropic positioning remains in flux: OpenAI developers announced GPT-5.6 availability in Kiro and a claimed ~82% cost reduction per successful Terminal-Bench 2.1 task in Kiro’s spec-driven environment for the Terra variant (announcement). OpenAI also cut GPT-5.6 Sol API pricing to $4/M input and $20/M output tokens (pricing note via @kimmonismus), with Arena updates showing Sol and Luna shifting the cost/performance Pareto frontier (@arena). On the Anthropic side, @tenobrus noted there has not been an unambiguous Opus-line upgrade in over six months, even as external testers reported stronger medium-reasoning results from new Claude variants (@kimmonismus).

Inference, Benchmarking, and Cost-Efficiency

• Tool latency overlap is emerging as a key harness-level speedup: @a1zhang introduced Speculative Programmatic Tool Calling (sPTC), which predicts safe tool calls during code generation and launches them early in a copy of the environment so execution overlaps with token generation. The reported improvement is modest so far—about 1.0–1.2×—but the mechanism is important: it shifts optimization from token-level decoding tricks to agent workflow pipelining. @lateinteraction compared it to CPU speculative execution, emphasizing that discarded work is acceptable if most guesses are right.

• Token accounting and benchmark hygiene remain messy: Several posts called out misleading reporting practices. @bnjmn_marie shared a DeepSWE run with 918.9M input tokens, clarifying many were cache hits, while @cHHillee bluntly argued that counting cached input tokens in “token usage” is “incredibly dumb.” On the eval side, @jmbollenbacher warned that when a quantized model exceeds the reference model on a benchmark, it may indicate overfitting the quant, not genuine improvement; @xeophon summarized the broader lesson: fixing the eval may matter more than hill-climbing it.

• Cost-normalized agent benchmarks continue to reshape model choices: Together AI reported that under a $100 budget, GLM-5.3 completed 5× more work than Fable 5 on DeepSWE, roughly 17 vs 3 solved tasks, despite similar first-try performance (tweet). @reach_vb similarly reported GPT-5.6 Sol Max at 72.7% on DeepSWE v1.1 for $6.47/task versus Fable 5 Max at 69.7% and $21.63/task. Cline also compared Ox Alpha vs Fable on a real bugfix and found both solved it, but Ox used roughly 3× fewer output tokens, suggesting a notably different post-training philosophy around re-verification versus acting on the first conclusion (comparison from @cline).

On-Device AI and Inference Systems

• Liquid AI + Artificial Analysis launched a serious on-device benchmark stack: @liquidai released Pipette, an open-source evaluation suite for on-device inference measuring quality, speed, latency, and memory across model + quantization + runtime + device combinations, with 10k+ verified results spanning 35 model classes, 7 quants, llama.cpp runtimes, and four devices. Artificial Analysis paired this with independent phone-scale intelligence evals on iPhone 17 Pro and Galaxy S26 Ultra (full thread).

• Phone-scale results highlight a different Pareto frontier than cloud evals: Under an 8 GB memory / 16K context framing, Nanbeige4.2-3B and LFM2.5-2.6B topped the average score at 63, with LFM2.5-2.6B much more efficient on iPhone (8.0s, 2.3 GB) than Nanbeige (21.4s, 4.0 GB). MoE designs such as LFM2.5-8B-A1B and Ling 3.0 Tiny are notable because they activate ~1B parameters/token, enabling sub-6-second responses on phone hardware. The evaluation also makes explicit that many “smart” reasoning models are poorly matched to mobile memory and latency constraints.

• Inference vendors are competing on agent-specific throughput, not just raw TPS: NVIDIA’s Groq 3 LPX was described as adding a dedicated token-generation accelerator to Vera Rubin, with a claimed 3,400 output tokens/s on Gemma 4 31B at 100K context in Artificial Analysis benchmarking (summary via @kimmonismus); Groq said it will be among the first to deploy it in production (announcement). Separately, vLLM published extensive AgentX 1.0 results on real multi-turn coding traces, emphasizing KV offload, prefix reuse, and prefill/decode disaggregation as the keys to high agentic throughput rather than classic single-turn serving metrics (@vllm_project).

Research, Papers, and Technical Education

• RL for LLMs and harness-native training remain hot: @cwolferesearch published a comprehensive reinforcement learning guide covering token-level vs completion-level formulations, PPO/GRPO variants, actor-critic methods, rubric-based RL, and agentic RL/world modeling. This coincides with growing attention on “harness-native” RL and agent environments, reflected in paper roundups like @TheTuringPost and discussion of papers such as Agent Lightning, LEGO-RL, EnvHarness, and SkillGate.

• Other notable research threads: Meta/USC’s Periodic Row-wise Muon extends Muon optimization to larger diffusion transformers by amortizing expensive Newton–Schulz updates while keeping gains over AdamW (summary via @iScienceLuvr); Adobe’s Latent Dynamics Reasoning learns extrapolative video world models from pixels by modeling latent state evolution instead of direct future prediction (paper via @_akhaliq, authors’ note); and Cartwheel reported compute-optimal scaling laws for human motion generation, arguing motion may become the fifth modality with Chinchilla-like scaling behavior (launch).

• Educational content worth saving: @fchollet recommended chapters 15–16 of Deep Learning with Python as one of the best accessible explanations of why dot-product attention works; @ProfTomYeh posted a detailed by-hand walkthrough of self-attention; and @mervenoyann announced a new home for llama.cpp docs, with upcoming material on speculative decoding, quantization, and coding agents.

Top tweets (by engagement)

• Hands-on product/UI performance: Anthropic said long answers in Claude web/desktop now stream ~4× smoother, with 9× fewer stalls and 4.5× shorter worst freezes on slower laptops (announcement).

• Fast image generation UX: @samdape showed a technique to make GPT image generation draw faster.

• OpenAI research culture: @gdb amplified a post from @kundan2510 praising OpenAI’s willingness to sustain long-term bets like full-duplex models.

• Learning resources: @fchollet recommending attention chapters from Deep Learning with Python was one of the highest-signal educational posts in the set.

• Enterprise MCP: Anthropic’s enterprise-managed auth for MCP connectors was one of the most consequential platform updates for production agent deployment (announcement).

• “Qwen 3.8 isn’t Opus level”: I re-ran the test. (Activity: 911): The image (link) shows the Deepseek/pi.dev-style coding harness being used with qwen3.8-27b in “Plan” mode for a C#/OpenGL ocean-rendering task, supporting the post’s claim that harness quality strongly affects observed model capability. In the author’s rerun, the same Qwen3.8 model and prompt failed under VS Code Copilot with a black screen, but succeeded under the alternate harness, reportedly using screenshot feedback and even generating a PNG decoder when vision was not enabled, producing waves, sky, sun, and underwater view in about 1 hour on an RTX 5090 running an ninfer-nvfp4 build with ~190k context at ~150–180 tok/s. Commenters largely agreed that the result demonstrates a large gap between “lazy” or sandboxed coding harnesses and agentic harnesses with execution/screenshot feedback. The original critic of Qwen3.8 conceded the prior conclusion was wrong and began retesting with pi.dev, noting fewer crashes and lower RAM use than VS Code/BYOM with llama.cpp.

  • A key technical theme was that harness quality can dominate perceived model capability: commenters noted Qwen 3.8 apparently implemented an “on the fly PNG decoder” and still produced working ocean shaders despite an initially misconfigured or limited execution setup. The discussion framed this as evidence that sandboxed tools like Copilot-style environments may under-represent what coding agents can do when given a proper runtime/test loop.

  • The original tester reported switching from VS Code + BYOM talking to llama.cpp to pi.dev after acknowledging the earlier harness was inadequate. They observed two concrete issues in the VS Code setup: driver errors after spawning the test executable, and random VS Code crashes while llama.cpp RocM 1200 build from Lemonade SDK continued running without output errors; by contrast, pi.dev had not crashed and used noticeably less RAM.

  • Several commenters compared agent harnesses such as pi.dev/OhMyPi, opencode, and local llama.cpp setups, with interest in how much autonomy the harness provides beyond a standard Claude-like chat workflow. Hardware constraints also came up: users speculated that a RTX 5090 or similar high-end local GPU setup, potentially with tools like Ninfer, could make local agentic coding workflows more viable without cloud subscriptions.

• New qwen3.8:27b on a 39k line C to single-file HTML / three.js port (Activity: 655): A one-shot agent benchmark attempted to port a 2.1 MB / 39k-line / ~600k-token single-file C procedural shooter (skill-issue) into single-file HTML/Three.js, where the source was >2× the available 262,144 token context. On RTX 6000 Pro 96GB with vLLM, FP8 weights and FP8 KV cache, Claude Code + Opus 5 produced the only “okay” port in 21 min / 1759 LOC, while qwen3.8:27b via hermes took 4h18m / 949 LOC and via codehamr (repo) took 1h40m / 1056 LOC, both judged “bad.” Commenters suggested that direct “convert this code” prompts cause models to re-imagine behavior; a more reliable pipeline is to first generate a transpiler, get runnable target-language output, then iteratively rewrite function-by-function against high-level pixel comparisons or low-level register/state references. Technical debate centered on whether the poor local results were due more to prompt/harness design, missing decomposition/tests, or inference setup: multiple commenters warned that FP8 KV-cache quantization may significantly degrade long-context performance and suggested rerunning without it. Others argued the wall-clock gap is expected because Anthropic can parallelize across far more hardware, and recommended measuring vLLM tokens/sec, planning first, splitting the monolithic C file into modules, and adding behavioral tests before porting.

  • Several commenters argued that direct “convert this codebase” prompting causes models to re-imagine the source rather than preserve behavior, even with frontier models. A suggested workflow is to first have the model help write a transpiler to the target language, then iteratively rewrite function-by-function while validating against high-level pixel comparisons or low-level register/value traces to reach pixel-perfect equivalence.

  • Multiple comments questioned the inference setup, specifically FP8 KV-cache quantization, Q8, and not running the full bf16 Qwen 27B model on an RTX 6000-class GPU. The concern was that KV-cache compression/quantization could introduce severe quality issues for a long-context code-porting task, and that rerunning without FP8 KV-cache or with full bf16 would better isolate model capability from quantization artifacts.

  • One technical explanation for the long runtimes was repeated KV-cache reprocessing in vLLM: if the engine releases the session cache, it may spend minutes recomputing prior context before generating any new tokens. A commenter suggested using LMCache to persist KV-cache in RAM, noting that cloud providers often avoid this latency by caching processed context across turns.

By AI standards today is a pretty quiet Friday, so it’s time to take a step back and reflect on what is really going on. If you read our 2025 reading list, and followed our coverage of Z.ai GLM, understood the Poolside pivot, been following our AI for Science themes, and tuned in to today’s Simile pod, you not only are one of the biggest readers of Latent Space, you will probably also arrive at this mental model:

Every year since 2022, one more component of the pipeline that produces machine intelligence has flipped from human-made to model-made. Not gradually, and not evenly — each flip has a patient zero, a paper or product where the synthetic version first became load-bearing at a frontier lab, and from there on, the future is simply here but not yet productionized.

And if you squint, what we used to call “synthetic data” and “synthetic rubrics” and “AI researcher” and “end to end RL environments” is just increasingly ambitious human simulation - 10% worse, but 100x cheaper and 10,000x faster.

The first thing to go synthetic was, counterintuitively, the judge. InstructGPT established the now-canonical trick: collect human preferences once, train a reward model, and let the policy optimize against the model rather than the humans. From the policy’s point of view, the thing dispensing approval was already an LLM. Constitutional AI pushed further and had the AI critique itself against a set of principles (RLAIF), and Lee et al. later showed AI feedback matching human feedback at a fraction of the cost. By the time LLM-as-judge became the default eval methodology (MT-Bench, AlpacaEval), the entire approval apparatus — reward, critique, evaluation — ran on models judging models.

Microsoft’s Phi series made the argument in its title: Textbooks Are All You Need. A small model trained on LLM-synthesized, textbook-quality data punched far above its parameter count, and phi-1.5 confirmed it wasn’t a fluke. Apple’s WRAP generalized the move: don’t just generate data, rephrase the entire web with an LLM, and pretraining gets roughly 3x more efficient. From there the pipeline industrialized — NVIDIA’s Nemotron-4 340B shipped with a permissively licensed synthetic data generation pipeline as a headline feature, and by 2025 reasoning-trace corpora (chains of thought generated by strong reasoners) had become a standard pretraining and mid-training ingredient. The corpus, the thing that was supposed to be the irreducibly human input, was now substantially model-written.

Weeks after ChatGPT’s API opened, Stanford’s Alpaca demonstrated that a $600 fine-tune on GPT-generated instructions could clone much of a frontier model’s behavior. Vicuna did it with shared conversations; Orca did it with rich teacher explanations rather than bare answers. The technique matured from imitation into a proper training discipline — on-policy generalized knowledge distillation fixed the train/inference mismatch — and reached its cultural peak when DeepSeek-R1 shipped a family of distilled models alongside the flagship, making “the teacher is a model” the default assumption for every small model release since.

Stages 1–3 made the inputs synthetic; stage 4 is where the loop starts closing on itself, because the model begins deciding what to learn next. The pieces existed early — Self-Instruct (models writing their own instruction sets) and STaR (models bootstrapping their own reasoning traces) are both 2022 — but the flip came when Meta’s Self-Rewarding Language Models and SPIN showed a model could generate its own tasks, judge its own outputs, and improve past the ceiling of its human preference data. Curriculum design — historically the most artisanal part of ML, the taste-driven choice of what to train on next — became something models do to themselves.

The assistance era (Copilot, then SWE-agents) kept a human choosing the experiments. The discovery era did not. DeepMind’s AlphaEvolve evolved genuinely new algorithms in 2025, and Sakana’s AI Scientist (now in Nature!) sketched the full paper-writing pipeline. The big moment was Karpathy’s autoresearch in March 2026: a deliberately minimal ratchet loop where a coding agent modifies a real LLM training setup, runs a five-minute experiment, keeps the change only if validation loss improves, and repeats overnight. His own extended run stacked 700 experiments into 20 kept improvements, cutting time-to-GPT-2 from 2.02 to 1.80 hours — real, transferable code changes found while he slept.

RL’s scaling bottleneck moved from the model to the environment: you need thousands of executable, verifiable, professionally realistic task worlds, and humans can’t hand-build them fast enough. We covered this recently in our z.ai / GLM-5.3 issue: Z.ai built pipelines that synthesize environments end to end — research agents mine real work patterns and convert them into long-horizon environments with hidden state, a judge agent attempts each task to confirm it’s solvable, and verifiers are synthesized without seeing the reference solution, then stress-tested with oracle, no-op, and unsolved-state checks until their binary reward is reliable enough to train on directly. As the GLM-5.3 release puts it, the entire environment, judging, and verification stack is synthetic all the way down. The same week, Ornith-1.5 shipped claiming end-to-end self-improvement — the model proposes its own tasks and generates its own RL rollouts. The gym, the referee, and the scoreboard are all models now.

If models can be the judge, teacher, and environment, the remaining human role in the loop is subject — the source of preferences, behavior, and demand. That’s the layer Simile is replacing. The lineage runs from Joon Sung Park’s Generative Agents (Smallville, 2023) through Generative Agent Simulations of 1,000 People, where digital twins built from two-hour biographical interviews reproduced their source humans’ survey and behavioral responses 85% as accurately as the humans reproduced themselves two weeks later.

The big hurdle to overcome: frontier models are trained toward being agent models, which makes them bad simulations of real people — so Simile post-trains on interviews, transaction data, and registered RCTs from the Open Science Framework specifically to recover human bias, inconsistency, and causal texture, and reports early scaling laws for simulation quality. With SimGym at Shopify simulating shopper trajectories and Tencent’s billion-persona approach at the crude end of the spectrum, the focus group, the user study, and the A/B test panel are becoming inference workloads.

The last row of the grid never quite turns red, and that’s the point. Poolside’s reverse-execuhire letter drew the line precisely: the world’s problems split into intelligence-bound ones (solvable by scaling cognition, soon commoditized by open weights) and experiment-bound ones, where “no amount of intelligence substitutes for real-world experimental feedback — 100,000 brilliant minds won’t cure cancer without a wet lab.” Their bet is that AI’s durable value accrues to whoever owns the experimental loop: AI as “the world’s most valuable scientific discovery engine.”

The bio side is running the same play from the other direction. CZ Biohub is imaging the Human Cell Atlas into a virtual cell — because in silico is roughly 1000x cheaper and faster than in vivo — and extending toward a virtual immune system, with Chai, Xaira, and Lila’s data-center-shaped labs filling in the AI-for-science stack. The physical world is the one component that can’t be fully synthesized — only compressed, cell by cell, into models.

Read the grid one more time and a second pattern appears underneath the first. Every flip was preceded by the same objection — model collapse, hallucination stacking, garbage in garbage out — and every flip happened anyway, at the exact moment a verification mechanism made the synthetic version trustworthy: aggressive filtering for Phi’s textbooks, judge-vs-judge agreement studies for LLM evals, unit tests and proof checkers for RLVR, oracle/no-op checks for z.ai’s verifiers, registered RCTs for Simile’s twins, the wet-lab loop for the virtual cell. The synthetic frontier doesn’t advance when generation gets better. It advances when verification does.

Which suggests where it goes next. The gray triangle remaining in the bottom-left of the grid — physical experiment, embodied ground truth — is exactly the region where verification is slowest and most expensive. The models learned to write, then to judge, then to practice, then to experiment. The remaining question of the decade is how much of reality they’ll need to touch — and how much they can get away with simulating.

10% worse, 100x cheaper, 10000x faster… and improving on ALL three dimensions fast.

One more time, with feeling:

AI News for 8/20/2026-8/21/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Stealth Models, Chinese Frontier Pressure, and DeepSeek’s Multimodal Push

• Ox Alpha became the day’s central mystery model: multiple builders reported unusually strong coding and agentic performance, with speculation converging on a Zhipu/GLM-family model—possibly GLM-5.3 Vision or a flash variant rather than a giant new base model. Reports included Theo saying it was “slaughtering” internal benchmarks, later merging 8 PRs based on its approval, and Kimmonismus citing >80% on 10 DeepSWE tasks vs 65% for Fable and 52% for GPT-5.6 Sol. Community distribution happened quickly via Hermes Agent/OpenCode/OpenRouter and Cline.

• The strongest technical read from the crowd was “post-training + infra > sheer size”: several independent takes argued Ox Alpha’s speed profile and style looked more like an efficient GLM derivative than a 1T+ monster. See Tim Dettmers on faster output / weaker partial prefill suggesting fewer active params, scaling01 arguing it may be a bigger teacher distilled into 5.3-class models, and teortaxesTex repeatedly narrowing toward GLM-5.3/5.4 Vision. That interpretation fits the broader thesis from a detailed GLM-5.3 analysis: gains came from the same 743B base as GLM-5.2, with improvements attributed to scaled post-training, better sandboxes, and SAO for finer credit assignment in long-horizon agent tasks, summarized in ZhihuFrontier’s thread.

• DeepSeek shipped the day’s most concrete release: DeepSeek-V4-Flash-Vision-Exp adds multimodal support while reportedly preserving V4-Flash text capability, with DeepSeek claiming multimodal-agent performance close to Opus-4.8. The rollout includes mixed text+image API support with 117–384 image tokens billed at Flash pricing and a new Files API for reusable uploads. This appears to have resolved at least part of the Ox Alpha confusion, with observers noting the mystery model had likely been a “blinded VLM” in some tests.

• Broader signal: Chinese labs are compressing the frontier on both price/perf and multimodal agents. That was reinforced by Kimmonismus arguing a rumored GLM-5.3 Flash-class Ox Alpha would force reactions from US labs, and by SemiAnalysis asking directly whether open models are catching up.

OpenAI, Codex, and Pricing/Usage Economics

• OpenAI cut GPT-5.6 Sol pricing by over 20% for three months in the API and credit-based products, announced by @OpenAI and @OpenAIDevs. This stacks with product-level promotions like Code’s 50% discount through Sept. 3 and Cognition’s note that on Devin, Sol is now effectively 76% off list through Oct. 3 after combining discounts. The move reads as both a utilization/efficiency update and a competitive response to cheap Chinese inference.

• Codex usage appears to be exploding: thsottiaux said Codex hit 20M active users and granted all Codex and ChatGPT Work users a “banked reset”, quickly amplified by Theo and Kimmonismus. There were also anecdotes of the product exceeding expected limits, e.g. Theo claiming a long-running goal consumed ~$800 in tokens after he’d already hit 0% remaining.

• OpenAI added better spend controls: teams can now track usage and spend by API key and set hard monthly org/project limits, useful as agentic workloads become less predictable and more concurrent.

• Market sentiment shifted back toward OpenAI in startup tooling: immad suggested Anthropic’s startup share may have peaked in Q1, with Sol and Codex “turning the tide back”. In parallel, some users framed Sol as the current best all-around model for coding/math/agentic tasks, e.g. DimitrisPapail’s “most capable model available for almost every task” take.

Agents, Harnesses, and the Shift Toward Environment-Centric Training

• The center of gravity is moving from prompts to environments: the most substantive thread here was again GLM-5.3’s sandbox-scaling interpretation: same base model, but better long-horizon performance from richer executable environments and SAO-style counterfactual credit assignment. This aligns with other work shared today: Google’s EnvHarness / EnvRigger adapts static environments using a plugin layer and policy-diagnosed reshaping, improving held-out performance by up to 9 points with 9.8% fewer execution steps.

• Benchmarks are getting more task-specific and harder: FACET creates executable terminal tasks from agent skills and validated 6,078 tasks; SWE-bench Science introduces 119 scientific software tasks where even Claude Code + Opus-5 is under 50% pass@1; CADBench finds top models at only 24.6% pass rate across realistic Fusion 360 tasks; and AI4AI-Bench tests recursive self-improvement over 10 research repos, with the best model only at 0.288 average score.

• Agent infra is getting more productized: GitHub rolled out collaborative agent workflows into Slack and Teams, with Slack describing Devin-like flows where the agent picks up tasks, opens PRs, and loops in design inside the shared channel (example). There’s also continued work on agent runtimes: nac v0.1.3 added sandboxed git worktrees, session organization, and vision-aware image reading; Hermes Agent made Ox Alpha available and exposed “Blank Slate mode” plus automatic skill pruning; and OpenHands switched its free default to Kimi K3.

• Inference-serving correctness in RL got an important systems result: vLLM’s IsoExec addresses rollout/training logprob mismatches caused by floating-point non-associativity, enforcing bitwise parity across TP/EP/SP layouts. On Qwen3.5-35B-A3B with DAPO on 8xH100, logprob diff reportedly dropped from 1.6e-2 to 6.7e-7 at 25.3% overhead.

Research Highlights: Routing, Recirculation, and Robotics

• Inference-time architecture ideas: a DeepMind paper on Recirculation got attention for feeding contextualized deeper-layer activations back into earlier processing at inference time, without retraining. The summary cited improvements including -60% contextualization errors, -23% perplexity, and +21% GSM8K in reported experiments (thread).

• Model routing got a more principled treatment: Pandora’s Router from Google DeepMind frames routing as an optimal search problem with costly inspection, rather than assuming routing estimates are free. The claim: it matches exhaustive-estimation quality while calling expensive estimators less often, including settings with specialist LLMs and variable inference-time reasoning.

• Robotics had two strong updates: NVIDIA AVO reportedly solved all 183 levels across 25 public ARC-AGI-3 environments, though François Chollet cautioned this is the public demo/tutorial set rather than the full benchmark. Separately, Jim Fan introduced T-Rex, a tactile-reactive dexterous manipulation stack with asynchronous vision/tactile experts plus what’s described as the largest open tactile dataset yet: 50 hours / ~5,500 episodes / 22-DoF hardware.

Infrastructure, Compute, and Open Models

• Open-model access and local inference continue improving: Ollama welcomed AT&T to open models and added Kimi K3 to Pro/Max subscriptions. Yuchen Jin highlighted UC Berkeley’s FreeToken: 753B GLM-5.2 at 14.9 tok/s on a single RTX PRO 6000 and Qwen3.6-35B at 39.3 tok/s on an 8GB RTX 4060 laptop, claiming 2–4x Ollama throughput on consumer GPUs.

• Compute remains the hard constraint: multiple operators argued inference capacity is tightening, not loosening—see saranormous on good AI companies being growth-limited by compute and Andrew Carr on self-hosting GPUs and still having more experiments than available capacity. This makes model efficiency, scheduling, and lower latency/tokens-per-dollar improvements strategically important.

• Open-source training transparency is also scaling: Percy Liang announced Marin 535B-A23B has started training, targeting 18.75T tokens on 11× GB200 NVL72 over ~3 months, with the run kept open as usual.

Top tweets (by engagement)

• DeepSeek launches V4-Flash-Vision-Exp — the clearest product release of the day, and likely the biggest practical shift for multimodal agents.

• OpenAI cuts GPT-5.6 Sol pricing by >20% — meaningful pricing pressure at the frontier.

• Codex reaches 20M active users; banked resets for users — notable product growth signal.

• NVIDIA AVO hits 100% on ARC-AGI-3 public environments with Chollet’s caveat — impressive, but benchmark interpretation matters.

• David Sacks on Harvey using open-source Kimi K3 for legal SOTA at lower cost — strong argument for why restrictions on open models would mostly hurt US application-layer companies.

• Qwen3.8-27b has the highest level of “agency” I’ve ever seen in a local model (Activity: 1334): The post claims Qwen3.8-27B running locally on a single RTX 3090 with Unsloth Q4_K_S quantization, q8 KV cache, and 150k context performed unusually capable autonomous agent workflows: using Playwright plus existing SSO/session cookies to navigate university systems and retrieve a course schedule, and separately processing a social-media video via download, frame extraction, transcription with Whisper, and image enhancement. The image is a screenshot of the model reporting use of an Outlook/OWA Playwright profile, Microsoft “stay signed in,” and Duo browser-trust cookies to access school systems, making the technical significance less about raw model quality alone and more about local LLM tool-use agency plus high-risk credential/session handling. Comments were impressed but cautious: one user explicitly worried about giving an agent enough access to potentially perform destructive actions like withdrawing from university, while others framed it as evidence that advanced local agentic systems are already here but unevenly distributed.

  • A commenter asked for implementation details behind the reported agentic behavior of Qwen3.8-27B, specifically the agent harness used—e.g. Claude Code, Hermes, or another framework—and how tools were exposed via MCP servers, browser tools, Python, filesystem access, etc. They also asked what inference backend served the model, such as llama.cpp, and how it was able to autonomously download video, extract frames, and install Whisper.

  • There was technical concern about the reliability of the referenced quantization: one commenter noted surprise that “the quant is that good,” while mentioning reports of looping behavior at that quant. This suggests the model’s apparent agency may be sensitive to quant level and runtime behavior, especially for long-horizon tool use.

  • A safety-oriented thread questioned giving local agents broad system access, with one commenter saying they would not trust agents like Sol or Fable with unrestricted permissions. The concern was not about local inference itself, but about autonomous agents with enough privileges to perform impactful real-world actions such as modifying accounts or workflows.

• Qwen3.8-27B took a serious hit to knowledge vs 3.6 (Activity: 779): The post reports that Qwen3.8-27B / Qwen3-8-27B appears to regress vs Qwen3.6-27B / Qwen3-6-27B on offline, no-tool-call factual recall: the author’s private “mildly obscure” trivia/prepper benchmark showed failures across quantization levels and sampling settings, consistent with lower scores on Artificial Analysis’ Omniscience knowledge benchmark. The reported degradation is specifically about knowledge stored in weights and hallucination/fact recall under airgapped inference, not coding/tool-use; commenters note Qwen3.8 is stronger at tool calling, web search/fetch workflows, coding, and agentic behavior. Commenters broadly frame this as an intentional tradeoff: newer Qwen 3.x models may be optimized for coding/agentic tasks rather than being “mini Google” factual stores, with Gemma 4 suggested as a better fit for trivia/random-fact recall. One user confirmed regression on niche visual/history/geography tasks such as stamp or old-photo location identification when web tools are disabled, but considered the tradeoff acceptable given improved tool use.

  • Several commenters frame Qwen3.8-27B as shifting away from memorized factual recall toward coding, tool use, and agentic workflows. One user testing a niche “knowledge” workload—stamp identification and historical/location inference from old photos—reported that with web search/fetch tools disabled, Qwen3.8 performs worse than Qwen 3.6, but becomes more useful when allowed to retrieve information externally.

  • The perceived regression is described as an intentional tradeoff for a 27B model: reduce obscure memorized knowledge while preserving enough reasoning ability for problem solving and agents. Commenters suggest using models like Gemma for factual/trivia-heavy tasks, while reserving Qwen3.8 for coding/tool-calling scenarios where users report stronger performance.

  • One technical speculation was that future models may separate base reasoning from domain knowledge via neural plugins/LoRA-like modules: e.g., adding Japanese-language capability or finance-domain expertise as attachable components rather than baking all knowledge into the base model. This was proposed as a way to keep base models smaller or more specialized while allowing opt-in domain expansion.

• Qwen 3.8 27b - PI AGENT vs OPENCODE (Activity: 510): The author compares PI Agent vs Opencode using a local llama-server backend on an RTX 3090 with Qwen3.8-27B-Q4_K_M.gguf, ctx-size=100000, flash-attn=on, n-gpu-layers=99, DeepSeek-style reasoning, and a vision mmproj module. They report PI Agent producing better outputs, using fewer tokens, avoiding Opencode’s apparent 32k output-token ceiling/freezing behavior, and delaying context compression until ~90k tokens vs Opencode starting around ~67k when total context is 100k; they also recommend enabling vision so the model can visually assess generated outputs, with CPU/RAM offload acceptable for screenshot evaluation latency (~3s vs ~0.3s GPU). The test was inspired by a prior LocalLLaMA post about generating a bouncing-ball animation: reddit.com/r/LocalLLaMA/comments/1j7r47l/.... Commenters questioned whether a one-shot HTML/animation task is a meaningful harness comparison and suggested multi-step tool-heavy workflows instead. Another user reported PI + local Qwen3.8-27B felt competitive with Claude Code on a roughly one-hour aurora-prediction app build, though both models judged Claude’s initial result slightly better before PI iterated.

  • A commenter argues that one-shot HTML generation is not a meaningful benchmark for comparing PI Agent vs OpenCode; they suggest using multi-step tasks with extensive tool calls to evaluate the harnesses’ planning, editing, and recovery behavior.

  • One user reports a subjective head-to-head between local Qwen3.8-27B running in PI and Claude Code on building an aurora predictor app. They felt runtime was similar; both agents judged Claude’s first result slightly better, but after asking PI/Qwen to upgrade its version, the user preferred Qwen’s presentation. The resulting app reportedly integrated multiple satellite instruments and provided 30–60 minute aurora warnings.

  • Another commenter suggests adding the DeepSeek harness to the comparison, implying the evaluation should cover more agent runtimes than just PI Agent and OpenCode.

• DeepSeek-V4-Flash-Vision-Exp (Activity: 722): The image is a technical benchmark table for DeepSeek-V4-Flash-Vision-Exp (image), comparing it against DeepSeek V4-Flash-0731 and Opus-4.8 on text-agent and multimodal-agent evaluations. It shows broad gains over the prior DeepSeek Flash release, including 83.9 on Terminal Bench 2.1, 75.9 on Toolathlon-Verified, and 64.3 on Chartography, while Opus-4.8 still leads many text-heavy benchmarks; Vision-Exp appears more competitive on multimodal tasks such as Agents’ Last Exam and ZeroBench. The main technical reaction was that the reported DeepSWE improvement of roughly +4 points over 0731 is considered unusually large. Other comments were mostly hype or tribal reactions rather than substantive analysis.

  • DeepSeek’s announcement says DeepSeek-V4-Flash-Vision-Exp is live via the DeepSeek API with model='deepseek-v4-flash-vision-exp', matching DeepSeek-V4-Flash text capabilities while adding multimodal input. The model supports Chat Completions, Messages, and Responses APIs, with mixed text+image inputs via base64, external URLs, or the Files API; images are billed as up to 384 tokens each at V4-Flash pricing. Docs: vision guide.

  • Several comments focused on benchmark movement: one noted DeepSWE reportedly improved by 4 points from 0731 to Vision-Exp, while the announcement claims a “major leap” on multimodal agent benchmarks, bringing performance close to Opus-4.8. The technical implication discussed is that Vision-Exp may retain V4-Flash’s agent/reasoning/world-knowledge text performance while substantially improving visual-agent workflows.

  • DeepSeek also launched a Files API for image reuse: users can upload an image once, reference it by file_id, and avoid resending image payloads across requests, reducing bandwidth overhead. One commenter asked whether the model weights would be open and noted they could not yet find them on Hugging Face, implying that availability appears API-only at the time of discussion. Files API docs: files_api.

• The boring way to run Deepseek V4 Flash-0731 130-150 tks - 16x5060ti 16GB over 2 PLX88096 switches (Activity: 621): The image is a terminal GPU-monitoring dashboard validating the post’s unusual 16× RTX 5060 Ti 16GB inference rig: all GPUs are visible, nearly full at roughly 15.2–15.7 GiB / 15.9 GiB VRAM, and assigned to vLLM worker processes for DeepSeek V4 Flash-0731. The setup uses two Broadcom/PLX PEX88096 PCIe switch islands with patched NVIDIA 610.43.02-p2p, Resizable BAR/BAR1 set to 16 GiB per GPU, and custom all-reduce/DSpark pipeline parallelism; reported throughput is about 100–150 tok/s single-user generation depending on TP/PP layout, with concurrency scaling up to 727 output tok/s aggregate for TP4/PP4 at 16 users. The image also shows the tradeoff/oddity of the build: the GPUs appear connected at PCIe Gen1 x8 and are mostly idle at the captured moment despite high VRAM residency, implying the screenshot is more a topology/memory residency proof than a live utilization benchmark. Commenters were less focused on the benchmark table and more on the physical absurdity of the build, asking for “a photo of the setup” and calling it a “mad setup.” One notable skeptical/funny technical reaction was that “a little vibe coding” likely hides substantial custom distributed-inference work.