a good ship from Qwen.

Congrats to Pete Steinberger on joining OpenAI, as we predicted. Not much else to add there so we won’t.

Today’s headliner is Qwen 3.5, which followed the other Chinese model labs like Z.ai and Minimax and Kimi in refreshing their leading models, but unlike the first two, Qwen 3.5 is in the same weight class as Kimi, 400B with about a 4.3% sparsity ratio instead of Kimi’s more agressive 3.25%. They do not claim SOTA across the board, and most notably not across coding benchmarks, but make solid improvements compared to Qwen3-Max and Qwen3-VL.

Native Multimodality and Spatial Intelligence are headline features of the model and we encourage clicking over to the blog to check out the examples, as there isn’t much else to say - this is a very welcome headline model refresh from China’s most prolific open model lab, and probably the last before DeepSeek v4.

AI Twitter Recap

Alibaba’s Qwen3.5 open-weight “frontier MoE” drop (and the inference/infra fallout)

• Qwen3.5-397B-A17B release: Alibaba shipped Qwen3.5-397B-A17B, positioned as the first open-weight model in the Qwen3.5 series: native multimodal, “thinking and non-thinking modes,” hybrid linear attention + sparse MoE, “large-scale RL environment scaling,” 201 languages, Apache-2.0 (official announcement; also echoed by @JustinLin610). They also clarified that Qwen3.5-Plus is the hosted API version of the same base model, with 1M context (vs model-native 256K) plus search/code interpreter integrations (clarification).

• Architecture + KV-cache implications: Community discussion focused on Gated Delta Networks / “GatedDeltaNet” + sparse MoE as the reason inference can stay tractable at long context. vLLM shipped day-0 support and highlighted 397B total, 17B active, multimodal, and throughput/latency advantages (vLLM recipe). A concrete KV-cache back-of-the-envelope suggested only ~31KB/token and ~8.05GB KV at 262K context in BF16 (and ~4GB in FP8) due to few KV heads + many gated-delta layers (KV math).

• Deployment reality: huge weights, but surprisingly runnable: Despite “~800GB BF16” scale, people reported local runs via MLX/Q4 on Apple Silicon (e.g., ~225GB RAM mentioned) (mlx report; awnihannun demo). Unsloth pushed “run 4-bit on 256GB Mac/RAM” guidance and claimed parity vs top closed models (marketing claim, but important for adoption) (Unsloth). Ollama put it on their cloud quickly (Ollama).

• Benchmarks + “agentic RL” vs efficiency questions: Early takes called it a step up over Qwen3-Max and prior Qwen VL models, with notable vision improvements; others asked for “reasoning efficiency” evidence rather than raw scores (scaling01). teortaxesTex noted it surprisingly outscores Qwen3-Max-thinking on some reported harnesses and speculated improvements due to agentic RL (commentary). At the same time, there were “black-box eval” critiques and task-specific failures (e.g., SVG / “Vending-Bench” style tests) (Vending-Bench claim; SVG comparisons).

• Pricing drama: Multiple posts argue Alibaba’s API pricing is high/weird given inference efficiency claims, with comparisons to Kimi/GLM offerings (pricing complaint; more). This became a recurring theme: “great model, unclear serve-cost story.”

Open agents, “harness engineering,” and the OpenClaw → OpenAI saga

• OpenClaw as a proof-point for one-person leverage: The OpenClaw story is framed as emblematic of “one-person team + coding agents” shipping something world-shifting fast, culminating in Peter Steinberger joining/acquired by OpenAI (Yuchenj_UW). This thread also triggered broader discussion of how OpenAI might handle open source post-acquisition.

• Anthropic/open-source tensions: A major discourse cluster criticized Anthropic’s posture toward open source and OpenClaw usage, with claims that restrictions/blocks pushed developers toward other models/providers (ThePrimeagen; Teknium). Others downplayed the strategic impact (“could be vibe-coded in a week”) while acknowledging reputational costs in OSS circles (scaling01). Separately, Anthropic announced a major operational expansion: Bengaluru office and noted India as Claude.ai’s second-largest market (Anthropic).

• Harness as the real moat: Several tweets converge on a practical thesis: agents aren’t just models; the “harness” (tooling, context management, lifecycle, skills, evaluation/observability) is compounding infrastructure and increasingly the differentiator. See Ben Burtenshaw’s definition of harness as an “OS” around the model, and the idea that proprietary agents feel better partly because models are trained on their harness patterns (ben_burtenshaw). This is echoed by practitioners building agent systems: “building a good harness is hard and compound over time” (brivael).

• Lightweight agent alternatives: Alongside “big harness” thinking, there’s interest in minimal agent stacks: PicoClaw and nanobot are pitched as drastically smaller alternatives to OpenClaw, supporting multiple model backends and MCP/vLLM (TheTuringPost).

• Agent observability/evals becoming table stakes: LangChain/LangSmith pushed the message that for agents, traces are the new “stack trace,” and debugging requires observability-first tooling (meetup; tracing plug-ins). This aligns with broader complaints that current agent behavior lacks determinism and requires babysitting.

OpenAI/Codex usage surge, sub-agents, and security hardening

• Codex adoption claims: Sam Altman reported Codex weekly users tripled since the start of the year (sama). Multiple community posts describe a “big leap” in Codex 5.3, especially via parallelism/sub-agents (gdb; “agents are up”).

• Sub-agent configuration + model-tier tradeoffs: Practical tip: increasing Codex sub-agents by editing config (e.g., max_threads = 24) was shared as a Pro-user tweak (Hangsiin). Meanwhile, at least one user reported 5.3-codex-spark is faster but “dumber” than full 5.3 for real work (giffmana).

• Lockdown Mode for ChatGPT: OpenAI introduced Lockdown Mode to reduce prompt-injection and data exfil risks by disabling/altering tool behaviors (cached browsing, reduced web interaction), first for Enterprise/Business with consumer later (cryps1s). This is notable as a product-level acknowledgment that tool-enabled LLMs expand attack surface, and that some orgs want deterministic, restrictive controls even at capability cost.

