Although Elon Musk's team looked close, Grok has stalled lately, and it was unexpectedly Zuckerberg's team that caught up with the leaders first. Google is back to SOTA as well.

Gemini 4 Argon access
https://blog.google/innovation-and-ai/products/gemini-app/gemini-4-argon-availability/
https://antigravity.google/blog/gemini-4-argon-in-google-antigravity
The first near-frontier model in a long time. After the September 30 announcement, when Argon was given only to cyber defenders, on October 13 Google rolled it out more broadly: the Antigravity desktop app and CLI + API on the Gemini platform. Per independent code-generation tests, it's obviously not at Opus 5.5 level, but it's already competitive with OpenAI.

The API has tricky intro pricing at $2 per Mtok of input / $10 of output, rising to $4 / $20 after November 30 — i.e. expensive. In Gemini web and app, Argon is on Pro and Ultra, but in Antigravity — Ultra only $100/200. https://one.google.com/about/google-ai-plans/#compare-plans

I don't like this trend of pushing a coding agent into a regular app, but Google backed it — macOS only for now: the Gemini chat app now has Antigravity option at the top.

Discussion
https://news.ycombinator.com/item?id=50073879
Unsurprisingly, $20 Pro subscribers in Antigravity are angry and demand Argon too. The main praise is for non-coding: crisp mini-essays, parameterized simulations, 3D visualization where ChatGPT 6 Pro and Opus 5.5 failed. Speed reports are polarized — from very fast to slow on agentic tasks, limits are conservative, context is 1M but people complain about auto-compact.

New Muse Wonder lineup
https://dev.meta.ai/models/muse-wonder/
https://dev.meta.ai/products/muse-code/
Two new closed models from Meta.ai — fast Wonder and full Wonder Full. Both with 1M context. Per their tests, top on DeepSWE 1.1 and SWE-Marathon, ahead of Claude Fable 5.1, GPT-6 Astra, and Claude Opus 5.5. Muse Code is a terminal coding agent for macOS and Windows. Multi-agent by default: it parallelizes workers, background reviewers, everything is audited. Plans are $5 Everyday / $15 High / $50 Power / $200 Maximum, with Wonder Full unlocked only on Power and Maximum.

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

The video breaks down the Muse Wonder + Muse Code combo for image and video generation — how to install Muse Code, select Wonder / Wonder Full. It shows creating images from text prompts, grounding with references, edits and turning a frame into a clip, previewing the result right in the session, and saving finished files.

Region block
Login from Muse Code via browser fails with Not available in your region — The Model API isn't available in your region right now. I didn't find a separate list of valid countries in the docs, but Ukraine currently appears blocked for the Model API, so Muse Code can't be logged in directly.

Uninstalling Muse Code
https://github.com/TerryZH/muse-code-uninstaller
Unofficial MIT uninstaller for macOS in Bash. Dry-run by default, just calculates how much space will be freed. Only deletes with the --uninstall flag, leaves the parent ~/.local/bin untouched. On Windows there is no entry in Add/Remove Programs, the installer writes itself to User PATH, plus it creates sandbox users muse-sbx-r1 / u1 and a MuseSandboxUsers group, profiles in C:\Users\muse-sbx-* and keys in ProfileList — after removal all of this has to be cleaned manually via takeown /f "C:\Users\muse-sbx-r1" /r /d y.

#musecode #gemini

Comments

OpenAI DevDay - Decisions API and GPT-6.1 Sol. New Sonnet 5.5 and Haiku 5.5 models, Mistral Large 4, Gemini 4 Argon.

Gemini 4 Argon. Announced, but no one has it yet. After a long pause, on October 1 Google showed its new flagship: SOTA-level on benchmarks in coding and security. But there is no access yet, so far only the US government and selected testers. https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/

Mistral Large 4 (Le Chonk). Their first release in a long time, but still far from SOTA models, lagging by about half a year, if not more. So far only paid access via API, with open weights promised for the end of the month. Vibe CLI for coding still runs on Medium 3.5 and Devstral 2 / Codestral, with Large 4 only callable via API. https://mistral.ai/news/mistral-large-4

