CodeWithLLM-Updates
-

SOTA parade: GPT-6 Astra, Claude Fable 5.1, Muse Spark 1.3, Gemini 3.8 Flash and the post-train Qwen 3.8 Max 0902.

Muse Spark 1.3
https://research.meta.ai/blog/introducing-muse-spark-1-3 
On their benchmarks it looks beautifully straight SOTA, but the real results don't add up: it loses skill instructions, instead of a targeted edit it may rewrite the whole file, generated websites look rough. Just like models a year ago. Separately, the cheap contributor pricing continues as dumping. Meta writes that an open-weights release for Muse Spark is ahead.

Gemini 3.8 Flash 
https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/ 
No Pro for a long time now, this is the third Flash update in six weeks, tuned for long agent coding sessions (which suits us), available immediately in API, AI Studio, Antigravity. The cheap price was kept until the end of the year. It can work in small iterations — "works harder", but that's exactly why on hard tasks it eats more tokens, Google itself says so. The Cyber version is only for trusted defenders.

Claude Fable 5.1 
https://www.anthropic.com/claude/fable 
Improved to Fable 5.1 (generally available) + Mythos 5.1 (limited). Expensive, but top. They say it was taught not to report fake success and not to cut corners like disabling a failing test. Long autonomous runs need less babysitting, review is faster. Its writing became more human, but it invisibly marks text (watermarking), on HN they separately praise that the templated feel is gone.

GPT-6 Astra — finishes long tasks, but eats your limit 
https://openai.com/index/gpt-6-astra/ 
As of September 7, GPT-6 Astra has been publicly available for only a few days. OpenAI positions it not so much as a model for "generating working code" but for independently going through the whole software engineering cycle. Very cool game demos, plus the ability to "take over" Blender and Unity or Godot via computer use. It's all long and expensive, but it gets to the result.

The docs explicitly emphasize: complex reasoning, coding, computer use, research and long multi-step tasks. Astra can work with a repository, run programs, see results, fix errors, continue work after requirements change and, in Codex, even ask questions asynchronously without stopping independent parts of the work.

Astra has 1M tokens, but the actually available context in a specific Codex environment can be much smaller. OpenAI also introduced a new context-preservation mechanism: instead of the usual constant compaction of old sessions, the model can keep notes between windows, with previous context windows remaining searchable.

In Terminal-Bench 4.0 data there is almost no gap between Astra and Fable 5.1. But Astra itself feels more autonomous and like one that understands the repository (although not always). Excessive usage/token budget consumption is already noticeable. On Reddit there are several reports of Astra burning a significant part of the five-hour limit in literally one session. In my Codex on a Plus subscription it ate the 5-hour limit doing a simple task in less than 15 minutes, I suspect that window was tightened even further.

In today's usual way of working the programmer is an AI operator: prompt → got code (diffs) → checked → threw in fixes. With Astra another mode becomes increasingly realistic, where the programmer sets intent, constraints and completion criteria, after which the model unwinds the process itself. The main upgrade in Astra is not that it generates unbroken code, but that it is increasingly often (but not always) able to drive the whole task to completion.

It looks like Google, following Anthropic, is trying to restrict its subscription-plan models to its own harness only, making it harder to use those credentials in third-party AI agents.

https://news.ycombinator.com/item?id=49548452
 A week ago in a discussion there were reports of Google accounts being blocked for using Antigravity via third-party tools. Google explicitly calls using credentials in a third-party tool a ToS violation that can lead to account blocking. There is a separate comment from a user whose access was blocked after using Pi agent + Antigravity.

https://github.com/can1357/oh-my-pi/issues/11689
Yesterday, for people in oh-my-pi (OMP), Gemini via Antigravity suddenly started consistently returning 429 RESOURCE_EXHAUSTED and asking to wait 30 minutes — and this lasts for hours. This is not quota exhaustion, but an entitlement mismatch — Google is cutting the agent bucket for third-party harnesses under the guise of RESOURCE_EXHAUSTED.

OMP is a fork of Pi, and OpenClaw also uses Pi as the base for its agent runtime. So the problem potentially affects a whole branch of third-party agents.

Cline is also building a native Desktop app.

Cline's biggest upgrade
https://cline.bot/blog/how-we-migrated-11-million-users-to-clines-biggest-harness-upgrade
Cline started in 2024 as a VSCode extension, back in the days of Claude 3.5 Sonnet. Each new model and provider had to be adapted manually. The new Cline SDK has been extracted into a separate modular runtime: prompts rewritten, loop simplified, context and tool definitions updated for native tool calling of 2026-era models instead of XML tags parsed from text. All 11M users have now been fully migrated to it.

Cline for Desktop (Beta)
https://cline.bot/desktop
https://github.com/cline/cline/releases/
They started testing a separate native app for macOS (Universal) and Windows — as is trendy now — without a code editor. Inside is the same open-source Cline harness now used in the IDE and CLI. Built with Tauri 2 + Bun-sidecar + Next.js: Tauri handles only the window and updates, the Bun sidecar runs Cline Hub and talks to the UI over websocket, the frontend is Next.js.

