The Grok scandal involving "silent" code uploads, followed by open-sourcing as an attempt to regain trust.

Grok CLI and Tracking
https://www.internationalcyberdigest.com/xais-grok-build-cli-uploads-entire-git-repositories-to-a-google-cloud-bucket/
https://gist.github.com/cereblab/dc9a40bc26120f4540e4e09b75ffb547
Several users reported that upon session startup, the Grok Build CLI deterministically (not as an autonomous agent decision) archives the current directory or Git repository and uploads it to Google Cloud Storage (grok-code-session-traces). One user ran grok from their home directory and observed that SSH keys, password managers, documents, photos, and all other personal files were being uploaded.

Investigations revealed that this is NOT the model's behavior. The "Improve the model" / /privacy settings only control whether the data is used for training, not whether files are copied from the machine in the first place. This behavior is executed by the harness code. Analysis (by cereblab, on grok version 0.2.93) revealed two data transmission channels:

1. Model turn (/v1/responses) — content actually read by the agent (including .env files).
2. Entire directory snapshot — a separate upload of the entire repository, including Git history, even containing files that the agent was explicitly instructed not to read.

For a 12 GB repository, approximately 5.1 GiB was uploaded to Google Cloud Storage, compared to only ≈192 KB sent to the model. A local workaround was identified using a kill-switch: setting [harness] disable_codebase_upload = true in ≈/.grok/config.toml (along with environment variables to disable telemetry). However, following the public backlash, xAI servers disabled these uploads on their end around July 12. Elon Musk promised to completely delete all previously uploaded data.

https://news.ycombinator.com/item?id=48892468
The tone on Hacker News (HN) is highly critical, with users arguing that authorizing an agent to "trust this directory" should not grant permission to "upload everything to the vendor." Consequently, there is strong advocacy for running AI agents within VMs, containers, or dedicated user accounts to restrict access to local systems.

Comparisons were drawn to Cursor's indexing behavior (which also uploaded all files on startup), but in Cursor's case, this was clearly documented as a requirement for faster embedding generation.

Grok CLI Open-Sourced
https://x.ai/open-source
https://github.com/xai-org/grok-build
https://simonwillison.net/2026/Jul/15/grok-build/
Following the controversy, xAI/SpaceXAI open-sourced the Grok Build codebase on GitHub under the Apache 2.0 license. It consists of a Rust TUI and an agent runtime (≈845k SLOC, with ≈3% vendored). The repository acts as a periodic snapshot of their internal monorepo (SOURCE_REV), and external pull requests or issues are not accepted. Users can build from source and run it local-first using their own inference backend. However, in practice, the CDN-distributed binaries and the open-source tree may differ, as reproducible builds are not yet supported.

Traces of the upload mechanism remain in the code (upload/gcs.rs), but the session upload now returns session_state_upload_unavailable. The codebase also includes ported tools from Codex/OpenCode (with appropriate THIRD-PARTY notices), a terminal Mermaid renderer, and system/subagent prompts.

Discussion
https://news.ycombinator.com/item?id=48926590
Reactions on Hacker News are mixed: some view this as a strategy of a lagging player or as an "open-sourced because they got caught" move. Others praise the TUI for its mouse support and smoothness. The community has already started creating privacy-focused forks:

• gork-build: https://github.com/thedavidweng/gork-build (strips telemetry, blocks auto-updates),
• digi-grok / open-grok (multi-provider support),
• desktop Tauri wrappers,
• scripts to disable telemetry.
  However, many believe these forks lack utility for other models, as alternatives like Pi or OpenCode are better suited for those workloads.

#grokbuild #grok #agenticcoding

Comments

Finally, model announcements that represent a meaningful step forward.

The Massive Kimi K3
https://www.kimi.com/blog/kimi-k3
Moonshot has released Kimi K3 — an open-frontier, extremely large 2.8T-parameter model (MoE: activates 16 out of 896 experts), featuring a 1M-token context window and native image understanding. It is the first open model in the ~3T parameter class. The model is optimized for long-running agentic workflows, and the launch presentation places particular emphasis on generating simple 3D games.

Among the showcased use cases are GPU kernel optimization, building a MiniTriton compiler from scratch, and a 48-hour chip design run. According to Moonshot's benchmarks, K3 trails Claude Fable 5 and GPT-5.6 Sol by a small margin, but consistently outperforms Opus 4.8, GPT-5.5, and clearly surpasses GLM-5.2. That effectively places it in third place worldwide today, with only about a 5% gap behind Fable 5. Following a proud Chinese tradition, it is also cheaper than its U.S. competitors.

At the time of the announcement, Moonshot released access to Kimi K3 through its API, Kimi.com, Kimi Code, and other company services, but not the model weights themselves. In the technical blog post, Moonshot explicitly states that the full model weights will be released by July 27, 2026.

Discussion
https://news.ycombinator.com/item?id=48935342
According to Simon Willison, this is "the most expensive pelican" among Chinese models. If K3 is genuinely close to Fable and Sol, that pricing may be justified. Running a 2.8T model locally is out of reach for nearly everyone, so the real value lies in GPU cloud access rather than "running it on a laptop." Much of the discussion revolves around whether Chinese AI labs have nearly caught up with Anthropic and OpenAI, or whether a significant gap still remains.

https://www.youtube.com/watch?v=QfCpRTLSOB4

Fable 5 Returns
https://www.anthropic.com/news/redeploying-fable-5
Following the June 9 release, the U.S. government imposed restrictions on open access to Anthropic's most capable models, Fable 5 and Mythos 5, requiring prior internal security review. Anthropic disabled access for all users because it had no reliable way to verify users' locations.

The restrictions were lifted on June 30, and starting July 1, Fable 5 became available globally again across Claude, Claude Code, Cowork, and the Platform API. Mythos 5 remains limited to a small set of U.S. organizations through the Glasswing program. Anthropic also extended the grace period during which Fable 5 remained available within subscription plans — first until July 12 and then until July 19. Whether access will eventually require token-based billing remains to be seen.