OpenAI DevDay 2026 — what was shown for coders
https://openai.com/index/devday-2026-recap/
GPT-6.1 Sol — the main model for code. Almost Astra-level in coding and computer use, at a fifth of the price, but reasoning cannot be turned off completely, the lowest level is low. Already set as default in Codex and in Work. https://openai.com/index/introducing-gpt-6-1-sol/

Ultrafast — a paid fast tier. Up to eight times faster output in Codex, up to six times faster in the API, up to three hundred tokens per second. Astra Ultrafast is already available, Sol Ultrafast — coming soon. A new Pro 500 plan was introduced for it.

Sign in with ChatGPT — you can spend your plan in partner services, including Devin, Vercel, Notion.

Codex improvements: cloud work from laptop or phone, shared team environments, updated CLI with voice, /agents view, worktrees, and better scrolling of long sessions. Separately — in-app change review and Codex Security Cloud for checking repos and new pull requests with ready-made fixes.

OpenAI launched the Decisions API on GPT-6 Luna, a direct answer to Jev from TypeSafe - not a conversation, but a quick answer: how true a statement is, what to pick from a list, how to score against a rubric. It runs ten times faster than a regular Responses API response. Unlike Jev, the Decisions API also understands images, runs on the full GPT-6 Luna, so it handles complex cases better, but is more expensive. https://developers.openai.com/api/docs/guides/decisions

Claude Sonnet 5.5 and Haiku 5.5
Sonnet 5.5 came out September 28, Haiku 5.5 — October 7. Sonnet 5.5 is for daily coding work, Haiku 5.5 helps it with small tasks.

Sonnet 5.5 in some computer-use and terminal benchmarks even beats the larger Opus 5.5, but in the announcement its benchmark numbers are from Max mode, which uses significantly more tokens and is generally not recommended for everyday use. https://www.anthropic.com/claude-sonnet-5-5

Haiku 5.5 sometimes matches Sonnet 5.5, compresses conversations well, finds what you need in a pile of logs, cleans up junk before the big model. While the conversation is short, pricing is on par with GPT-6 Luna, but gets significantly more expensive after that. https://www.anthropic.com/claude-haiku-5-5

In Claude Code the short names sonnet and opus now point to 5.5. There is an opusplan mode: Opus makes the plan, Sonnet executes it. Subagents are recommended to keep on Haiku: exploration, compaction, first review of changes.

#claude #sonnet #haiku #openai #sol #codex #mistral #opensource #decisions #jev

Comments

DeepSeek Harness as a desktop app for macOS and Windows.

Desktop DeepSeek Harness
https://www.deepseek.com/en/harness/
Now in public preview worldwide and open source under MIT, on the Cordis "everything is a plugin" architecture. Desktop so far only macOS Apple silicon and Windows 64-bit, essentially an Electron shell around the full dsh Web. Works with lots of providers including local ones: Settings → Models, a huge dropdown plus a custom model API tab with base URL, protocol, and key.

Installs in literally a few clicks: download the dmg/exe, log in, settings and workspaces carry over, nothing is lost. During setup there is a profile choice — office tasks or code — and an answer detail level. Out of the box it covers everyday routine, code, research with citations, scheduled background tasks, and in-session previews of results.

Trajectory tab
The site highlights Developer tools separately: a full execution trace in real time — system prompt, turns, tool calls, payloads, schemas, timings. People call this the main edge over other harnesses: transcript as the product backbone, append-only context design without cache bugs, two-way communication with subagents.

Agent presets
In Settings → Agent you can pick PTC / Minimal / Creator mode besides Standard. PTC mode includes everything from Standard, but tools are exposed via the Code Mode MCP/SDK so the model packs batches of calls into one TypeScript program and filters, dedupes, counts, and summarizes right there — handy for data-heavy and mechanical multi-step work. Minimal mode is only terminal plus editor, for testing and comparing baseline performance; minimal context spent on tool descriptions means more room for the task, faster and cheaper. Creator mode customizes DSH itself through conversation: writes plugins for features or UI, combines tools and prompts to assemble your own mode.