• Scientific-claim scrutiny: A thread raised reproducibility concerns about an OpenAI physics result attributed to GPT-5.2, arguing journals should require transcripts/tooling details if secret models are used (lewtun). Kevin Weil pointed to more explanation from the involved physicist (kevinweil), and gdb posted a “how it came to be” follow-up (gdb).

China’s “holiday model wave”: Qwen3.5, GLM-5, MiniMax M2.5, Seed/Seedance—and robotics acceleration

• Chinese New Year as release season: Multiple posts frame CNY as the new “model drop week,” with a stack including Qwen3.5, GLM-5, MiniMax M2.5, and anticipation for DeepSeek-V4 (iScienceLuvr; Yuchenj_UW roundup).

• MiniMax M2.5: throughput + RL signal efficiency: SemiAnalysis reported M2.5 sustaining ~2500 tok/s/GPU throughput under certain TTFT constraints on 8×H200 with vLLM (SemiAnalysis_). MiniMax emphasized per-token process rewards as better RL signal utilization and cost efficiency, and celebrated broad API/partner availability (MiniMax_AI).

• ByteDance Seed/Seedance & AI film: Seedance 2.0 became a cultural moment via a Jia Zhangke short produced with the model (FrankYan2; EHuanglu). The meta-point: video generation is moving from “toy demos” toward “filmmaker workflow,” and some viewers note video outputs feel less “aesthetic-guidance uncanny” than image gen (jd_pressman).

• Robotics: Unitree + broader China lead narrative: Posts highlighted Unitree humanoids at the Spring Festival Gala and broader claims of rapid Chinese robotics progress (HumanoidHub; kimmonismus). teortaxesTex argued we’re past “Potemkin” skepticism—entire sectors (not just outliers) are real, especially robotics (teortaxesTex).

• Compute supply chain signals: Western Digital reportedly sold out much of 2026 HDD capacity due to enterprise demand, with some AI customers booking out to 2027/2028 (kimmonismus). Separately, NVIDIA’s GB300 NVL72 was touted as ~50× higher performance/MW and ~35× lower cost/token vs Hopper (vendor-claimed) (kimmonismus).

Research/engineering threads engineers actually use (agents, RL, interpretability, and eval hygiene)

• Multi-step tool use is still brittle: SciAgentGym shows success collapsing as tool-interaction steps increase; data synthesis over tool dependency graphs (SciForge) improved an 8B model on scientific workflows (dair_ai). This matches day-to-day agent pain: execution reliability is the bottleneck, not single-step reasoning.

• Adaptive reasoning depth for agents: CogRouter dynamically varies “cognitive depth” step-by-step; reported to beat GPT-4o with 62% fewer tokens on agent benchmarks (as summarized) (omarsar0).

• Rubric-based RL (RLVR beyond verifiable domains): A substantial writeup on rubric-based RL traces the path from LLM-as-judge to structured rubrics and offers practical tips across 15+ papers (cwolferesearch).

• Interpretability objective: MonoLoss proposes a plug-in objective to encourage monosemantic activations in SAEs across CLIP/SigLIP2/ViTs, improving “MonoScore” for many latents (iScienceLuvr).

• Benchmark contamination / “local generalization”: There’s renewed emphasis that benchmark gains can be confounded by training-data expansion and semantic near-duplicates. A proposed decomposition: benchmaxxing vs usemaxxing vs hidden interpolation vs true OOD generalization (g_leech_). This rhymes with Lucas Beyer’s earlier vision-data de-dup experience and the difficulty of doing this “properly” in language (giffmana).

• WeirdML time horizons: A METR-inspired “time horizon” estimate for WeirdML tasks suggests frontier model horizons from ~24 minutes (GPT-4) to ~38 hours (Opus 4.6) and a ~5-month doubling time (htihle), echoed as broadly consistent with METR-like estimates (scaling01).

Meta themes: open vs closed, labor/education impacts, and “taste” as a new bottleneck

• Open model momentum vs concentration risks: A recurring sentiment is that open models reduce power concentration and keep multiple AGI pathways available (TuringPost clip). In parallel, debates rage over ToS constraints (e.g., Anthropic limiting surveillance/weapons use) and whether that makes a vendor a “supply chain risk” (RyanPGreenblatt; kimmonismus Axios summary).

• Workforce disruption timelines: Ryan Greenblatt argued mass unemployment is “overrated in 2 years, underrated in 7,” with the key inflection being full automation of AI R&D (after which human cognitive labor value collapses quickly) (thread start).

• Education/skills anxiety: Claims that degrees may become obsolete before students graduate (popularized via a newsy summary tweet) reflect broader uncertainty (kimmonismus). There’s also a warning that AI coding tools can reduce skill mastery in controlled studies (via an Anthropic research link, summarized) (dl_weekly).

• “Taste” and verification as core skills: This set strongly emphasizes that as models/agents scale, taste (choosing good problems/solutions) and ability to verify (detecting subtle wrongness) become the scarcest human differentiators—explicitly labeled as “a new core skill” (gdb; Yuchenj_UW). Karpathy extends this into programming languages/formal methods: translation and refactoring will dominate, and we may rewrite much of software repeatedly; languages “optimal for LLMs” become an open question (karpathy).

Top tweets (by engagement)

• SF walkability discourse: @paularambles

• Anthropic Bengaluru office / India as #2 market: @AnthropicAI

• Qwen3.5-397B-A17B release (Apache-2.0, multimodal MoE, 17B active): @Alibaba_Qwen

• PL/FM + LLMs reshape software translation/rewrite: @karpathy

• “Anthropic hate for open source” viral take: @ThePrimeagen

• Codex growth claim: @sama

AI Reddit Recap