GPT-5.6 in Three Variants
https://openai.com/index/gpt-5-6/
OpenAI introduced the GPT-5.6 family: Sol (flagship), Terra (balanced, roughly GPT-5.5-level performance at a lower cost), and Luna (fast and inexpensive, roughly GPT-5.4-level performance). It's encouraging to see an explicit choice instead of a single model expected to handle everything. Routine agent loops fit Terra or Luna, while heavy refactoring and long-running tasks are better suited to Sol.

GPT-5.6 Sol already feels like GPT-6. It can autonomously work for hours, perform self-verification, execute complex tasks, and generate substantial amounts of code. This capability is precisely why the release initially went through a government preview program before becoming broadly available.

The New Work / Codex App
https://openai.com/index/chatgpt-for-your-most-ambitious-work/
OpenAI is integrating the Codex app with the Atlas browser (a few days later, Anthropic also integrated a browser into Claude Work/Code) and the new ChatGPT desktop applications for macOS and Windows. The platform now revolves around three modes: Chat (quick questions and drafts), Work (long-running agentic tasks involving documents and email), and Codex (repository-connected development workflows).

Computer Use has reportedly improved significantly. Plugins, skills, scheduled tasks, and related automation features now work across the ecosystem. Long-running tasks can be monitored and managed directly from a phone. A new Sites tab allows users to publish public dashboards and prototypes with minimal effort — simply by asking ChatGPT to publish a site.

OpenAI has also introduced inline editing. Code and text can now be modified directly inside the ChatGPT interface without constantly switching to an external editor for small changes.

Keyboard Codex Micro
https://worklouder.cc/codex-micro
OpenAI has also unveiled its first hardware product, the compact programmable keyboard (more accurately, a macropad) developed together with Work Louder for managing Codex agents. It features dedicated agent-control keys, status indicators, a reasoning-level dial, and support for voice commands.

#kimi #openai #codex #anthropic #fable5 #agenticcoding

Comments

Finally, an answer to Claude Code and Codex from Elon Musk's team.

Grok 4.5 — Faster and Cheaper than the Opus-Class
https://x.ai/news/grok-4-5
https://cursor.com/blog/grok-4-5
On July 8, 2026, SpaceXAI unveiled the Grok 4.5 model—tailored for code generation, autonomous tool use, and "office" tasks. It was trained in collaboration with Cursor on tens of thousands of GPUs. The training data includes trillions of tokens from real Cursor sessions: how people work with repositories, agents, and tools, plus STEM and general knowledge, rather than just "pure" coding like in Composer 2.5. The model has seen what real-world work in Cursor looks like from users who opted in via their settings.

In benchmarks, the model isn't leading everywhere—sitting somewhere between GPT 5.5 (with 5.6 just around the corner) and Opus/Fable—as the focus is specifically on cost-effective intelligence. Compared to GLM-5.2, Grok has the ability to accept image inputs.

On SWE-bench Pro, the model consumes about 4 times fewer output tokens than Opus 4.8 at maximum settings while pushing around 80 tokens per second. On longer tasks, Grok tends to overcomplicate answers less than Sonnet 5 or Opus, meaning the actual bill often ends up being more favorable than a simple token-price comparison suggests. The API costs $2/$6 per million input/output tokens; if the context exceeds 200k (with a maximum of 500k), the price doubles.

Grok Build CLI for Everyone
https://x.ai/cli
https://x.ai/news/grok-build-cli
Grok Build is a terminal-native coding agent (a Rust-based CLI, in beta since May 2026). It’s not a browser chat, but an agent in your command line. It has everything you need: parallel subagents (including in separate git worktrees), skills / plugins / hooks / MCP / AGENTS.md. Out of the box, it intentionally picks up settings from Claude Code (skills from ~/.claude/ and some permissions). It features a headless mode (grok -p) for scripts and CI, voice, image/video tools, and a /goal command for long-term objectives.

Grok 4.5 with a 500k context window has now been set as the default model. So Grok Build focuses on speed and parallelism (multiple agents running simultaneously). Right now, it features a clean, nice terminal UX and compatibility with workflows from the Claude ecosystem. Plus, for a limited time, there is a free tier in Grok Build and Cursor (in Cursor, this applies to all plans, with double usage for the first week). It is not yet available in the EU (promised by mid-July).

Currently, the interface has a lot of "pay for subscription" prompts. By default, training data collection is enabled after installation—you have to go into the settings to opt out. In my comparative testing of ZCode (another relatively affordable GLM-5.2 model) vs. Grok Build, I preferred the results from Grok.

https://www.youtube.com/watch?v=RGXRUH3oK6U

According to the video creator, Grok generated a more visually appealing version (better color palette, more user-friendly design) of the presentation. Grok also produced a much better solar system simulation. For creating a web page from a photo, the results were roughly identical. The main advantage is the price, which is 5–6 times cheaper than Claude Code.

Discussion
https://news.ycombinator.com/item?id=48835111
On HN, the discussion revolves around price, speed, and how many tokens a task actually consumes. First impressions: it is very fast, performance-wise around the lower tier of Opus / GLM 5.2, and if you pay for the API, it often ends up cheaper than GPT and Opus. Grok Build's interface is being praised—"well made"—especially against the backdrop of Claude Code's ongoing decline.

There is skepticism too. It stops looking cheap once the context exceeds 200k; some are keeping it strictly for short reviews. There are complaints that for simple edits (inline helpers), the model tends to rewrite half a module instead of just ten lines. Grok's reputation (past safety scandals) is still cited as a reason to avoid using the model.

Cursor data and training in robust environments are strong points; Grok 4.5 + Grok Build look like good candidates to test on various tasks if your repositories aren't too large.