Everything is a plugin
https://github.com/topics/dsh-plugin
Same logic: install plugins or ask in chat in Creator mode to write one for you, and it installs and verifies it. Examples from the thread: dsh-zoom for cmd +/- since the stock font limit is 17, a bell on task completion, an RSS aggregator from 30 sources for under 50 cents. The topic already has 17k repositories. The downside people mention: when the core is also plugins, tweaking behavior means dragging ~25 downstream patches.

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

Creator Mode writes plugins itself from a single prompt — in the demo it assembles a Pomodoro timer in a couple of minutes and drops it straight into the plugin manager, plus it shows slides/web pages from notes in one go, scheduled tasks like a Friday summary, and installing community plugins by name in a couple of clicks with tuning someone else's plugin to fit, while V0.2 is pitched as a full plugin manager, more options for yourself, and two ways to start — Mac/Win desktop or Node with one command.

Discussion
https://news.ycombinator.com/item?id=49929489
Complaints: Electron instead of native, ~/.dsh clutter in home instead of ~/Library/~/.config, third-party plugins as a malware vector, a fake deepseekharness.io site out-SEOing the official one. Some fear the paid API offers no opt-out from training. Praise: cordis as a potential emacs among harnesses for long-lived agents, lightness and speed.

Top comment: desktop enables telemetry by default (unproven, just a comment), while dsh web is explicit feedback only; the commenter says it is fixed by editing cordis.patch.yml with desktop-product-telemetry, product-analytics, and session-log-deepseek: enabled: false.

I got a bonus You've received a CNY 6 bonus credit, valid until October 11, 2026, 3:59 PM Beijing Time. Looks like they hand it out to try the desktop preview cheaply. After my first tests it makes a positive impression.

#deepseek #dsh #harness #desktop

Comments

Pi 1.0 is out: the minimal harness is locked in as a stable platform, with MCP added via Codemode, virtual models, and a separate Pi Durable.

Pi finally released
https://earendil.com/posts/pi-1-0/
On October 1 Earendil shipped Pi 1.0: the move from 0.99 to 1.0 signals that the core is stable, MIT license. According to the team, Pi is used by hundreds of thousands of people every week. The release includes a new TUI theme and fullscreen by default.

Jev router. The demo shows Pi writing itself an extension with the router/auto virtual model — planning on Claude Opus and implementing on GPT-6 Luna, with the Jev classifier deciding when to switch. /session then breaks down cost by physical models and cache.

Virtual models are registered via pi.registerVirtualModel(), the footer shows the real routed model.

Why MCP was brought into core
https://earendil.com/posts/you-said-no-mcp/
pi.dev used to have a proud No MCP badge. Now MCP has been added, explained in a separate post You Said No MCP! Three reasons:

• MCP has changed for the better over the year and become more stateless
• a plain MCP extension lacked the metadata to decide whether a tool is visible to the model or only from code
• a sandbox interpreter was needed anyway for Jev and image models

Codemode — how MCP was enabled
https://pi.dev/docs/latest/codemode
Codemode is a QuickJS JS sandbox on the harness side, not where bash runs. Instead of a hundred one-by-one calls, the model writes a script, calls tools in parallel, and filters out noise before returning to context. It turns on automatically when MCP is configured, or via defaultTools: ["+codemode"]. Each MCP tool is mcp__server__tool, exposure is a choice: codemode by default, deferred via tool_search, direct, hidden.

Hacker News discussion
https://news.ycombinator.com/item?id=49906637
https://news.ycombinator.com/item?id=49926069
Both posts hit the HN front page with hundreds of comments. Discussion was split: some praise it — a small initial prompt leaves more context for the model itself, and Codemode is interesting. Others say it contradicts the idea of minimalism, counting an extra 450k lines of code and over a dozen direct dependencies. In response the developers explain: Pi's minimalism is not about code size, but about 4 base tools — read, write, edit, and shell — the rest is added via extensions.