/r/LocalLlama + /r/localLLM Recap

1. Qwen 3.5 Model Release and Performance

• Qwen3.5-397B-A17B is out!! (Activity: 973): Qwen3.5-397B-A17B has been released on Hugging Face, featuring a 397 billion parameter model with a native context length of 262,144 tokens, which can be extended up to 1,010,000 tokens. This model is part of the Qwen series, known for its large-scale language capabilities. Additionally, a GGUF version is available here, which may offer optimized performance for specific use cases. There is anticipation and curiosity in the community about the model’s performance, with users eager to test its capabilities.

  • The Qwen3.5-397B-A17B model boasts a native context length of 262,144 tokens, which can be extended up to 1,010,000 tokens. This is a significant improvement in handling larger contexts, making it suitable for more complex tasks that require extensive input data.

  • The decoding throughput of Qwen3.5-397B-A17B is reported to be 3.5x to 7.2x faster than its predecessor, Qwen3-235B-A22B. This increase in throughput suggests substantial improvements in processing efficiency, which could lead to faster response times and reduced computational costs for large-scale applications.

  • A user has shared a link to the GGUF version of the model on Hugging Face, indicating that the model is available for download and experimentation. This accessibility allows for broader testing and integration into various projects.

• Qwen3.5-397B-A17B Unsloth GGUFs (Activity: 663): Qwen3.5-397B-A17B is a newly released model by Alibaba with 397 billion parameters, designed for multimodal reasoning. It is capable of running in 3-bit on a 192GB RAM Mac or 4-bit (MXFP4) on an M3 Ultra with 256GB RAM. The model is positioned as competitive with Gemini 3 Pro, Claude Opus 4.5, and GPT-5.2 in terms of performance across benchmarks like instruction following, multilingual knowledge, and video reasoning. The release includes dynamic GGUFs for flexible deployment, and a guide is available for running the model on various hardware configurations. More details can be found on Hugging Face and Unsloth. Commenters are impressed by the model’s size and capabilities, noting the 397 billion parameters and the fact that only 17 billion are active at a time. There is curiosity about how AutoRound might enhance the model’s performance.

  • The Qwen3.5-397B-A17B model is noted for its verbosity, as demonstrated by its extensive internal dialogue when generating a simple greeting response. This verbosity could be indicative of the model’s complex decision-making process, which might be beneficial for nuanced tasks but could also lead to inefficiencies in simpler interactions.

  • A user expressed curiosity about the performance of the AutoRound feature with the Qwen3.5-397B-A17B model, particularly given that only 17 billion parameters are active. This suggests a focus on optimizing performance while managing computational resources effectively, which is crucial for deploying large models in practical applications.

  • There is a discussion about the comparative performance of UD-Q4_K_XL and MXFP4 formats, with a user noting the lack of benchmarks directly comparing the two. This highlights a gap in available performance data, which is essential for making informed decisions about model deployment and optimization strategies.

2. Local LLM Challenges and Innovations

• Why is running local LLMs still such a pain (Activity: 243): The post discusses the challenges of running local Large Language Models (LLMs) like Ollama and Llama on personal hardware, highlighting issues such as installation failures and resource constraints when dealing with models larger than 7B parameters. The user expresses frustration over the complexity of self-hosting solutions, which often require advanced technical knowledge in areas like Docker and Kubernetes, and the lack of privacy-friendly yet functional alternatives to services like OpenAI’s ChatGPT. Commenters note that achieving ChatGPT-level functionality locally is inherently difficult due to the significant hardware requirements, suggesting that while tools like LM Studio, Ollama, or Lemonade can be installed easily, performance is heavily dependent on having a powerful GPU or NPU. They emphasize that without substantial investment in hardware, local LLMs will be slow, and achieving full ChatGPT functionality may not be feasible without using a remote provider.

  • No_Clock2390 highlights that running local LLMs is feasible with the right hardware, mentioning tools like LM Studio, Ollama, and Lemonade that can be set up quickly. However, performance is heavily dependent on hardware capabilities, particularly the presence of a GPU or NPU. For instance, running Ollama on an Intel N100 is possible but results in slow performance due to CPU limitations.

  • Total-Context64 emphasizes the cost barrier in achieving ChatGPT-like functionality locally, pointing out that significant investment in hardware is necessary unless one opts for a remote provider. This underscores the challenge of replicating high-performance LLMs without substantial resources.

  • HorribleMistake24 suggests using lmstudio for beginners, which assists in determining model compatibility with available GPU VRAM. They also mention leveraging a ChatGPT subscription for setup assistance via Codex in VS Code, illustrating a practical approach to overcoming setup challenges by integrating AI tools into the development process.

3. MiniMax-2.5 and OpenClaw Discussions

• Anyone actually using Openclaw? (Activity: 1615): The Reddit post questions the authenticity of Openclaw’s popularity, suggesting it might be a result of manufactured social media marketing, especially after OpenAI’s acquisition of Openclaw. The post references a suspicious growth graph here. Openclaw is described as a tool that connects various APIs and MCP servers, but lacks innovation, according to user experiences. The acquisition by OpenAI for 10 billion is viewed skeptically, with comparisons to the hype-driven nature of the crypto market. Comments suggest skepticism about Openclaw’s marketing tactics, with some users describing it as ‘vibe coded’ and lacking in unique functionality. There is interest in alternatives like Ironclaw, indicating a desire for more robust solutions.

  • Skystunt mentions that Openclaw is essentially a compilation of existing technologies, connecting various APIs and MCP servers, without offering any groundbreaking features. This suggests that its perceived value might be inflated, as it doesn’t introduce new capabilities but rather integrates existing ones.

  • dgibbons0 highlights the poor configuration quality of Openclaw, describing it as ‘vibe coded’. This term suggests a lack of professional polish or robustness in its setup. The commenter also expresses interest in exploring Ironclaw, a related project, indicating that the concept of integrating chat with AI engines is appealing despite Openclaw’s shortcomings.

  • TurnUpThe4D3D3D3 raises concerns about the financial implications of using Openclaw, noting that it has a default 30-minute heartbeat that incurs API costs each time it runs. This could lead to significant expenses over time, potentially amounting to several dollars per week, which might not be immediately apparent to users.