#grokbuild #cursor #newllmmodel #agenticcoding

Comments

Over the past six months, most new large language models have evolved beyond merely providing high-quality answers; they now possess the capability for sustained, autonomous operation.

Loop Engineering is a method of structuring agentic workflows so that instead of responding to a single prompt, an agent repeatedly executes a cycle: understanding the task, gathering context, taking a micro-action, verifying the result, correcting errors, and terminating based on an explicit rule.

While prompt engineering aims to optimize a single model response, loop engineering focuses on improving the entire process of driving a task to a verified outcome.

What is Loop Engineering
https://kilo.ai/articles/what-is-loop-engineering
This article provides the foundational concepts. The strength lies not in a single step, but in closing the loop—where any test failure or code error becomes new context rather than just a failure. However, a well-designed loop should not run indefinitely; it requires explicitly defined goals, context, verification, and termination rules. The article also addresses the risks associated with such high autonomy.

The basic cycle is structured as follows:

1. Intent. A human or system specifies a concrete desired outcome.
2. Context. The agent reviews code, documentation, errors, logs, requirements, or project guidelines.
3. Action. The agent modifies code, executes a command, calls a tool, or drafts a plan.
4. Observation. The system captures test results, compiler errors, build outputs, logs, screenshots, or review comments.
5. Correction. The agent adjusts its plan and repeats the cycle.
6. Termination. The cycle ends when there is proof of completion or a blocking issue arises.

Origin of the Term's Popularity
https://addyosmani.com/blog/loop-engineering/
Addy Osmani references insights from Peter Steinberger and Boris Cherny, popularizing the terminology. Instead of manually prompting the agent for each subsequent step, we build a system that prompts the agent on our behalf. This involves learning to design feedback loops, memory management, access controls, and termination boundaries.

Sub-agents separate the "doer" from the "verifier"; automated schedulers trigger tasks, separate git worktrees isolate parallel agents, and plugins provide access to real-world tools. Project-specific knowledge is stored externally—tracking what has been done, what remains, and what has already been attempted.

https://lushbinary.com/blog/loop-engineering-ai-coding-agents-guide/
Lushbinary largely echoes Osmani's points but adds practical details: the Ralph loop, how automations are structured, isolated worktrees, skills, integrations, sub-agents, and memory architectures in modern tools.

Without guardrails, budgets, logging, persistent memory, isolation, and manual error overrides, a loop is not a production-grade system—it is simply an infinite loop hosting an expensive agent.

Four Levels of Loops
https://www.langchain.com/blog/the-art-of-loop-engineering
While LangChain uses this topic to promote its product stack, they openly acknowledge the core trade-off: verification increases cost and latency but is essential for quality. They propose categorizing loops into four levels:

1. Agent Loop. The model calls tools sequentially until the task is complete.
2. Evaluation Loop. A dedicated evaluator agent reviews the output against specific rules and provides feedback to the execution agent.
3. Event Loop. Triggers are event-driven (e.g., schedules, external webhooks, messages, or new documents) rather than manual.
4. Optimization Loop. Execution logs are analyzed to refine system configurations, tools, or prompts.

Matthew Berman's Video
https://www.youtube.com/watch?v=dMrm2jAyrKM

The video "Only the best are using them..." frames the topic as the new "meta" for coding. It employs a highly hyped tone—using phrases like "the future of software engineering," "only a few know how to do this," and "the best are already using it." While it explains the core concept well for a broad audience, it significantly amplifies the hype.

Critique of the Term
https://iii.dev/blog/loop-engineering-is-just-software-engineering/
In many discussions, "Loop Engineering" is presented as if a brand-new paradigm has emerged. Some authors frame it as the future of software development, even though many of its components are well-established engineering practices: automated testing, queues, schedulers, logging, access control, retries, and human-in-the-loop validation.

Terminology mapping:

• scheduled automations -> schedulers / cron jobs;
• out-of-conversation memory -> state management / persistent storage;
• verifier -> independent consumer of output with retry logic;
• stuck tasks -> dead-letter queues / error queues;
• external integrations -> webhooks and external integrations.

This approach works best for mechanical, repetitive, and highly verifiable tasks that can be broken down into clear, testable steps. For product decisions, architecture, security, financial transactions, database migrations, and anything requiring nuanced judgment, a human must remain in the loop.

#agenticcoding #autonomousagents

Comments

Cursor hosted Compile 26, its developer-focused event dedicated to the future of programming.

https://www.marketwatch.com/story/social-media-declared-cursor-dead-then-spacex-handed-the-ai-startup-a-60-billion-lifeline-50454e29
At Compile, Michael Truell showcased the new Composer—featuring their proprietary 1.5T parameter model, trained from scratch by Cursor using over 100,000 Nvidia GPUs from SpaceX/xAI. In his view, Cursor is no longer just "a better VS Code with a chat", but a platform for agentic programming.

The model may also become available in Grok Build.

https://www.youtube.com/watch?v=fWa7uxyhVDE

https://www.youtube.com/@cursor_ai/videos
Presentations are gradually being uploaded to the official YouTube channel. These are short 10 to 25-minute talks focusing not on "AI replacing programmers," but on how the nature of work is shifting: agent memory, infrastructure for parallel agents, the roles of PMs and senior engineers, training, and quality assurance.

In addition to agent workflows and memory, there are sessions covering note-taking, representation of thoughts, development environments, agency in language, intelligence efficiency, the shifting role of the engineer, and other non-technical topics.

Origin — GitHub for Agents
https://cursor.com/origin
Notably, the most intriguing announcement is Origin, Cursor's new Git platform. On their website, they refer to it as "Git for agents." During the presentation, Origin was explicitly introduced as an agent-native Git platform, ultimately positioned as the beginning of direct competition with GitHub.