It works via BYOK — Anthropic, OpenAI, Gemini, open-weights or a local endpoint, models can be switched right in the middle of a project. Integrated with their Cline Pass subscription for $9.99/month for open-weights models such as GLM 5.3/5.2, Kimi K3/K2.7 Code/K2.6, DeepSeek V4 Pro/Flash, MiniMax M3, MiMo V2.5/Pro, Qwen 3.7-Max/Plus and 3.8-Max.

Already has queued messages to add edits while the agent is working, fork & edit — edit an old message and the session forks with the workspace reverted to a checkpoint, session history in one place — desktop, CLI, extension and scheduled runs, with a filter for session origin.

On my Windows machine it still throws a bunch of errors when configuring models and doesn't work.

Memory in Grok Build, Zen vs third-party harnesses, a completely different Jev, and Geiger.

Geiger for finding AI agents
https://atomburst.io/geiger
If, like me, you're constantly testing agents, one command npx geiger-scan shows what's actually installed and what it can touch. Zero dependencies, no account and no telemetry, you only need Node 18+. It only reads configs and folders, it doesn't launch anything it finds. It only writes a report file you explicitly request via --json / --html. Finds many known agents and IDEs. Separately, global and project MCP servers including remote ones, editor and browser extensions, AI browsers.

Memory in Grok Build
https://x.ai/news/grok-build-memory
Grok Build now remembers the project between sessions: conventions, decisions, facts. After each step it reviews it in the background and appends only what's durable, while work doesn't stop. These are markdown files, one file per topic. There's a project level and a separate global one for user habits.

The /memory command opens a simple grouped file view with search and preview, /dream organizes fresh stuff by topic and sometimes cleans up in the background on its own. Background Dream cleanup runs single-threaded via dream_lock, old stuff goes to archive.

OpenCode Zen cuts off third-party harnesses
https://github.com/can1357/oh-my-pi/issues/12306
Similar to the Antigravity story from last week (by the way OMP fixed it with a separate plugin), here the gateway cuts out outsiders. Without the x-opencode-client, x-opencode-session, x-opencode-project, x-opencode-request headers and tool profiles, Zen, especially for free models, responds with 429 FreeUsageLimitError or just hangs. Pi extensions now imitate these headers with random ids to look like the CLI. In the threads this is called identity spoofing with a risk of a full account ban.

A completely different model — Jev / System One from TypeSafe
https://console.typesafe.ai
https://typesafe.ai/blog/introducing-system-one-models-and-jev
The first Jev model is named after Jevons. This is not chat, but System One after Kahneman: state in, ready-made decisions for code out.
Send state as text, JSON or array plus a list of typed questions Choice, Score, Noul — and in a single parallel pass you get all answers with calibrated probabilities.

New architecture, parallel sampler, RLCD training instead of RLHF / RLVR. The schema is fixed upfront, so there's simply nowhere to go outside the types or hallucinate text. Access is currently waitlist-only: endpoint POST api.typesafe.ai/v1/systemone, jev-latest is currently jev-1.13.0, plus jev-preview next to it, SDK for Python and JS, skill for Claude Code, key at console.typesafe.ai/settings/keys.

OpenHands went from agent to platform over agents in six months

OpenHands from agent to coordinator
https://www.openhands.dev/blog/introducing-agent-canvas
https://docs.openhands.dev/openhands/usage/agent-canvas/acp-agents
Previously OpenHands itself was an agent, now via Agent Client Protocol (ACP) it launches and serves harnesses like Claude Code, Codex and OpenHands itself on desktop. It was brought into the architecture back in spring, and over the summer it became the central scenario. Agent Canvas is now effectively the main interface from which you can run multiple agents in parallel, see files, commands, conversations, automations and attach remote backends. Added a clear context-window usage meter, a drawer with context usage info and manual compaction.

A new Agent Profile object appeared — a saved configuration of how exactly to start an agent. It holds agent type, model, credentials and scoped secrets, MCP servers, skills and more. Automations turned from a simple feature into an orchestrator with Agent Profile selection, export/import as JSON, configurable timeouts, conversation launch via plugin, cron, live execution phase, task result understanding, tags, view/manage permissions, auto-disable after a series of errors. Moving toward agent errors being caught automatically.

The usual git status run at agent startup executes a command from within the repository itself.

Manifold's GitSpawn vulnerability
https://www.manifold.security/blog/ai-coding-agents-git-hijack
Many CLI agents gather project context at startup via git status / git diff, and strangely, on some of them this happens before the workspace-trust prompt: on Qwen Code even before login, on Grok Build the first keystroke is enough. This allows running core.fsmonitor = <command> outside the agent's sandbox, with no approval dialog at all, under the user's privileges: SSH keys, tokens from shell config, cloud credentials, all repositories on disk.