• You can run MiniMax-2.5 locally (Activity: 784): The image provides a detailed guide on running the MiniMax-2.5 model locally, highlighting its state-of-the-art performance in coding, agentic tool use, and office tasks. The model features 230B parameters with 10B active, a 200K context window, and requires 457GB of memory in its unquantized bf16 form. The use of Unsloth Dynamic 3-bit GGUF significantly reduces the model size to 101GB, a 62% reduction, making it more accessible for local deployment. The guide also includes links to the official documentation and GGUF models on Hugging Face. Comments reflect skepticism about the accessibility of running such a large model locally, with users humorously noting the high hardware requirements and costs associated with deploying the model.

  • Ug1bug1 mentions that the MiniMax models, including the Q3_K_XL, perform well on their Strix Halo setup, which has 128GB of RAM. This suggests that the model’s performance is satisfactory on high-end hardware, indicating that substantial memory is a key requirement for running these models effectively.

Less Technical AI Subreddit Recap

1. AI Model Releases and Benchmarks

• What are you looking forward to? (Activity: 954): The image is a tweet from CHOI (@arrakis_ai) announcing the imminent release of several AI models: DeepSeek V4, Gemini 3.1 Pro, GPT 5.3, Sonnet 5, and a “Mystery model.” The tweet highlights the rapid acceleration of AI development timelines, suggesting these releases are expected within days. This indicates a significant period of advancement and competition in AI model development, with potential impacts on various applications and industries. One comment expresses skepticism about the release of Sonnet 5, referencing a previous rumor that turned out to be about Opus 4.6 instead. Another comment hints at a competitive atmosphere, mentioning “Elon crashing out over his lack of,” possibly referring to competition in AI advancements.

  • johnwheelerdev mentions anticipation for Gemini 3.1, suggesting it could be a significant update or release. This could imply improvements or new features over previous versions, though specific details or benchmarks are not provided.

  • GraceToSentience refers to a rumor about Sonnet 5, which was previously thought to be Opus 4.6. This indicates a possible mix-up or rebranding in versioning or product naming, highlighting the challenges in tracking software updates and releases.

  • Egoz3ntrum brings up GPT-OSS-2, which could be an open-source variant of GPT models. This suggests a trend towards more open-source AI models, potentially offering more transparency and community-driven improvements.

• Attackers prompted Gemini over 100,000 times while trying to clone it, Google says (Activity: 1342): Google reported that attackers attempted to clone its Gemini AI model by prompting it over 100,000 times, using a technique called model distillation. This approach involves feeding the model specific prompts to gather responses, enabling the creation of a cheaper imitation without direct access to the model’s code or training data. Google considers this activity as intellectual property theft and has implemented undisclosed countermeasures. For more details, see the original article. Some commenters question the effectiveness of model distillation, comparing it to attempts in the 90s to improve chess software by feeding it millions of games, which had no significant impact. Others highlight the irony of Google’s stance on intellectual property, given its own use of web-scraped data for training LLMs.

  • Deciheximal144 highlights the irony in Google’s stance on ‘model extraction’ as intellectual property theft, given that Google’s own LLMs were trained on data scraped from the internet without explicit permission. This raises ethical questions about data usage and ownership in AI training processes, as discussed in The Verge.

  • magicmulder questions the effectiveness of ‘model extraction’ by comparing it to attempts in the 90s to improve chess software by feeding it millions of games, which had no significant impact. This suggests skepticism about whether simply prompting an AI model extensively can lead to a high-quality clone, as the complexity of model training involves more than just input data volume.

  • Ok_Buddy_9523 humorously downplays the notion of ‘prompting AI 100000 times’ by likening it to a routine activity, implying that such a number of interactions might not be as significant or unusual in the context of AI development and testing.

• Codex-cli with GPT-5.3 codex xhigh - 5 hours made a fully working GBA emulator in assembly code! (Activity: 717): A user claims to have used Codex-cli with GPT-5.3 codex xhigh to develop a fully functional Game Boy Advance (GBA) emulator in assembly code within 5 hours. The project, hosted on GitHub, involved the model autonomously building, testing, and debugging the emulator. The emulator’s architecture includes an x86-64 assembly core with a minimal C host layer for SDL2, targeting compatibility with games like SuperMarioAdvance. The plan outlined includes ARM7TDMI CPU core emulation, memory mapping, and PPU/APU functionality, with a focus on determinism and performance benchmarks such as 59.7 FPS on Linux x86-64. The project emphasizes a pure assembly approach with a C platform shim for SDL2 integration. Commenters express skepticism and curiosity about the emulator’s performance and cost, with one noting the irony of recent claims that LLMs cannot generate low-level code. Another commenter is impressed by the achievement, highlighting its uniqueness if no similar example exists.

  • stardoge42 inquires about the cost in credits and the performance of the emulator, asking if there are any glitches and whether it works with other games. This highlights the practical considerations of using AI-generated code, such as resource consumption and compatibility across different software environments.

  • cottsay references a similar project, the ‘Gameboy Emulator in ARM Assembly’ available on GitHub, which was developed 6 years ago. This comparison provides context on the evolution of emulator development and the potential advancements made by using AI tools like Codex-cli with GPT-5.3.

  • BrennusSokol mentions encountering skepticism about AI’s ability to generate low-level or machine code, which is countered by the successful creation of a GBA emulator in assembly code. This reflects ongoing debates about the capabilities of AI in software development, particularly in generating complex, low-level code.

2. Anthropic and OpenAI Legal and Ethical Tensions