Here, agents can interact with repositories, create and handle PRs, respond to comments, fix CI failures, resolve merge conflicts, and ping human developers only when absolutely necessary.

Currently, Origin is active for internal use, while a waitlist has been opened for the public.

#cursor #composer #agenticcoding #origin #github

Comments

It seems China is actively expanding not only into models but also into complete coding harnesses / agent apps.

Kimi K2.7 in GitHub Copilot
https://github.blog/changelog/2026-07-01-kimi-k2-7-is-now-available-in-github-copilot/
GitHub has added Kimi K2.7 Code to Copilot. This is the first open-weight model available in Copilot. Hosted on Microsoft Azure.

MiMo-Code CLI by Xiaomi
https://mimo.xiaomi.com/mimocode
https://mimo.xiaomi.com/blog/mimo-code-long-horizon
https://github.com/XiaomiMiMo/MiMo-Code
Xiaomi is developing its open-source CLI MiMoCode. It supports working with Git, checkpoints, task trees, subagents, compose mode, and voice input. It features persistent memory on SQLite FTS5 and commands like /dream and /distill to extract knowledge and repetitive workflows into skills.

Interestingly, this is not just "another CLI", but an attempt to build a Codex/Claude Code-like agent with its own memory and operating modes. There is a free starting tier called MiMo Auto, OAuth via Xiaomi MiMo Platform, and support for OpenAI-compatible providers.

ZCode App v3 by Z.ai
https://zcode.z.ai/en
ZCode is a desktop application for MacOS/Windows/Linux powered by the top-tier GLM-5.2 model. With v3, Z.ai optimizes the entire agent harness specifically for its model and pricing plans. It looks like a direct clone of the Codex app.

It features plugin management, file rewind with a safety summary, improved command suggestions for prompts, planning, review, deployment, workspace tasks, skills, and multi-agent interaction. You can manage the agent via chat in WeChat, Feishu, or Telegram.

Discussion
https://news.ycombinator.com/item?id=48753715
On HN, the main discussion point is trust. Unlike MiMoCode, ZCode is not open-source, so people are asking about telemetry, sandboxing, and whether running a desktop agent on a primary machine is safe at all. Many comments boil down to best practices: agents are best run in VMs/containers, given separate worktrees, separate GitHub deploy keys, and minimal access to secrets.

Sonnet 5 - Longer and More Expensive
https://www.anthropic.com/news/claude-sonnet-5
Anthropic has released Claude Sonnet 5. Positioning: the most agentic Sonnet yet, closer to Opus 4.8 but cheaper. Available in Claude, Claude Code, and API as claude-sonnet-5. Until August 31, 2026, the price is discounted to $2/$10 per million input/output tokens, after which it will be $3/$15. For comparison, Opus 4.8 is $5/$25.

An additional nuance: the new tokenizer may count the same text as 1.0-1.35x more tokens depending on the content. Meaning, a "cheaper Sonnet" is not always automatically cheaper in reality. The model isn't necessarily smarter, but it shows better results because it is more persistent. Therefore, it can consume a lot of tokens.

Discussion
https://news.ycombinator.com/item?id=48736605
HN met Sonnet 5 with skepticism. Many are asking why use Sonnet 5 for high-effort tasks if Opus 4.8 (low/medium) sometimes offers better value per dollar. Another complaint is that models are becoming more "agentic" but sometimes overcomplicate simple tasks and generate extra work for themselves.

#glm #kimi #githubcopilot #mimo

Comments

OpenAI News.

GPT-5.5-Cyber and the Daybreak Initiative
https://openai.com/index/gpt-5-5-with-trusted-access-for-cyber/
GPT-5.5-Cyber has been announced as part of the Daybreak initiative. The model is tailored for defensive security, including vulnerability detection, threat modeling, and code patch generation. On the CyberGym benchmark, it scored 85.6%, outperforming the base GPT-5.5 (81.8%) and Anthropic Mythos 5 (83.8%). Currently, access is restricted to verified organizations.

Codex: Rate-Limit Resets
https://community.openai.com/t/flexible-rate-limit-resets-for-codex-and-a-method-to-get-a-reset/1383470
The primary update for June 2026 is the introduction of banked rate-limit resets. How it works: if you do not exhaust your limit within a 5-hour window, the remaining portion is "banked" and saved as a separate reset to be used later. These are not API credits or monetary balances, but rather an additional limit strictly within the ChatGPT subscription. It remains valid for 30 days from the date of accrual.

Each Plus/Pro user has received one free reset, and up to three more can be earned through referrals until June 24. Some users did not see them appear until their first referral. Banked resets can be activated via the Codex desktop app under Settings → Usage remaining. Note: CLI and VS Code plugin users (as well as some Linux users) currently lack a native way to activate them and must use the desktop app. Unofficial community scripts for CLI workarounds have already emerged.

Additionally, a Codex Profile screen has been introduced, displaying usage stats and token activity graphs, which is particularly useful with the transition to token-based billing.

Codex-Maxxing: A Guide for Long-Running Sessions
https://openai.com/index/codex-maxxing-long-running-work/
OpenAI has published an official PDF guide / white paper titled Codex-Maxxing. This guide outlines how to utilize Codex as a persistent working agent handling long-term projects, rather than just answering individual queries. OpenAI envisions a future that goes beyond starting a new chat every time.

The term "Codex-maxxing" is used here to describe an approach: rather than simply asking questions, users build an entire workflow system around the agent:

• Codex can and should work with more than just code. It can control a computer, browse the web, or have MCP access to email, calendar, etc.
• Instead of separate chats, use durable workflows (Durable Threads) with accumulated project history and context compaction.
• Agent memory should be visible and isolated. Repositories store code, while a separate folder (Vault) stores context, decisions, open loops, current state of work, etc.
• Steering (guidance during execution): Instead of assigning a task and waiting for the final result, you monitor the progress in real-time and provide adjustments along the way. This interaction resembles collaborating with a human colleague: you focus on the work itself (documents, code) rather than the chat window, providing feedback on specific parts.
• Voice over text + mobile access: OpenAI believes that typed queries are often over-edited. Voice input allows users to convey emotions, raw ideas, and unstructured thoughts that modern models can process effectively. You can discuss progress with the agent on your phone while walking, while it performs tasks on your computer.
• Utilizing Heartbeats (Thread Automation): scheduled automatic checks that allow the agent to monitor repository states or CI pipelines without human intervention. The agent does not wait for a new message from the user; it returns to the task according to a schedule.

Tasks are defined by clear, verifiable exit criteria (e.g., "achieve 100% test coverage" or "reduce deployment time by 30%"), and the agent works autonomously with regular checks until they are met. A poorly formulated task is "Implement the entire plan," whereas a well-formulated one is "Port the library to Rust, keep the API compatible, and consider the task complete only when all legacy tests pass successfully."

#codex #newllmmodel

Comments

Chinese AI services continue to gradually catch up with their US counterparts.

TRAE Solo is now Work
https://solo.trae.cn/
https://docs.trae.ai/solo/what-is-trae-solo?_lang=en
ByteDance has renamed its "Trae Solo" tool to Trae Work, highlighting a shift in positioning: from a simple developer assistant to a fully autonomous "AI employee" for various tasks (data scraping, content creation, web research, etc.). Code remains as a separate tab, and a GitHub connector is available. The interface resembles the Codex app, featuring Skills and an MCP with a catalog. The tool is accessible via web, desktop, and mobile. By default, "Privacy Mode" is disabled for new accounts, so users need to enable it manually.

The Capable GLM-5.2
https://docs.z.ai/guides/llm/glm-5.2
https://artificialanalysis.ai/articles/glm-5-2-is-the-new-leading-open-weights-model-on-the-artificial-analysis-intelligence-index
Zhipu AI has released GLM-5.2 — a 753B parameter Mixture-of-Experts (MoE) model under the MIT license, which significantly improves upon GLM-5.1. The context window has been expanded to 1M tokens (compared to 200k in its predecessor).

https://www.youtube.com/watch?v=nODxez6nZEU

The model ranked first among open-source models in the Artificial Analysis Intelligence Index (v4.1) with a score of 51, demonstrating coding skills on par with the proprietary Claude Opus 4.8. While it tends to get confused more easily and consumes more tokens overall, it still delivers results.

Discussion
https://news.ycombinator.com/item?id=48567759
On Hacker News, the model is praised for its price-to-performance ratio in long-running development cycles. However, users note that the "Max" reasoning mode is extremely slow and highly token-intensive. Due to its large size (753B), running it locally on standard MacBook Pros is not possible, but users can rent GPU cloud instances or access it via https://openrouter.ai/z-ai/glm-5-2#providers.

Current top coding models on OpenRouter by usage volume (token count):

1. MiMo-V2.5 (by xiaomi) — the clear leader with 4.59T (trillion) tokens, representing 22.5% of the total market share.
2. MiniMax M3 (by minimax) — holds second place with 2.45T tokens (12.0%).
3. Hy3 preview (by tencent) — third place with 1.43T tokens (7.0%).
4. Claude Opus 4.7 (by anthropic) — fourth place, accounting for 1.17T tokens (5.7%).
5. DeepSeek V4 Pro (by deepseek) — closes the top five with 1.14T tokens (5.6%).
6. DeepSeek V4 Flash (by deepseek) — sixth place with 972B (billion) tokens (4.8%).
7. GLM 5.1 (by z-ai) — seventh place with 952B tokens (4.7%).
8. GLM 5.2 (by z-ai) — eighth place with 820B tokens (4.0%).

GLM-5.2 on OpenCode
https://dev.to/danielbergholz/testing-glm-52-on-opencode-im-impressed-1780
The article's author, Daniel Bergholz, tested the model in real-world development conditions by integrating GLM-5.2 via OpenRouter into the free coding agent OpenCode.

In a practical test on an actual Next.js project, the model was tasked with implementing an article search feature with a 300ms debounce without cluttering the browser history. GLM-5.2 proved to be a somewhat slow but highly deliberate model: during the planning phase, it analyzed the project structure without additional prompting, recognized the difference between server and client components, and logically justified using client-side rendering for this task. It wrote clean, working code on the first attempt ("one-shot") and demonstrated a rare "restraint" for AI assistants by not trying to overcomplicate the existing project structure.

The entire session, which included repository analysis, planning, coding, review, and the final fix, cost the author only $0.265 (less than 27 cents).

#trae #glm #top #opencode

Comments

Code generation quality continues to improve, but the US government is trying to restrict access for others.

Fable 5 — Pulled in 3 Days
https://www.anthropic.com/news/claude-fable-5-mythos-5
https://support.claude.com/en/articles/14328960-identity-verification-on-claude
On June 9, 2026, Anthropic introduced Claude Fable 5, a model of the new Mythos class. Tests showed a record level of autonomy (including completing games using computer vision) and exceptional performance in code generation.

https://www.youtube.com/watch?v=LoIGVdfTq9M

However, just 3 days later, access to the models was suspended. The US government issued an export directive prohibiting foreign nationals from using these models. Unable to immediately filter out foreign users, Anthropic disabled the models for all customers.

To resolve the issue, the company is launching mandatory identity verification (ID + selfie) via the Persona service. While the verification process is global and supports documents from most countries, access to the flagship Fable 5 will only be granted to verified US citizens and residents due to US regulations.

Discussion
https://news.ycombinator.com/item?id=48618455
The Hacker News community reacted highly negatively to these changes. Many international developers point out that paying for an Anthropic subscription is now pointless since they won't get access to future flagship models. The introduction of Persona verification raises serious privacy concerns, while the sudden shutdown of Fable 5 has undermined trust in US SaaS platforms as a reliable foundation for business.