A practical nuance also surfaced separately: a Figma employee confirmed that their MCP server only accepts clients from an approved list, and Pi is not on it, and in general because many blocked OpenClaw, Pi on which it is built suffers from that.

Pi Durable — a separate experiment for long-lived agents
https://earendil.com/posts/pi-durable/
To avoid bloating the core, longevity was moved into a separate package Pi Durable. The split: Pi coding agent is one person in one terminal, if the process dies — you look yourself and continue, while Durable is a harness for agents running anywhere, surviving crashes, accessible from different surfaces and to multiple users. Each step is a task with a checkpoint, exactly-once submit via requestId, conversation forks without copying, ownership tree, state documents next to the transcript, background compaction, live steering from any client.

#piagent #pi #mcp #codemode #virtualmodels #jev

Comments

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.

#mimo #claude #opus #openai #gpt6 #grok #stepfun #opensource

Comments

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.

#omp #piagent #subagents #advisor

Comments

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.

#claudecode #codex #cursor #security #grokbuild #qwen #goose

Comments

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.

#openhands #acp #selfhost

Comments

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.

#grokbuild #opencode #piagent #typesafe #mcp

Comments

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.

#cline #desktopapp

Comments

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.

#piagent #antigravity

Comments

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.

#newllmmodel #openai #gpt6 #fable #musespark #gemini #qwen

Comments

Official agentic environment from DeepSeek built on the Cordis microkernel.

DeepSeek Harness (dsh)
https://github.com/deepseek-ai/deepseek-harness
https://www.deepseek.com/harness/en/
Announced on August 13 alongside the DeepSeek-V4-Pro-0813 release, the official open-source harness from DeepSeek — dsh — is powered by the Cordis microkernel. It was originally created by developer Shigma as the core engine for the Koishi chatbot framework. Later, it was spun off into an independent project (Cordiverse), with researchers from Peking University and DeepSeek formalizing its mathematical model in a paper on "spatiotemporal composability." The paper describes the ability to dynamically load, update, and unload plugins at runtime without restarting the process.

The architecture follows an "everything is a plugin" philosophy: the agent loop, tools, sandbox, and UI are all implemented as modular components with reversible effects (clean side-effect rollback upon unloading) and a shared context. It is MIT-licensed and currently in early developer preview (with potential breaking changes to the API). The repository includes tutorials for building custom extensions, and the community is already publishing additional plugins under the dsh-plugin tag.

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

In a hands-on review, the author demonstrates the practical workflow inside the dsh Web UI. Key takeaways from the video:

• Built-in Marketplace (Harness Market) — installing extensions, extra tools, and third-party model providers directly from the interface.
• Operating Modes (Code, Minimal, Creator) — notably the Creator mode for configuring custom agent presets and inspecting runtime state.
• Workspace Management & Live Control — organizing projects by folders, along with the ability to pause execution and adjust goals on the fly without restarting the session.

Discussion
https://news.ycombinator.com/item?id=49285244
On Hacker News, the project is discussed primarily as an example of agentic harness engineering. The main takeaway from developers is that a well-designed environment (feedback loops, context control, and tool invocations) currently yields just as much impact as upgrading the model itself.

It is also compared with Reasonix (a compact Go-based agent optimized for DeepSeek, MIT): Reasonix aims for maximum cost efficiency through stable prefix caching for long-running sessions (often less than $1–2 per task), whereas dsh serves as a more versatile, extensible, and official framework.

#deepseek #harness #agenticcoding #cordis

Comments

Changes in model availability. OpenAI cuts off Cursor following its SpaceX acquisition.

OpenAI Terminates Contract with Cursor!
https://openai.com/index/our-decision-on-cursor-following-its-acquisition-by-spacex/
https://cursor.com/blog/joining-spacex
On August 14, Cursor (Anysphere) officially became part of SpaceX — an all-stock deal valued at ≈$60B, granting access to the Colossus GPU infrastructure for model training. On August 28, OpenAI notified SpaceX that it intends to wind down its contract providing OpenAI models to Cursor, with a shutoff date of November 12, 2026 — the maximum notice permitted under their custom agreement.