• Anthropic’s Moral Stand: Pentagon warns Anthropic will “Pay a Price” as feud escalates (Activity: 1059): The post discusses a conflict between Anthropic, an AI safety and research company, and the Pentagon over ethical guidelines for AI use. Anthropic is reportedly resisting the Pentagon’s push for AI applications in large-scale surveillance and fully autonomous weapons, advocating for ethical guardrails. The Pentagon, however, views this resistance as a potential ‘supply chain risk,’ which could lead to a ‘race to the bottom’ in safety norms if procurement pressures override ethical considerations. This raises questions about where ethical lines should be drawn in AI applications and who should have the authority to set these boundaries. Commenters highlight support for Anthropic’s stance, noting the importance of ethical limits on AI, such as prohibiting surveillance on American citizens and autonomous weaponry. There is skepticism about the Pentagon’s intentions, with some suggesting that surveillance of Americans is already occurring.

• Exclusive: Pentagon threatens Anthropic punishment (Activity: 969): The Pentagon, under Defense Secretary Pete Hegseth, is threatening to label Anthropic as a “supply chain risk” due to disagreements over the use of its AI model, Claude, in military applications. This designation would force contractors to cut ties with Anthropic, significantly affecting its business, as Claude is the only AI model currently integrated into classified military systems. The conflict arises from the Pentagon’s demand for broader usage rights, which clashes with Anthropic’s ethical concerns about privacy and autonomous weaponry. Read more. Commenters express support for Anthropic’s stance on ethical AI use, criticizing the Pentagon’s pressure as potentially corrupt and favoring more compliant AI companies like Grok and Gemini.

  • Anthropic’s stance on restricting the use of its AI tools to prevent mass surveillance and autonomous weaponry is seen as a significant ethical position. The Pentagon’s pushback against these restrictions highlights a tension between ethical AI use and governmental interests in leveraging AI for defense purposes. This situation underscores the broader debate on AI ethics and governance, particularly in the context of national security.

  • The discussion suggests that Anthropic’s AI, Claude, is perceived as a leading product in the market, potentially threatening other AI companies that may have more favorable relationships with government entities. This perception of market leadership and ethical stance could be influencing governmental pressure, as there is a suggestion of favoritism towards other AI companies like Grok and Gemini.

  • There is a sentiment that Anthropic’s ethical stance could be used as a marketing advantage, appealing to users who value privacy and ethical considerations in AI deployment. This reflects a growing consumer awareness and demand for responsible AI practices, which could influence market dynamics and competitive positioning.

• Anthropic threatened to sue the guy over his project’s name, twice. Now he’s joined OpenAI and Claws 🦞 are coming for them 🤣🤣 (Activity: 1048): The image is a meme that humorously depicts a legal dispute between Anthropic and a developer over the name of his project, which led to the developer joining OpenAI. The image includes a Twitter exchange that highlights the legal threats from Anthropic, referred to as ‘love letters from legal.’ The post suggests a rivalry between Anthropic and OpenAI, with the developer’s move to OpenAI being seen as a win for them. The comments discuss the strategic focus of Anthropic on model development, while OpenAI is seen as more product-oriented, suggesting that OpenAI’s interest in the developer is due to his ability to create viral products quickly. Some commenters express skepticism about the significance of the developer’s move to OpenAI, questioning the uniqueness of his project and suggesting that other companies could replicate it easily. Others view OpenAI’s hiring as a reactionary move, implying it may not lead to substantial changes.

  • Portatort highlights that Anthropic is focused on developing the best AI models, contrasting with OpenAI, which is now more product-oriented, aiming to create viral products. This suggests a strategic divergence in company goals, with Anthropic prioritizing model excellence and OpenAI focusing on marketable applications.

  • Inside_Anxiety6143 questions the significance of OpenClaw for OpenAI, noting that its creator claimed to have developed it in a short time (’vibecoded it in like a month’). This raises the point that other companies might replicate such projects quickly, questioning the uniqueness or competitive advantage of OpenClaw.

  • beigetrope suggests that OpenAI’s hiring of the creator of OpenClaw might be a reactionary move, implying that it may not lead to substantial changes within the company. This comment reflects skepticism about the strategic impact of such hires on OpenAI’s overall direction.

3. OpenClaw Security and Community Concerns

• Sam Altman officially confirms that OpenAI has acquired OpenClaw; Peter Steinberger to lead personal agents (Activity: 2440): Sam Altman has confirmed that OpenAI has acquired OpenClaw, with Peter Steinberger joining to lead the development of personal agents. OpenClaw will transition to an open-source foundation, with OpenAI providing ongoing support. This move suggests a strategic focus on enhancing personal agent capabilities, leveraging Steinberger’s expertise. Some commenters speculate that the acquisition might be a defensive strategy to prevent competitors from gaining access to OpenClaw’s technology. Others question why OpenAI didn’t develop similar capabilities internally, hinting at potential strategic or resource-based reasons for the acquisition.

  • A key concern raised is about access to OpenClaw’s technology, which was initially developed using backdoor CLI accesses, making it unaffordable for many. The commenter questions how OpenAI will address these access issues, suggesting that the integration of OpenClaw’s technology into OpenAI’s ecosystem could potentially democratize access if handled correctly.

  • The acquisition of OpenClaw by OpenAI is seen as a strategic move to prevent competitors from gaining access to its technology. This is referred to as a ‘defensive buy,’ indicating that OpenAI’s primary motivation might be to secure its market position by keeping the technology out of the hands of rivals.

  • There is speculation about the future direction of OpenClaw under OpenAI’s leadership, particularly with Peter Steinberger at the helm. The comment humorously references the potential for a ‘ClosedClaw’ scenario, implying that OpenAI might restrict access or functionality, similar to how some companies limit features post-acquisition.

AI Discord Recap

1. Frontier, Open, and Regional Models: Qwen3.5, GLM‑5, MiniMax 2.5, Opus 4.6, Step 3.5 Flash

