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

Zed released in version 1.0
https://zed.dev/blog/zed-1-0
Just as Cursor bumped its major version after an interface overhaul, the code editor from the creators of Atom officially reached 1.0 on April 29, 2026. They write: "we've reached a tipping point where most developers can quickly feel at home in Zed."

Built with Rust, it features GPU acceleration, collaborative mode, built-in Git, a debugger, and AI (native and via Agent Client Protocol). Available on macOS, Windows, and Linux. Along with the release, it gained the ability to run multiple agents simultaneously in one window.

Discussion:
https://news.ycombinator.com/item?id=47949027
Many praise the speed, collaboration, native feel, and progress. There is criticism regarding project-specific configuration, AI features (which can be disabled), accessibility, and some minor nuances. Lots of practical feedback from those who switched or tried it.

Warp goes fully open source
https://www.warp.dev/blog/warp-is-now-open-source
On April 28, the AI terminal client Warp became open-source (AGPL for the core code + MIT for the UI framework). Now the community can contribute, including developing agent-first workflows through their cloud agent/orchestrator Oz.

Following the open-sourcing of the Warp client, a popular community fork called OpenWarp (https://openwarp.zerx.dev, zerx-lab) emerged. The project quickly gained popularity. It retains all the familiar Warp functionality (blocks, workflows, speed, UI) but, most importantly, fully opens the AI layer: you can connect any OpenAI-compatible provider (DeepSeek, Qwen, Ollama, OpenRouter, LM Studio, etc.), set custom system prompts via templates, and keep all keys locally without depending on a Warp cloud account or paid plans.

GitHub Copilot moves to usage-based billing
https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/
Starting June 1, 2026, all plans will transition to a usage-based model with GitHub AI Credits (1 credit = $0.01). Code completions remain unlimited, while chat, agents, CLI, and other heavy features consume credits based on tokens.

GitHub explains the transition by stating that Copilot is no longer just the simple autocomplete tool it was a year ago—it now includes powerful agentic workflows, chats, code reviews, and complex agents that consume significantly more compute resources. Fixed subscriptions no longer cover the costs.

Discussion:
https://news.ycombinator.com/item?id=47923357
Many understand the reasons (expensive agents and inference) but complain heavily about the loss of predictability, rising costs for power users, and multipliers for powerful models. Tools are available to estimate future bills.

Vibe with a new model and cloud
https://mistral.ai/news/vibe-remote-agents-mistral-medium-3-5
Mistral introduced a new agentic model, Medium 3.5 (128B, 256k context), and made it the primary model in the Vibe CLI. They also added remote agents that run asynchronously in isolated cloud sandboxes (similar to Codex or Claude Code) for long-running tasks. These can be launched from the CLI or the Le Chat web interface with history synchronization.

#zed #mistralvibe #wrap #githubcopilot

Comments

Zed Agent Interface
https://zed.dev/blog/parallel-agents
Following Cursor's lead, Zed is adapting its interface to manage multiple agent chats simultaneously. The main innovation is the Threads Sidebar, which helps group threads by project, flexibly configure agent access to repositories, and track their progress. AI panels have been moved to the left, while files and Git are now on the right.

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

Discussion
https://news.ycombinator.com/item?id=47866750
Many programmers are dissatisfied with the interface changes, noting that running several agents simultaneously creates a massive "cognitive load" and complicates code review, as AI still generates too much "garbage" code. Users also mention the unfinished Git interface and the lack of proper code review tools—issues that should be addressed first.

The biggest pain point remains the isolation of databases, configurations, ports, and test data. Developers are actively discussing how to automate this: some write custom shell scripts, some use Devcontainers, while others praise third-party tools like Conductor or Ouijit for managing the lifecycle of such environments.

Claude Design
https://www.anthropic.com/news/claude-design-anthropic-labs
Anthropic introduced a specialized AI tool based on the new Claude Opus 4.7 model and a design system (DESIGN.md) tailored for the product design process. It creates fully functional interactive prototypes, presentations, landing pages, and UI components, outputting ready-to-use HTML, CSS, and JavaScript code in real-time.

A one-click export allows users to transfer the finished design directly into the Claude Code environment.

#zed #claudecode

Comments