The decision is framed around distrust: OpenAI stated it cannot be confident that SpaceX will comply with its Terms of Service, citing Twitter's contract violations (now part of SpaceX) following Musk's takeover and Musk admitting under oath earlier this year that xAI distilled OpenAI's data for training. They also cited a heightened level of accountability required for the upcoming Astra model — meaning Cursor will not receive future models as part of its subscription, though BYOK via personal API keys remains available.

Discussion
https://news.ycombinator.com/item?id=49486172
Cursor was once primarily valued as a polished wrapper around top-tier models from OpenAI and Anthropic, but is now turning into a distribution platform for Musk's Grok. Many argue SpaceX paid not for the IDE, but for billions of developer prompts and codebase contexts for model training. Developers are wondering whether Anthropic will follow suit and ban Cursor as well. Cursor's founder tweeted that OpenAI models represent only ≈5% of total traffic, though comments pointed out that OpenAI models account for a much higher share of revenue. Some developers are already looking to migrate — to JetBrains, Zed, OpenCode, Codex — unwilling to lose the ability to switch between Sol/Terra for planning and Composer/Claude for implementation.

Free DeepSeek Flash Disappears from OpenCode Zen
Users noticed that deepseek-v4-flash-free disappeared from the free OpenCode Zen gateway; for those connected via API, it began throwing "401 No payment method. Add a payment method here" — the model many (myself included) relied on for 100% free, high-quality code generation over recent weeks. There has been no official announcement, with GitHub issues and Reddit simply reporting it as "unavailable." Meanwhile, on the official DeepSeek API itself, a new peak/off-peak pricing structure went live on August 16 (peak hours 01:00–04:00 and 06:00–10:00 UTC cost 2x more, resulting in an overall +3.5–4.7x price hike).

GLM-5.3, GLM-5.3 Flash as ox-alpha, and Qwen 3.8 Flash
https://z.ai/blog/glm-5.3
https://z.ai/blog/glm-5.3-flash
https://qwen.ai/blog?id=qwen3.8-flash-next
Z.ai released GLM-5.3 on August 14 on the same 743B base as GLM-5.2, achieved entirely via post-training. On August 26, they launched GLM-5.3 Flash on a brand-new base — an MoE with 320B total / 18B active parameters, the first open-weights frontier model with hybrid sparse+linear attention (≈4.4× smaller KV cache), native multimodality (text+images+video), 1M context window, and an MIT license. Prior to the official announcement, it was tested anonymously for a week on OpenRouter and OpenCode Zen under the alias stealth/ox-alpha — quickly becoming the most popular model of the week, matching Claude Opus 4.8 tier performance at ≈1/10th the cost.

On that same day, August 26, Alibaba rolled out Qwen3.8-Flash-Next (available in the API as Qwen3.8-Flash) — an architectural preview for the upcoming Qwen4 family: MoE with 125B total + 51B N-gram memory + 4B MTP head, activating only 6B parameters, featuring Qwen Sparse Attention across micro-blocks, gated residuals, 262K native context (extensible to 1M), multimodality, and the Qwen 1.0 license.

Voyage Code 4 — Embeddings Built for Agents
https://blog.voyageai.com/2026/08/13/voyage-code-4/
Since December 2024, voyage-code-3 has been one of Voyage's most popular models overall — a major hit among code embeddings for RAG and semantic codebase search, widely adopted by code assistants (Cursor, Continue, Cody, and others) as the underlying retrieval engine for relevant files and snippets. Today, however, the majority of retrieval queries come from autonomous agents rather than humans.

Voyage Code 4 is the new generation of the Voyage Code series, succeeding code-3 and purpose-built for agents. In practice, this means the model is significantly better at locating the right file on the first try: across 19 new agentic benchmarks (held-out repositories, NDCG@10 — higher means better retrieval accuracy), it performs roughly a third better than close competitors Cohere and Gemini, and nearly 1.5x better than OpenAI. At the same time, it remains flexible and more affordable.

#newllmmodel #openai #cursor #spacex #voyageai #glm #qwen #deepseek #opencode