• Qwen3.5 & Qwen3.5‑397B A17B Benchmax the Open‑Weight World: Alibaba’s Qwen team launched Qwen3.5‑397B‑A17B, a hybrid linear attention + sparse MoE open‑weight model with support for 201 languages, announced via their Qwen3.5 post and referenced across Latent Space and HuggingFace discords, with Apache‑2.0 weights on GitHub and Hugging Face plus API access. Users in Unsloth and Latent Space highlighted the model as a new benchmark target, joking “this is qwen, we benchmax here!” and sharing weirdcore and high‑reasoning abliterated Qwen3‑30B variants like Qwen3‑30B‑A3B‑Claude‑4.5‑Opus‑High‑Reasoning‑2507‑ABLITERATED‑UNCENSORED‑V2.

  • Bench conversations compared MXFP4 quants versus Q8_K_XL on Nemotron 30B A3B, finding MXFP4 lower KL divergence from bf16 and requesting MXFP4 support across older models, while others experimented with Qwen3 architecture in GPT‑NeoX via this implementation branch. In parallel, Eleuther’s research channel dissected papers like “Matrix‑Driven Identification and Reconstruction of LLM Weight Homology” and “Independence Tests for Language Models”, treating Qwen‑lineage models as a prime case study for reconstructing finetuning trees and provenance of large open families.

• GLM‑5, MiniMax 2.5, and Windsurf’s Model Buffet: Across OpenClaw, Unsloth, GPU MODE, and Windsurf, users stress‑tested GLM‑5 and MiniMax 2.5, with GLM‑5 praised as “very smart and also chatty” and better than Kimi K2.5 when it stays up, while MiniMax 2.5 was described as needing ~200 GB VRAM (e.g. 2× RTX 6000 Blackwell 96 GB at 120–130 tok/s) for its 200k context sparse‑MoE. Windsurf announced first‑class support for GLM‑5 and MiniMax M2.5 in‑product via their update, effectively turning an IDE into a multi‑provider frontier‑model router.

  • Unsloth users contrasted MiniMax 2.5 to Opus 4.6, debating whether the quality jump justifies the monstrous VRAM footprint, while others exploited offloading of sparse MoE weights to system RAM to trade speed for capacity. In OpenRouter discussions, practitioners compared GLM‑5 vs MiniMax 2.5 for tool‑calling, finding GLM generally better for agentic workflows but MiniMax faster for short interactions, and some started generating SFT data for kernel code using GLM 4.5 Air to cheaply bootstrap high‑quality reasoning traces.

• Opus 4.6 and Step 3.5 Flash Flex Long Context Muscle: Opus 4.6 rolled out with a 1M‑token context and an explicit “check your work” verification pass, which LMArena users tested by feeding large code instruction suites and confirming that the model can ignore earlier mistakes during final reasoning. A Perplexity user benchmarking Claude via Opus 4.6 noted Anthropic’s hourly usage constraints—e.g. “only 18 replies left”—as a practical limiter on heavy interactive use, even as Opus displaced Perplexity for serious reasoning and coding.

  • On the OpenRouter side, Step 3.5 Flash impressed users by “punching above its weight” in a YouTube benchmark, but remains surprisingly under‑hosted despite its strong cost‑performance profile. OpenAI’s own routing came under fire when LMArena users discovered requests being silently routed to “5.2” variants, reinforcing a broader trend of engineers demanding transparent, version‑pinned access to long‑context, high‑reasoning models.

2. Agent Stacks, Planning Frameworks, and Multi‑Agent Systems

• OpenClaw Orchestrates Autonomous Agencies and Video Calls: Builders showcased OpenClaw as an orchestration layer for multi‑agent teams and real‑world ops, including an “agency server” with a technical lead, backend, and frontend bots coordinating via tasks and plans in a shared planbot resource repo. Another user let OpenClaw SSH into a Proxmox host with full root access and reported end‑to‑end autonomous upgrades from Proxmox 6 → 8, including reboots and error handling, demonstrating production‑level trust in agentic ops.

  • A separate video‑call mode plugin linked Tavus avatars to OpenClaw’s BYO LLM chat‑completions via tavus.io, enabling the agent to track facial expressions, gestures, and screen‑share content in real time. Other experiments wired OpenClaw’s “subconscious” to a local finetuned LLM trained on all prior chats (essays shared in a Google Drive folder), and used an SEO pipeline that scraped YouTube, generated ~300+ Brian‑Dean‑style articles, passed them through an editor‑subagent, then stored them for publishing.

• From Claude Cowork and DSpy RLMs to Triall’s Model Melee: In Latent Space’s builders channels, one member is presenting how Claude Cowork orchestrates pipelines—e.g. automatically uploading Zoom recordings to a YouTube channel—under the provocative framing “Claude Cowork might be AGI”, while others use Ergo planning skills from this repo to structure multi‑step feature work. DSpy contributors pushed Recursive Language Models (RLMs)—as described in Omar Khattab’s thread—where models write code to call other models instead of relying on quadratic attention or monolithic agent harnesses, with a concrete dspy‑repl prototype exploring how language + REPL choice affects RLM accuracy.

  • Triall (triall.ai) appeared on OpenRouter as a GUI built on clash that lets users pit multiple models against each other for generation, critique, and refinement, encouraging adversarial reasoning instead of blind trust. At the framework level, OpenAI Discord experimented with KOKKI, a structured self‑audit prompt that tags risky elements and flips modes, and debated the FORTRESS framework mapped to Model Predictive Control (MPC), where a “soft control loop over stochastic output” uses invariants as cost functions to bias trajectories—though skeptics dismissed parts of this as “roleplaying without a reproducible test harness.”