Although this flagship model currently remains available only to a select group—namely the military and Anthropic employees—I believe this is temporary. OpenAI is clearly preparing its response with GPT-6, and Google is also actively developing in this direction. Therefore, the widespread availability of next-generation models with a qualitatively new level of autonomy and code generation is only a matter of months. Let's wait and see.

#anthropic #fable5

Comments

Chinese AI giant MiniMax has announced a new generation of M models: M3.

MiniMax M3
https://www.minimax.io/blog/minimax-m3
https://www.minimax.io/models/text/m3
MiniMax M3 is built with an emphasis on deep reasoning, coding, and autonomous pipelines. It accepts text+image+video as input and produces text as output. The model is specifically optimized for agentic workflows and complex, long-term tasks rather than simple chat interactions.

MiniMax Sparse Attention (MSA) is a new sparse attention mechanism that radically reduces computational costs for long contexts (approximately 1/20th of the previous generation). It supports up to 1M tokens, with a guaranteed minimum of 512K in the cheaper API version. Token Plans are available (starting at $20/month), with a highlighted $50/month option.

Benchmarks look impressive: SWE-Bench Pro ~59% and Terminal-Bench 2.1 ~66%. This is on par with GPT-5.5 and Gemini 3.1 Pro, trailing only Claude Opus 4.8.

There is no active discussion on Hacker News yet.

MiniMax Code Updates
https://code.minimax.io/
With the M3 update, MiniMax Code has also received a significant upgrade, fully utilizing the model's capabilities: long context, agentic skills, and native multimodality. The program can not only generate code but also create documents, PDFs, slides, tables, and icons. Thanks to multimodality, MiniMax Code supports "computer use" (controlling the computer).

The concept is built around delegation - you don't write code alongside the AI; you manage it. It uses a Producer + Verifier adversarial loop where agents constantly generate, reflect, check, and fix errors in real-time. There is a "Smart Authorize" option to avoid manual monitoring of every agent action.

https://www.youtube.com/watch?v=mBHFGeU18MI

There is native support for MCP servers to connect external databases and documentation. It features a skills marketplace and integration with bots in Telegram, WeChat, and Lark for managing agents from a phone. Autonomous operation for several days without human intervention is possible, as well as scheduled task execution.

#minimax #agenticcoding #desktopapp

Comments

Microsoft presented a series of changes at its May Build 2026, shifting from simple AI assistance toward autonomous agents.

Proprietary MAI Models
https://microsoft.ai/news/building-a-hillclimbing-machine-launching-seven-new-mai-models/
They introduced a new family of MAI (Microsoft AI) models, totaling 7, including MAI-Code-1-Flash and MAI-Thinking-1. Microsoft is effectively reducing its dependence on OpenAI. The company claims frontier-level results for autonomous tasks.

The MAI-Code-1-Flash model has 5B active out of 137B parameters (medium-sized) and a 2-million-token context window (extremely large), operating with record-low latency. Presentation slides look perfect: they claim it outperforms previous generations of the flagship GPT-4o. It is being positioned as the core engine for pipelines integrated into GitHub Copilot, VS Code, and other MS products.

Discussion
https://news.ycombinator.com/item?id=48374466
In a active Hacker News discussion, people note that open models like Qwen 3.6 (35B) or DeepSeek V4 Flash yield better results and run significantly faster, while GitHub Copilot's new strict token billing might make using MAI-Code-1-Flash economically unviable.

GitHub Copilot — Now a Separate App
https://github.blog/2026-06-02-github-copilot-app-the-agent-native-desktop-experience/
Copilot used to be a plugin in VS Code, then became part of it. Now, following Codex, Cursor, Zed, and others, Microsoft decided to create a standalone GitHub Copilot App — an "agent-native" desktop chat application.

This is a single control plane for agents working in parallel across isolated git trees, creating PRs, and debugging code. MS are moving away from the editor concept toward delegating entire workflows. It includes support for MCP servers.

https://www.youtube.com/watch?v=5Q5mLNYJ6Hw

Instead of getting lost on the GitHub website, the app features a convenient "On your radar" (or Inbox) tab where all your Pull Requests (PRs) and Issues from selected repositories are gathered. You can open any PR, view code changes (diff), leave comments, or approve it. Furthermore, you can tag @copilot directly in comments for fixes or explanations.

Users can create "quick chats" for general questions (even non-code related, like D&D games) or sessions tied to a specific repository. The app allows switching between different LLMs. For instance, the author uses Claude Opus 4.7 for code generation.

Agent Isolation: MXC (Microsoft Execution Containers)
https://www.microsoft.com/en-us/security/blog/2026/06/02/microsoft-build-2026-securing-code-agents-and-models/
Since agents now execute real code and interact with systems and infrastructure, Microsoft is implementing MXC at the Windows 11 kernel level. This is a new level of isolation and sandboxing specifically for AI applications. Windows is essentially turning into an "Agent Runtime" platform.

The demonstration showed OpenClaw attempting to delete all files from the desktop and failing due to these restrictions.

#githubcopilot #mai #agenticcoding

Comments

More new models of May.

Cursor Composer 2.5
https://cursor.com/blog/composer-2-5
On May 18, 2026, the Cursor team released Composer 2.5. It is based on the open Kimi K2.5 model from Moonshot AI, but now approximately 85% is Cursor's own fine-tuning. The main change compared to Composer 2 is increased autonomy and cost optimization.

The model offers two tiers: Standard at $0.50 per 1M input / $2.50 per 1M output tokens, and Fast at $3/$15. In SWE-Bench Pro tests, it achieved a 49% success rate (compared to 12% in Composer 2), meaning coding skills and context understanding have grown significantly at a reasonable price.