Comments

Vercel and Slack are also entering the coding tools market.

fx — a tiny native code agent
https://fx.sh/
https://github.com/vercel-labs/fx
fx — Vercel Labs' answer to bloated agentic TUIs — is for now an experimental CLI harness written in Zig: a 6–8 MB binary, microsecond startup, minimal system prompt, and a UI closer to a Unix shell than an "IDE in the terminal." Licensed under Apache-2.0. Includes a Wasm build (live demo directly in the browser), skills, MCP, subagents, and ACP for editors.

Models are routed via Vercel AI Gateway or via Codex (fx login codex) or Grok (fx login grok) subscriptions; the current default in the demo is glm-5.2. Currently at v0.0.5 — "use at your own risk."

Slack Code: Agentic Coding for Teams
https://www.salesforce.com/introducing-slack-code/
Salesforce is launching Slack Code — dedicated code channels inside Slack where you can tag a code agent (Claude, Devin, GitHub Copilot, ChatGPT, Vercel agents) and collaboratively review diffs, previews, and approve work without leaving chat. It features an Agents tab and "Add to Slack" for agents from Lovable, n8n, LangChain, and others. At launch, it works with partner agents and is available on any Slack plan — but requires separate access to each agent.

The idea is straightforward: currently, the human-agent conversation happens in a private tab, the team doesn't see it, and context is lost. In Slack Code, a channel is created per task and archived when no longer needed, with history preserved as a log. They demo a workflow where a PM tags an agent on a bug directly, and an engineer only needs to review the diff and approve the PR.

Proliferate: Open-Source IDE for Multiple Agents
https://github.com/proliferate-ai/proliferate/releases
https://proliferate.com/
Proliferate is an attempt to assemble a team of agents with branch isolation and shared review. The project is open-source (AGPL-3.0) and runs multiple native harnesses in parallel within a single workspace: Claude Code, Codex, OpenCode, Cursor, Grok. Each task is a separate git worktree (or a cloud sandbox that stays alive when the laptop is closed) with subagents, shared MCP/skills, and beta workflows (nightly reviews, CI triage, dependency bumps).

jcode for Concurrent Agent Collaboration
https://jcode.sh/
https://github.com/1jehuang/jcode
https://www.ycombinator.com/companies/jcode
jcode is an open-source (MIT) terminal agent written in Rust by Jeremy Huang, Y Combinator. The project's mission is to parallelize dozens of tasks simultaneously. Its key differentiator is ultra-low memory overhead: per project benchmarks, 10.4 MB per additional session vs. 212.7 MB in Claude Code — so 10 jcode sessions consume less than half the memory of a single Claude Code instance.

The TUI remains fully featured with support for images, LaTeX/math, diagrams/Mermaid, live progress for background tasks, swarm mode with file-conflict notifications, and inter-agent messaging.

Orca by Stably
https://onorca.dev/
https://github.com/stablyai/orca
Orca is a standalone open-source ADE (Agent Development Environment, MIT). It's a desktop IDE for parallel agents: each task gets its own git worktree + dedicated terminal (Ghostty-inspired) + browser — you can run Claude Code, Codex, OpenCode, Cursor side-by-side, with mobile companions and Orca CLI included.

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

Practical value comes from the Workspace Board for distributing tasks across agents and a unified Diff Review for reviewing/merging without jumping between branches, plus built-in Chromium with Design Mode (DOM inspection → copy markup to agent for targeted layout fixes), tab splits, integrated editor, and git-workflow automation (worktree creation via Cmd+N + setup script pnpm install, staging/commits/PRs).

#agenticcoding #cli #harness #multiagents

Comments

A week of minor updates: Grok 4.6, Gemini 3.7 Flash, DeepSeek V4-Pro 0813, GLM-5.3, Qwen 3.8 27B, MAI-Code 1.1 Flash, and Muse Glimmer—all have improved code generation capabilities without changes to their underlying architecture.