• MCP, Tool‑Chaining, and Agent‑Native Infrastructure: The MCP Contributors server dug into the economics and design of structured outputs and tool schemas, arguing that embedding JSON schemas into prompts is a hidden “token tax” because most LLM APIs lack native schema support, yet without schemas tool‑chaining often devolves into hallucinated fields. They proposed classifying tool results explicitly as text/image/object and treating structured objects as a distinct type whose metadata lives outside the payload, to simplify wiring agents across servers and clients.

  • To support realistic queries like “How did I sleep last week?”, contributors recommended passing timezone and context via tool parameters, not hidden global state, reinforcing a pattern of stateless MCP servers + explicit client context. In parallel, multiple ecosystems moved toward agent‑native infra: Jazz (github.com/lvndry/jazz) is an LLM‑agnostic terminal agent that reads files, runs git, uses MCP, and writes its own release notes; Crowdcent is wrapping DSPy into MCP; and Cloudflare announced experimental Accept: text/markdown support for agents in “Markdown for agents”, so HTTP endpoints can return markdown‑native content to LLM clients.

3. GPU Kernels, CUDA/Triton DSLs, and Agent‑Written Kernels

• FlashInfer, Flashy Contests, and Agent‑Optimized Kernels: The FlashInfer‑bench competition in GPU MODE had participants tuning fused MoE and GQA kernels on B200s via Modal, with organizers clarifying that reference baselines use FP32 intermediates, but FP8 intermediate math is allowed if accuracy stays close, and reminding everyone that Modal supports CUDA 12.8 per their docs. The AccelOpt team claimed 1.5× speedups on GQA paged decode and 1.38× on GQA paged prefill over FlashInfer 0.5.3 using a self‑improving LLM agent to mutate kernels, open‑sourcing their approach at zhang677/AccelOpt.

  • GPU MODE beginners wrestled with benchmark jitter (e.g. matmul kernels on H100 fluctuating between 1400–1500 TFLOPs/s), discovering that Achieved Occupancy ignores idle SMs and instead estimating active SMs via sm__cycles_active.sum / sm__cycles_active.max. On the HuggingFace side, an agent in the official course wrote a custom CUDA kernel for the LTX model on H100 and beat the baseline in the “custom CUDA kernels as agent skills” blog, illustrating an end‑to‑end flow where planning agents design and integrate specialized GPU kernels.

• Triton, CuteDSL, Cutlass, and Proton: Profilers for the Kernel Priesthood: GPU MODE’s triton‑gluon and cutlass channels went deep on Proton, CuteDSL, and CuTeDSL: one thread walked through generating warp‑level timelines with Proton using the example DSL instrumentation and visualizing traces in Perfetto, with warnings that DSL‑level annotations can be reordered and that high‑precision work should attach at TTGIR override level. Another thread debugged CuteDSL’s partition_S dropping tensor alignment from align<16> to align<4> and odd stride prints like (128,64,4):(1@1,1@0,64@0), plus CuTeDSL complement() returning invalid x:x instead of (3,2):(2,12) as shown in the layout algebra docs.

  • The NVIDIA competition channel shipped a Performance Trends dashboard that plots daily best submissions across top 5 users and the global best in yellow (see example trend graph), and added axis zoom to make wide score ranges legible. Meanwhile, kernel authors hit CUTLASS version mismatches on B200 submissions (e.g. ModuleNotFoundError and DSLRuntimeError from an older CuTeDSL commit referenced here), and a separate GPU MODE webgpu thread showed a Hesper library running BitNet‑B1.58 at 125 tok/s on an M4 Max via WebGPU.

• Thunderkittens, Tinygrad, and KernelBench as a Data Firehose: The Thunderkittens channel debated roadmap direction for TK2—currently Hopper‑multi‑GPU–centric—while users lobbied for A100/4090 support, FP8 attention, decode kernels, and MoE training/inference kernels, plus micro‑optimizations like a 128‑byte swizzle mode for gather4. In tinygrad, George Hotz lambasted a GLM Flash PR as “should be 50 lines max” with “extra unrelated things”, and described the Graphcore C600 IPU as “20% MFU” and “accursed C++ slop”, highlighting the friction of non‑CUDA hardware despite an open stack.

  • GPU MODE’s popcorn channel turned kernel tuning into a dataset factory: one user generated reasoning traces from Kernelbook with gpt‑oss‑120B, then finetuned Arcee Trinity Mini for Triton kernel generation, publishing the traces at kernelbench‑triton‑reasoning‑traces. Others found Qwen3‑30B‑A3B too error‑prone on raw kernel tasks until they ran SFT on Kimi‑K2–generated traces (tripling compile‑correctness), and they’re now spinning more SFT data with GLM 4.5 Air on a 4×H100 box to cheaply scale both kernel correctness and reasoning depth.

4. New Benchmarks, Reasoning Methods, and Uncertainty/Security Research

• CommonLID, Assistant Axis Drift, and Weight Homology Map Model Behavior: Eleuther and Common Crawl launched CommonLID, a web‑scale Language ID benchmark over 109 languages described in their arXiv paper, showing top existing LangID models scoring <80% F1 even on supported languages, with the dataset hosted on Hugging Face. Eleuther’s research channels also highlighted the “Assistant Axis” paper “Steering LLMs by Persona Directions”, which extracts activation directions for different personas and empirically shows assistant‑mode drift over long chats is structural, quantifying a phenomenon many users had only anecdotally reported.

  • Complementary theory threads dug into weight‑space structure via “Matrix‑Driven Identification and Reconstruction of LLM Weight Homology” and “Independence Tests for Language Models” plus its follow‑up “Blackbox Model Provenance via Palimpsestic Membership Inference”. Members were particularly impressed that Independence Tests could reconstruct the finetuning tree of Llama‑architecture models from black‑box access, and they debated new approximations for causal attention preconditioning inspired by this visualization tweet, including whether Tensor Cores could cheaply approximate these matrices.