Qwen 3.7 Max
https://qwen.ai/blog?id=qwen3.7
On May 20, 2026, at the Alibaba Cloud Summit, Qwen 3.7-Max was announced. Unlike the previous Qwen 3.6 line, which focused on general tasks, the new version is positioned exclusively as an agentic model for ultra-long autonomous work cycles. The key change is stability during long-running tasks.

Alibaba demonstrated a case where the model fully autonomously optimized a GPU kernel over 35 hours without any human intervention, performing over 1,100 tool calls. The context window was expanded to 1 million tokens (up from 256k in its predecessor), and the "reasoning density" per token was increased.

Qwen 3.7-Max can generate complex interactive web applications from a single prompt—including 3D scenes on Three.js, Canvas animations, full-page layouts, and dynamic SVGs.

https://openrouter.ai/qwen/qwen3.7-max
There is currently a 50% discount on the model at OpenRouter ($1.25/$3.75), making Qwen 3.7 Max perhaps the best choice for price/performance in long-running tasks.

Claude Opus 4.8 — fewer hallucinations and more control
https://www.anthropic.com/news/claude-opus-4-8
On May 28, 2026, Anthropic introduced Claude Opus 4.8 (pricing remains the same as 4.7 at $5/$25 per million tokens) and once again topped the Artificial Analysis global rankings with a score of 61.4, overtaking GPT-5.5.

Instead of focusing on abstract benchmarks, Anthropic prioritized system "honesty": the model learned to directly state "I don't know" or ask for clarification, and it misses hidden bugs in its own code 4 times less often than Opus 4.7.

Dynamic workflows appeared in Claude Code. Now Opus 4.8 can independently plan large-scale tasks, launch parallel sub-agents, and verify results before submitting the work.

#cursor #qwen #claude #claudecode #newllmmodel

Comments

Google at May I/O 2026 has already begun "tightening the screws" and radically reshaping its infrastructure for developers.

Gemini 3.5 Flash
https://deepmind.google/models/gemini-3-5-flash/
The main "engine" of the announcement was the Gemini 3.5 Flash model, which precedes the upcoming 3.5 Pro. Google claims the model works significantly faster than previous generations and shows frontier-level results in agentic coding tasks: ~76.2% on Terminal Bench 2.1 and ~55.1% on SWE-Bench Pro.

The new Flash is significantly more expensive than the previous one, and the massive use of agents quickly burns through tokens and compute.

$100 Plan
https://blog.google/innovation-and-ai/technology/ai/google-io-2026-all-our-announcements/
Google is introducing a new tariff plan — Google AI Ultra for $100 per month, which provides higher limits for using agents in Antigravity. The more expensive enterprise tier is also being updated: instead of simple message limits, a "compute-used" model is increasingly being adopted — actual payment for agent resources and execution.

Everything will be Antigravity
https://antigravity.google/blog/introducing-google-antigravity-2-0
Previously, Project IDX was based on Code OSS (open-source VS Code). Now the strategy has changed: Google is actively shifting focus from IDX and Firebase Studio toward Antigravity.

Instead of fragmented tools, Antigravity 2.0 is now being promoted — an "agent-first" development platform following the chat-centered approach popular in recent months. This is a direct response to the Codex app and Cursor 3, but with full control by Google over the execution environment, sandboxing, and agent orchestration. They are also moving away from "VS Code-like" editors, but have radically removed the text editor altogether.

https://www.youtube.com/watch?v=3arUEZlv9mc

Judging by the low activity on Hacker News and early feedback on Antigravity 2, it seems many developers haven't switched to active use of the tool after launch — it is perceived more as another experimental AI-IDE than a stable work tool.

From Gemini CLI to Antigravity CLI
https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/
Google officially announced the sunsetting of old tools. Most notably, from June 18, 2026, Gemini CLI (open source, daily quotas) and the Gemini Code Assist extension will disappear — they will stop serving requests for free users and even for AI Pro/Ultra subscribers, remaining available only for Enterprise.

Google is effectively shifting focus from Gemini CLI and Gemini Code Assist to the new Antigravity CLI (closed source), which becomes the primary terminal tool for agentic workflows. Quotas now look less like "number of prompts" and more like a compute usage model — how many agents and resources you actually use. Currently, it performs poorly and is gathering bug reports rather than serving as a developer tool.

In addition to Google's models, two Claude models from Anthropic and, for some reason, GPT-OSS 120B from OpenAI are available. That's it.

Native Android in Google AI Studio
https://android-developers.googleblog.com/2026/05/build-android-apps-google-ai-studio.html
In Google AI Studio, you can now generate a native Android app (Kotlin/Jetpack Compose) from a prompt and run it in an emulator directly in the browser.

If a project becomes complex, Google offers "seamless" export to Android Studio for further agentic development.

#gemini #geminicodeassist #antigravity #newllmmodel

Comments

A few interesting updates for May. Amidst the news about xAI, Anthropic also surprised many by announcing a partnership with SpaceX on May 6 to expand their computing power.

Anthropic Discounts and Transition to New Pricing
https://www.anthropic.com/news/higher-limits-spacex
Anthropic announced a temporary "spring discount" on their API models. They also stopped blocking OpenClaw-style usage. However, this is likely an attempt to smooth things over before big changes: the company is increasingly hinting at a revision of the classic "fixed subscription — unlimited chat" model. Instead of "per token" payment, Compute-based pricing is being introduced. The cost of a request will depend on how many computing resources the model spent on "reasoning."

Claude Code Updates
https://code.claude.com/docs/en/whats-new#week-18
On Windows, Claude Code finally no longer requires Git Bash; if it's missing, the tool now natively uses PowerShell.

Cloud functions. Public access (research preview) was opened for a new command /ultrareview, which spins up several autonomous AI agents in the cloud to check the repository for vulnerabilities and bugs in parallel. Before this, they also launched the /ultraplan command — a large planning task is pushed to Anthropic servers, where an isolated virtual machine is spun up for it (4 CPU cores, 16 GB RAM, with Node.js, Python, Rust, Docker, etc., pre-installed), eventually providing a link to a web interface with the results.