Check .git/config before opening an agent that was obtained as a repo of files; you can also block it globally with git config --global core.fsmonitor false.

Seven agents were tested: Claude Code, Codex, Cursor, Goose, Hermes, Qwen Code, Grok Build. Already patched: Claude Code 2.1.196 (main path), Codex 0.131.0 (CVE-2026-19592), Cursor, Goose 1.44.0 (CVE-2026-72718, CVSS 7.0). In progress: Qwen Code (Alibaba SRC accepted the report — but hasn't fixed it), Grok Build, Hermes.

The deeper problem is that the agent's sandbox is an illusion here: any subprocess inherits the user's OS privileges and git's full trust model.

omp (oh-my-pi) — a Pi fork by Mario Zechner, rewritten for a real development workflow: sessions, subagents, slash commands, extensions. TypeScript + Rust on macOS/Linux/Windows without WSL.

https://omp.sh/docs/agents-and-roles
There are three layers:

  • Model — a specific provider and model (Claude, GPT…).
  • Role — a named slot: default for regular requests, smol for cheap small jobs, slow for deep thinking and review, plan, vision, commit, task, more on that later.
  • Agents and subagents — who exactly does the work (reviewer, scout, designer). The agent looks at the role, the role looks at the model. Out of the box: scout (fast read-only repo overview), designer, reviewer, security-reviewer, librarian (checking external APIs), task, sonic (mechanical edits).

When you change the model in the slow role, all future reviewer agents automatically switch to it. The agent harness picks them itself depending on the prompt.

https://omp.sh/docs/advisor
The special Advisor agent can be assigned a separate model that reads every step of the main agent (prompts, responses, reasoning, tool calls) and adds notes directly into the session, and sometimes can stop the whole flow right away if it is clearly going the wrong way!

It runs on its own context and a completely different model (preferably with a matching context window size): the main stream can run on Gemini 3.8 Flash, while the advisor is, say, Meta Spark 1.3 — different models look at the same work from different angles. The Advisor does not approve actions: the main agent must weigh each note against the request, not blindly obey it.

Enabled with two lines in the config, or via /advisor. Three levels of advice: nit — an uninterrupted aside (“this could be simplified”); concern — a risk or wrong direction, may interrupt the run; blocker — continuing is clearly pointless, the result will be broken. Subagents have no advisor by default.

The advisor idea has already been ported back to pure Pi: the pasky/pi-omplike-advisor port https://github.com/pasky/pi-omplike-advisor — a permanent read-only model that reviews the main agent's work on every step.

Models are updating so frequently now: Opus 5.5, GPT-6 Sol and Luna, MiMo-V2.6, Grok 4.7, and Step 5 Preview.

Grok 4.7. The model spends longer on complex tasks, self-verifies better and holds long context, plus it was trained to understand its own Grok Bot harness.

GPT-6 Sol and Luna. A fast and cheap tier to replace the GPT-5.6 family. Sol and Luna together cover the price-sensitive segment, while Astra remains OpenAI's flagship and most expensive model.

Claude Opus 5.5. The best model to date. Anthropic's successor to Opus 5: according to the company, on most tasks it matches the more expensive Fable 5.1, but costs 40% less. Sonnet 5.5 and Haiku 5.5 are promised "in the coming weeks".

Step 5 Preview
https://www.stepfun.com/step-5-preview
On September 20, Chinese company StepFun unveiled its new flagship for agentic work: an MoE with 600B total parameters and 27B active. Per their tests, strong in software engineering, above the Kimi K3 level. Fully open weights are promised by October 15 — for now there is only a placeholder repo on Hugging Face.

Top open-source model from Xiaomi
https://mimo.xiaomi.com/mimo-v2-6/article
Xiaomi released the MiMo-V2.6 series: the flagship MiMo-V2.6-Pro, the budget MiMo-V2.6-Flash, and MiMo-V2.6-Pro-UltraSpeed — the same Pro but with up to 20x faster output at the same quality. Xiaomi showed training live, streaming it during the release. Along with the models, the tech report, training environments, and all RL code were open-sourced.

Both main models are natively omnimodal (text, video, audio, images in one context) with a 1M-token window. Pro surpassed Kimi K3 and Qwen3.8 Max on the Artificial Analysis Intelligence Index, though it still falls short of closed models.

MiMo Code and MiMo Desktop
https://github.com/XiaomiMiMo/MiMo-Code
https://mimo.mi.com/docs/en-US/updates/feature/desktop
The terminal open-source coding assistant MiMo Code is a fork of OpenCode under MIT with subagent orchestration and a built-in free MiMo Auto channel. It now runs on V2.6 models. MiMo Desktop moved from early access to its first official release alongside V2.6. It is a desktop client for task agents, browser control, and interactive previews of results right in the session.