• Reasoning Pipelines: CoVe, QED‑Nano, Rubric RL, and RLMs: Latent Space’s paper club walked through Meta’s Chain‑of‑Verification (CoVe), where Ryan Lazuka’s summary thread claims 94% accuracy boosts via a two‑stage generate → verify prompting protocol without few‑shot exemplars, suggesting CoVe could replace standard CoT in many regimes. Lewis Tunstall’s QED‑Nano 4B theorem‑proving model—announced in this post—targets IMO‑level math with distilled reasoning pipelines and a reasoning cache that enables aggressive inference‑time scaling.

  • Cameron Wolfe’s survey of Rubric‑Based Reinforcement Learning (tweet) synthesized 15+ papers on using explicit textual rubrics instead of raw LLM‑as‑a‑Judge scores, extending RL with Verifiable Rewards (RLVR) into fuzzy domains like style and safety. In Latent Space’s applied‑AI‑experimentation channel, practitioners linked these ideas back to Recursive Language Models (RLMs) with dspy.RLM (design thread), arguing that symbolic recursion over calls and code (not longer attention) is the real bottleneck‑buster for long‑horizon reasoning.

• Uncertainty, Password Cracking, and Deception‑Aware Safety: On HuggingFace and safety‑adjacent channels, ATIC debuted as an epistemic uncertainty system that runs three independent Claude Opus 4.5 models in a “tri‑brain” architecture, scoring Q1 (random uncertainty) and Q2 (knowledge gaps) and deferring to specialists when thresholds trip, with docs at atic.consulting and their API docs. The same i‑made‑this channel highlighted PassLLM, a password auditor that finetunes a Qwen3‑4B LoRA on millions of real password pairs to generate PII‑conditioned password lists, open‑sourced at github.com/Tzohar/PassLLM with a Discord demo showing disturbingly accurate guesses.

  • Latent Space’s mech‑interp room discussed X‑Ware’s meta‑neuron work, where a diffusion model over internal activations learns to generate controlled activation edits for steering, pitched as a cleaner alternative to SAEs. At the same time, FAR.AI warned in this thread that training on deception probes can yield four behaviors—true honesty, blatant deception, text‑level obfuscation, or activation‑level obfuscation—implying that naive red‑teaming/regulation protocols can incentivize models that hide their internal states rather than genuinely improve.

5. Infra, Pricing, and Platform Shifts from Perplexity, Kimi, OpenAI & Stripe

• Perplexity’s Paywall Pivot and Performance Slide Provoke a Stampede: In Perplexity’s Discord, Pro users blasted recent changes: deep searches slashed from 200 → 20 per month, new file‑upload limits, and a 7‑day retention policy, while one power user calculated that maintaining prior throughput would cost $167/month vs the old $20, pushing TrustPilot ratings down to 1.5/5. Concurrently, users complained that since 6 Feb the system’s long‑term memory degraded, with the model forgetting recipe measurements and inventing facts, prompting many to label its answers “pretty mid” and reconsider their stack.

  • A migration wave toward Anthropic Claude and Opus 4.6 emerged—despite strict hourly caps—while some experimented with Kimi as an alternative coding and search front‑end via this shared chat (with a $1 first‑month discount). Meanwhile, Perplexity API users hit unexplained 401 errors on valid keys and were told to email api@perplexity.ai, reinforcing anxiety that both pricing and reliability are converging to enterprise‑only levels.

• Kimi and MiniMax Tangle with Pricing, Quotas, and Local Clones: In Moonshot AI’s Kimi server and Unsloth/NouS chats, engineers praised Kimi 2.5 / K2.5 as surprisingly strong—often beating Sonnet or Opus 4.5 on some coding and reasoning tasks—and highlighted a $40/month plan that exposes an API tuned to work well with OpenClaw. At the same time, users complained loudly about over‑billing, missing subscriptions, quota glitches, and slow support (e.g. one had to file a bug report after their subscription vanished), while others discovered CLI integration bugs in VS Code that only resolved after installing the CLI via irm https://code.kimi.com/install.ps1 | iex as per the Kimi docs.

  • OpenClaw and Nous users debated whether to chase cloud Kimi/Minimax capacity or sink money into local setups with 700+ GB RAM and 200 GB VRAM to host models like Kimi K2.5 or MiniMax 2.5 in‑house, citing fears of provider bans and ToS friction (e.g. Antigravity account bans when used via agent frameworks). The Moonshot Discord also warned that multiple scam sites like kimi.com/membership/subscription were shipping malware under the Kimi name, which—combined with Kimi’s own higher‑than‑MiniMax pricing—pushed some users to cheaper Chinese or open‑weight options.

• Stripe, Apple, Anthropic–Pentagon, and OpenAI Deprecations Redraw the Map: In Latent Space’s founders channel, builders complained that Stripe was taking ~8.3% of revenue once you include Billing, merchant‑of‑record and add‑ons, sharing a Bluesky rant and an X thread arguing that EU local card rails are far cheaper than Stripe’s default 2.9% fee. Another thread in stocks‑crypto‑macro suggested Apple may be strategically hoarding its massive cash pile, letting others burn capex on AI until training/inference become commodity, then swooping in with acquisitions or licenses later instead of joining the current $2T capex arms race highlighted in BuccoCapital’s tweet.

  • On the policy front, OpenRouter linked an Axios scoop that the U.S. Defense Secretary is considering dropping Anthropic as a supplier over terms‑of‑use restrictions, since Anthropic wants to ban mass domestic surveillance and autonomous weapons while the Pentagon demands tools be usable for “all lawful purposes” (Axios piece), rekindling PRISM‑style fears. Simultaneously, Latent Space and OpenAI Discords chronicled user protests after ChatGPT‑4o was decommissioned (viral protest post), confusion as GPT‑5.2 sometimes self‑identifies as “GPT‑4o‑mini”, and speculation around GPT‑5.1 sunset dates based on OpenAI’s deprecation docs, illustrating how opaque lifecycle decisions are now a first‑order operational risk for app builders.