Managing OpenAI Codex from Mobile
https://openai.com/news/codex-mobile-app/
Responding to a similar feature in Claude Code, OpenAI released an update for Codex that allows managing AI agents from a smartphone. Now developers don't have to be near a laptop: they can approve pull requests, run testing pipelines, resolve merge conflicts, or give prompts to fix small bugs on the go. The interface is fully optimized for voice and quick commands — essentially, it's a pocket remote for the agent on your computer.

Gemma Models in Gemini CLI
https://geminicli.com/docs/changelogs/
The Gemini CLI terminal client update (v0.40.0) added experimental integration for local Gemma models. Version v0.41.0 added support for Gemma 4 models (experimental). While intelligent Model Routing and full offline agent execution are not yet available, the team is already preparing full local task execution.

Memory handling was also improved. Tiered Memory allows the agent to store context directly in Markdown files across four levels: from global developer styles (in ~/.gemini/GEMINI.md) to specific project directory rules. A new Auto Memory feature background-analyzes old sessions, finds successful solutions, and suggests saving them as reusable skills in SKILL.md. Auto Memory Inbox (from v0.42) is a system that automatically collects, classifies, and surfaces important pieces of information for an AI assistant’s long-term memory.

Voice mode has also been improved.

#codex #anthropic #gemini #claudecode

Comments

Speaking of the major LLM players, xAI is the only one that hasn't been monetizing developers and programmers until now. It seems they are starting to change that.

Cursor and xAI
https://techsifted.com/posts/spacex-cursor-acquisition-april-2026/
SpaceX/xAI has secured an option to acquire Cursor for $60 billion. If the acquisition does not go through, Cursor will still receive $10 billion for partnership and joint R&D work. This is a right to buy the company later at a fixed price.

In March, several key Cursor engineers moved to xAI. In May, Cursor began a massive international expansion and hiring push. If xAI's infrastructure makes future versions even more powerful, most Cursor users will likely stay.

The developer reaction has been mixed. Part of Cursor's audience chose it specifically for its independence—not being OpenAI, Microsoft, or Google, but offering any model of choice. Now that the service is potentially joining Elon Musk's ecosystem, it remains unclear whether this will impact the priority of the Grok model.

Fine-tuning Grok on Cursor Data
https://x.com/elonmusk/status/2055914584373141906
On May 17, xAI completed the primary training of the massive Grok V9 model (1.5 trillion parameters). The next stage is supplemental training using data from Cursor. This will allow Grok models to significantly improve their coding skills, as Cursor has collected a vast database of high-quality code from developers.

Grok Build CLI Launch
https://x.ai/news/grok-build-cli https://x.ai/cli
On May 14, xAI released an early beta version of Grok Build—a code generation agent: task planning, sub-agents for parallel work, headless mode for scripts, support for AGENTS.md, diffs, plugins, etc. It’s a fully-featured tool and a direct competitor to Claude Code and similar instruments.

However, it is currently only available with a SuperGrok Heavy subscription ($300/month with a three-day trial) and runs in the terminal only on Linux/macOS (Windows via WSL). Updates are released almost daily, and users are already praising its speed and quality. Elon Musk is personally asking for feedback.

https://www.youtube.com/watch?v=l_dAOKHLiYw

xAI is currently offering a promotional SuperGrok Heavy subscription: instead of $300 per month, the rate is temporarily around $99 for the first six months. However, users are complaining that even the Heavy plan doesn't feel "unlimited," as real limits can change depending on system load.

#grok

Comments

AI Didn't Delete the Database
https://idiallo.com/blog/ai-didnt-delete-your-database-you-did
A tweet went viral: a startup founder claimed an AI agent deleted their production database in seconds. He was outraged, questioning the model and blaming "bad AI." However, the author argues: it's not the AI's fault. The issue was a public API endpoint in production that could destroy the entire database with a single request.

It's like placing a self-destruct button in plain sight and being surprised when someone presses it. Ibrahim Diallo says the AI didn't delete the database—the developers did by using unsafe architecture, lack of protection, and irresponsibility. The AI simply discovered what they carelessly left behind.

Discussion
https://news.ycombinator.com/item?id=48022742
Most people fully agree: it's not the AI's fault, but rather the person who gave the agent unrestricted production access without limiting API token permissions or setting up safeguards. A tool can be dangerous, but responsibility always lies with the operator. Many criticize "AI-maximalism"—when developers enthusiastically grant agents full access instead of using sandboxes and reviews.

10 Lessons for Agentic Coding
https://www.dbreunig.com/2026/05/04/10-lessons-for-agentic-coding.html
Thanks to modern AI agents, code has become extremely cheap to create but expensive to maintain, secure, and support. This completely changes the development approach: the key is no longer saving on writing code, but wisely utilizing its low cost.

1. Implement to Learn.
2. Rebuild Often.
3. Invest in End-to-End Tests.
4. Document Intent.
5. Keep Your Specs Synced.
6. Find the Hard Things.
7. Automate Everything Easy.
8. Develop Your Taste.
9. Agents Amplify Expertise.
10. Code is Cheap, but Maintenance, Support, and Security are Not. Agentic code is "free as in puppies." Maintenance isn't cheap, and neither is security. Build fast, but remember the maintenance burden you are taking on.

Discussion
https://news.ycombinator.com/item?id=48019025
The discussion is active and mostly positive—many consider this one of the most practical and sober publications on working with AI agents. Most agree: code is extremely cheap, so focus must shift to architecture, security, E2E tests, maintenance, and "taste." Skeptics argue that coding is only a small part of the job; business and organizational bottlenecks remain, and in large companies, development speed isn't the primary constraint.

#bestpractices

Comments