Grok 4.6
https://x.ai/news/grok-4-6
On August 12, xAI released a post-training-only update based on the same ≈1.5T base as Grok 4.5. Regarding code generation, it achieved the 1 public result on FrontierCode v1.1 Extended (61.3%), APEX-SWE (56.4%), and saw CursorBench v3.2 rise from 66.7% to 69.9%. The key improvement is that the model now autonomously tests and verifies its code during long agentic sessions, requiring significantly fewer redundant steps (≈53 steps compared to ≈103 for Claude Opus 5).

The weak point remains terminal performance (Terminal-Bench 3.0 score is only 26%). Elon Musk mentioned that Grok 4.7 is just a few weeks away. These updates are steadily pushing the model higher in the Artificial Analysis rankings, bringing it closer to top-tier models.

DeepSeek V4-Pro 0813
https://api-docs.deepseek.com/updates/
On August 13, the Pro tier received the same agentic post-training update previously introduced in V4-Flash 0731. This is a full production release rather than a preview. Operationally, they added support for the OpenAI Responses API, a one-click Codex setup, and reasoning level controls (low/high/max). The weights for the 0813 version have not been published.

Gemini 3.7 Flash
https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-3-7-flash/
Released by Google on August 13, just three weeks after 3.6 Flash. This update represents the largest leap for the Flash lineup in coding tasks: DeepSWE v1.1 improved from 49.0% to 65.3% (according to benchmarks), and FrontierCode 1.1 Main rose from 34.4% to 43.6%. In Google's comparisons, it outperforms Claude Sonnet 5 and GPT-5.6 Terra. Additionally, it is nearly twice as cheap at launch ($0.75/$3.75 per million tokens until the end of 2026) and features a 1M context window.

GLM-5.3
https://z.ai/blog/glm-5.3
Released by Z.ai on August 14. Built on the same 743B base as GLM-5.2, all improvements stem from post-training (IndexShare + SAO). Coding performance: +50% on the internal Z.ai Code Bench, Terminal-Bench 3.0 at 28.3% (the best score among open-weight models, compared to GLM-5.2's 4.6%), and DeepSWE 1.1 at 66.9%. Reports indicate that its cybersecurity capabilities (CyberGym 84.5%, ExploitBench up from 24.4% to 54.4%) increased so significantly that the weights release was delayed by two weeks for safety reviews. Currently, it is only available via GLM Coding Plan and ZCode.

Qwen 3.8 27B
https://huggingface.co/Qwen/Qwen3.8-27B
Released by Alibaba on August 14, this is a dense multimodal 27B model under the Apache 2.0 license—distilled from the flagship Qwen3.8 Max for local deployment. All benchmarks show a noticeable improvement over Qwen3.6-27B, as expected. It features a native context window of 262K (expandable to 1M via YaRN) and runs on standard high-end GPUs and Ryzen AI Max.

MAI-Code 1.1 Flash
https://microsoft.ai/models/mai-code-1-flash/
https://github.blog/changelog/2026-08-11-mai-code-1-1-flash-available-in-github-copilot/
Microsoft updated its small coding model (an MoE with ≈5B active parameters) on August 11 and launched it in GitHub Copilot. Developed in response to developer feedback, the update delivers a +22% improvement on Terminal-Bench 2.1, +15% on .NET, and adds native vision capabilities (supporting screenshots and diagrams). For routine light tasks, other efficiency metrics are even more notable: it is 25% more token-efficient and four times cheaper (73% lower list price than version 1.0), trained from scratch on a clean enterprise dataset without distillation.

Muse Glimmer
https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model
On August 10, Meta released its first open-weights model in 16 months (since Llama 4)—a 30B model under the Apache 2.0 license. This is a distillation of the proprietary Muse Spark, designed for local deployment on a single consumer GPU (4-bit quantization requires ≈17GB VRAM). In coding, it leads its class in agentic tasks but falls short of Qwen3.6-27B (which has already been succeeded by 3.8). Notably, Mark Zuckerberg also promised to eventually open-source the weights for the more powerful Muse Spark 1.2.

#newllmmodel #grok #gemini #deepseek #glm #qwen #microsoft #meta

Comments