CodeWithLLM-Updates
-

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.

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.

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.

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.

OpenCode has moved to the 2.0 branch — the largest rework in its history.

OpenCode 2.0
https://anoma.ly/notes/opencode-2-0/
A good refactoring. Now a single background service starts automatically, and TUI, web, and desktop all work with one process. The API was rewritten from scratch — the authors themselves say the old one "grew chaotically and was bad."

The main new feature is Code Mode, where the agent calls tools not one at a time but as a script, so several calls go in a single exchange with the model, and thousands of MCP servers barely inflate the context. Background subagents and background commands were added, and almost every 2.0 feature was made an internal plugin (80+).

Free models in Zen
https://opencode.ai/docs/zen/
In Zen, developers help test agents, so there are often more than a dozen free models, from stealths and Big Pickle, Space Bunny to MiMo, Ling, Nemotron, Muse Spark, GLM. No account, no key, no card: just /models and go. For a quick test or comparing several models on real tasks, this is the most convenient free playground in the industry.

But in August the gateway started rejecting requests without proprietary headers (429 FreeUsageLimitError), in September a requirement for a full set of tools was added (403), and in October now you also need a properly signed opencode session, or you'll get OpenCode's free tier can only be used from within OpenCode. The catalog is great, but using it from Pi, DSH, Claude Code, or any other harness is getting harder and harder.

Discussion
https://news.ycombinator.com/item?id=50094994
The most notable thing is the more flexible architecture; the client-server model is now finally used to the fullest: the agent on one machine, control from another. The main dispute is autonomy versus security. Some believe the agent should create plugins itself and change the environment, otherwise automation becomes an eternal confirmation of actions. Others respond: if the agent changes its own tools and the changes immediately take effect, it expands its capabilities without a separate permission, and a mistake, prompt injection, or malicious plugin could leak secrets or damage the system. They advise isolation in a container or VM, keeping keys outside, and reviewing important changes separately. A separate complaint: 2.0 allegedly pulls remote configuration from the model provider, which poses a risk of executing untrusted code — but this is a claim from the discussion, not an independently confirmed audit.

Overall, OpenCode never had flexible security configuration before, and it continues to be that way.

Which companies build both their own model and their own harness for it.

USA

Anthropic — Claude Code
https://code.claude.com/docs/en/overview
https://claude.com/pricing
One of the best-known tandems: Claude Opus / Sonnet / Haiku (now also Fable) plus the Claude Code harness (initially CLI, now IDE, desktop, web). There is no free tier for Code — the minimum is Pro at $20/mo ($17 with annual billing). Then Max 5x at $100 and Max 20x at $200. From a lightweight terminal client, Claude Code has grown over the years into a heavy combine with everything imaginable — Slack, Chrome, CI/CD, a mobile app, and computer use that clicks around the screen by itself. Only Anthropic models.

Anthropic has saved limit resets: they can be applied later, once the limit is already exhausted. Unlike Codex, such a reset restores only the limit named in the offer (the five-hour or the weekly one) and does not shift the usual weekly reset day. The first such resets came with Opus 5.5 on September 22, 2026: Pro, Max, and Team could apply them until October 22.

OpenAI — Codex
https://developers.openai.com/codex/cli
https://developers.openai.com/codex/pricing
GPT models and the agentic Codex harness — CLI, IDE, desktop, and cloud. OpenAI fell behind competitors in agentic coding, but was catching up: in the first months after launch it gave away a lot of tokens even on the free plan. Over the past year the CLI has evolved noticeably: multi-agent scenarios, worktrees, web search, MCP, voice input, and CI/CD integrations.

Codex temporarily comes with all ChatGPT subscriptions: Free (usually only the base model) and Go $8. Of course it is included in Plus $20, Pro $100, $200, $500. Together with the desktop app and the cloud, Codex has become one of the main competitors to Claude Code and Cursor. Only OpenAI models.

A separate Codex mechanic is the banked reset: a saved reset you can stockpile and apply manually once the weekly limit of your subscription plan is exhausted. It immediately refreshes both the five-hour and weekly windows and shifts the date of the next weekly reset. This is not the same as a paid reset, which you can buy after hitting the weekly limit.

Google — Antigravity
https://antigravity.google/
https://antigravity.google/pricing
Gemini lives in the Antigravity ecosystem: the desktop app, CLI, and IDE integrations. Before that, the open-source Gemini CLI was shut down for regular users on June 18, 2026, and everyone was moved to Antigravity CLI, which is not open source and is also a rather rough, inconvenient product. The community is still angry that contributions to the open project went into a closed product and into the fork for China's Qwen Code. Gemini 4 Argon is definitely available on Ultra ($100 and $200), while Free gets Gemini 3.8 Flash. The AI Pro $20 plan is a question mark — it's all muddled as to whether Gemini 4 is there now. Also, besides Gemini, there are for some reason two old Anthropic models and OpenAI's gpt-oss-120b.

Meta — Muse Code
https://dev.meta.ai/products/muse-code/
Over the past weeks Meta has made good progress and introduced the terminal harness Muse Code for the Muse Wonder/Spark models. Plans $5 Everyday / $15 High / $50 Power / $200 Maximum, Wonder Full unlocks from Power. The product is still young, so it's worth watching its development and how developers actually adopt it. Only Meta models.

A separate issue is trust in Meta and code privacy: by default, subscriptions use Contributor mode, which allows Meta to use submitted content to train its models. You can turn this off in the settings by choosing Standard mode.

xAI — Grok Build and Cursor
https://docs.x.ai/build/overview
https://cursor.com/cli
https://docs.x.ai/x-subscription/overview
Elon Musk's company: the Grok 4.7 model (the Fast variant only through harnesses) is available in the lightweight Grok Build CLI and the acquired Cursor. The X Subscription merged Grok, Cursor, and X into one subscription with a shared weekly pool. Plans Free / Plus $8 / Premium $30 / Super $100 / Ultra $200. On Free, Grok Build's limits are very tight — sometimes it can't even finish a single task. Also only the Grok model.

Microsoft — GitHub Copilot
https://microsoft.ai/models/mai-code-1-flash/
https://github.com/features/copilot/cli
https://github.com/features/copilot/plans
Microsoft is developing its own compact model MAI-Code-1.1-Flash (MoE 137B, 6.8B active). It is available in GitHub Copilot and VS Code. GitHub Copilot has its own terminal harness variant. Prices: Free $0 / Pro $10 / Pro+ $39 / Max $100. The free tier includes 2,000 completions per month with lightweight models. MAI-Code-1.1-Flash is also being optimized for local execution; Microsoft announced an experimental integration into Copilot CLI and other Microsoft clients for the end of October 2026.

In its early days GitHub Copilot got models only through its partnership with OpenAI; later Anthropic, Google, xAI, and Kimi K3 were added. They also tend to be conservative and don't rush to add new features until users of other harnesses react positively.


China

Xiaomi — MiMo Code
https://mimo.xiaomi.com/coder
https://mimo.mi.com/docs/en-US/tokenplan/subscription
The terminal MiMo Code harness is built as a fork of the popular OpenCode project for its own models mimo-v2.6-pro and mimo-v2.6-flash, with cross-session memory added. The repo has issue 1230 asking Xiaomi to openly thank OpenCode's contributors — they kept the license but never mentioned the people who built the foundation.

MiMo Code inherited a weak spot from OpenCode in its security model: the allow / ask / deny permission system is not a full sandbox and doesn't guarantee the agent won't bypass restrictions by executing commands. On Windows, specifically, people found ways to get around file-access restrictions via PowerShell.

There's a shared Token Plan credit package for using Xiaomi models in supported tools, including OpenCode, Claude Code, and OpenClaw. Plans: Lite $6 / Standard $16 / Pro $50 / Max $100. There's no free way to try the mimo models. Like OpenCode, there's integration with the Models.dev model catalog.

Alibaba — Qwen Code
https://qwenlm.github.io/qwen-code-docs/en/users/quickstart/
https://docs.modelstudio.console.alibabacloud.com/en/model-studio/token-plan-overview
The terminal agentic Qwen Code harness, as I wrote earlier, was a fork of the old Gemini CLI v0.8.2 (they say so in the README), which then started evolving on its own and already has desktop and mobile apps. It supports qwen3.8-max, as well as the 3.7 / 3.6 lineups.

Free Qwen OAuth was discontinued on April 15, 2026. A separate Coding Plan Pro product at $50, which, according to Alibaba's documentation, is no longer available for purchase after the limited offer runs out. The international Token Plan is currently available only in the Singapore region. Token Plan Personal: Lite $6 / Essential $10 / Standard $18 / Pro $68 per month at promo prices. Alibaba's catalog contains more than just Qwen models.

DeepSeek — DeepSeek Harness (dsh)
https://github.com/deepseek-ai/deepseek-harness
https://deepseek.ai/pricing
dsh is an open-source project for building an agentic harness whose main principle is "everything is a plugin": you can replace not only models and tools, but also memory, sessions, sandboxes, the agent's work loops, and the interface itself. It is built on the Cordis plugin core. There's a Web UI, headless launch, and several operating modes — from a minimal agent with a shell and file editor to a full coding agent with planning, subagents, and workflows. DeepSeek has no subscription plan — only pay-per-token with (off-)peak pricing. When registering in the harness, a new DeepSeek account may get a small number of free credits.

Zhipu — ZCode
https://zcode.z.ai/en
https://z.ai/subscribe#code-plans-container
ZCode is the Chinese company Z.ai's own agentic development environment (ADE), integrated with its GLM-5.3 model. It is a desktop app for Windows, macOS, and Linux, not a terminal CLI. GLM Coding Plan works not only in ZCode: the subscription can be used in many compatible harnesses. Plans: Lite $18 / Pro $80 / Max $168. Only GLM models.

Moonshot — Kimi Code
https://www.kimi.com/code/
The Kimi K3 model and the Kimi Code agentic harness (CLI, VS Code, Desktop). The old Kimi CLI was written in Python. On September 23, 2026, Moonshot archived it and replaced it with the new Kimi Code CLI — a different codebase, a redesigned interface, and distribution as a single binary. The new CLI is written in TypeScript, and its terminal interface is built on top of a separate pi-tui library. There's no free way to try the model.

Plans Plus $19 / Pro $39 / Max $99 / Ultra $199, previously named after musical tempos: Andante, Moderato, Allegretto, and Allegro — but the sales department apparently didn't appreciate it. Credits are shared across all Kimi services — Kimi Code, the chat agent, and Deep Research. The subscription includes only Kimi models, but in Kimi Code you can connect any other models via your own API keys.

MiniMax — MiniMax Code
https://github.com/MiniMax-AI/minimax-code
https://platform.minimax.io/subscribe/token-plan
For the MiniMax M3 and M3.1-Flash models, the company is developing its own agentic harness MiniMax Code as an ecosystem with a desktop app, web interface, terminal CLI, and mobile apps for iOS and Android. The terminal agent is open source under the MIT license.

MiniMax Code can be connected directly to your MiniMax account. Token Plan: previously Plus $22 / Max $55 / Ultra $132, new names Go / Explore / Build. 50% off the first month. There are free quotas. The subscription includes only MiniMax models. The ability to add custom model providers via OpenAI- and Anthropic-compatible APIs is only available in paid subscriptions.

Tencent — CodeBuddy Code
https://www.codebuddy.ai/docs/cli/overview
https://www.codebuddy.ai/docs/ide/Account/pricing
Tencent is developing its own Hy3 and Hy4 models and the agentic harness CodeBuddy Code. It is not tied exclusively to Tencent models. Subscription Pro $10, Team $40 per user per month, plus a Top-up Pack — a one-time purchase of additional credits available to active Pro and Team subscribers. In the end I couldn't figure out whether it's only their models or also GLM, Gemini, etc.


Other countries

Mistral (France) — Vibe
https://mistral.ai/solutions/coding/
https://mistral.ai/products/vibe/
https://mistral.ai/pricing/
It has its own model lines Devstral, Large/Medium/Small, the unique Leanstral, and the Mistral Vibe agentic CLI harness. The Vibe ecosystem also covers the web interface (formerly called Le Chat), mobile apps, and IDE plugins. The old Vibe variant can still be run via --legacy-harness. It's hard to tell whether this can be used for real work, because it looks like an unstable project.

The Mistral Medium 3.5 and devstral-small models can be tried for free, but you can't turn off consent to use data for training. Full access is available in the Pro $14.99 and Team $50 for two subscriptions; extra usage can be paid as you go (PAYG). The company lags behind the US and China, so they added GLM-5.3 as an alternative.

JetBrains (Czechia) — Junie
https://www.jetbrains.com/junie/
https://www.jetbrains.com/ai-ides/buy
JetBrains' own model line is called Mellum, where Mellum2.1 is an open MoE model with 12B parameters, 2.5B of them active (i.e., small and fast). But the Junie Local harness variant for local coding currently uses only a specially tuned Qwen3.8-3.6-27B-blend.

JetBrains' full coding agent Junie runs in the IDE, in the terminal, and in GitHub Actions. It supports models from OpenAI, Anthropic, Google, and xAI, as well as third-party providers and compatible local endpoints. JetBrains AI plans: Free — $0 (3 AI credits) / Pro — $10 (10 credits) / Ultimate — $30 (35 credits). One AI credit corresponds to $1 of cloud-model usage cost.

An important note on the impossibility of comparison. Because although most have $10/$20 plans, that doesn't mean they're the same in terms. There's no standard for how many tokens to include, and on top of that everyone has different models with different capabilities.

The VibeWise plugin makes the agent first ask how you understand the task

VibeWise
https://github.com/nykooi1/vibe-wise
https://www.youtube.com/watch?v=GckkaKEQ3vo
The project appeared on September 29, 2026. In a month — almost 4 thousand stars. It's a plugin for Claude Code and Codex. In Claude Code it installs from the Anthropic directory, in Codex — via the plugin marketplace. After a restart you have to explicitly enable the mode: /vibe-wise:learn or $vibe-wise:learn. Without that, the installation teaches nothing and gives no permission to code.

The agent asks how you propose to solve the task. Not "which stack should we use?", but "what happens to a shared note if you delete the folder?". The key part is three types of checkpoints:

  • Build — you and the agent work out how to approach the problem.
  • Design — you lock in the design. "Confirm and continue" records the decision and continues planning, but there's no code yet.
  • Implementation — you separately confirm a specific change. "Implement this step" lets the agent write code.

After implementation the agent must briefly explain what changed, how the key code works, why it matches your decision, which tests were added and what they cover. Not "done", but a report you can verify.

State lives in .vibe-wise/: profile.md, progress.md, project-map.md. There are beginner / intermediate / advanced levels and a separate checkpoint frequency light / normal / frequent. There's no backend, separate model, or telemetry. The notes go into the agent's context, so the host's usual privacy settings apply here too. .vibe-wise/ can be added to .gitignore.

VibeWise's methodology currently has no research proving it improves understanding in the long run. It's interesting because it makes learning a blocker for generation. That doesn't guarantee understanding, but it changes the default: the agent can no longer start with generation.

Universal fork for other harnesses
https://github.com/Itskorrah/vibe-wise-universal
This is not an official upstream branch, but a separate derived project. It preserves the original's authorship and demos but covers Claude Code, Codex, OpenCode V1/V2, Antigravity and portable mode. Shared notes live in the same .vibe-wise/profile.md, progress.md, project-map.md.


Similar in idea, but different:

DshVibeLearning
https://github.com/EarzuChan/DshVibeLearning
A plugin for DeepSeek Harness: /learn, plans, FSRS, notes. An early POC, not a finished product.

vibe-learn
https://github.com/rudrasatani13/vibe-learn
A Claude Code skill: explains concepts at the moment of generation, then unobtrusive quizzes. There's a Learn block, Bug class and Mental model, spaced repetition, export to Anki/CSV/Markdown, state in .vibe-learn/.

stay-sharp
https://github.com/zhinit/stay-sharp
A CLI with manual exercises while the agent does the task. A simple idea: don't watch the agent write, write yourself in parallel.

Anthropic paid well-known Canadian tech blogger Tim Ruscica to make this tutorial.

The YouTube channel Tech With Tim (@TechWithTim) breaks down the setup and capabilities of Claude Code (mostly the desktop app): from installation and model selection to skills, subagents, hooks, and context management. The sections on MCP, plugins, mods, and routines are superficial. CLI/CI, team practices, and security are barely covered. There were already similar "from zero to workflow" videos about Codex (14.07.2026) and Cursor 3.0 (29.07.2026), and a year ago about Cursor 2.0, Windsurf, and Trae.

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

Main topics if you want to revisit the basics:

  1. Plan Mode (12:43) — plan and questions first, then code. Reduces rework and token spend.
  2. CLAUDE.md (16:57) — the file records the stack, commands, conventions, and restrictions; any new chat is up to speed immediately.
  3. settings.json (23:31) — allow/ask/deny for commands and files; a mandatory deny for secrets.
  4. Skills (27:03) — turns repeated explanations into reusable instructions.
  5. Subagents (31:27) — isolate background work from the main context; can run in parallel.
  6. Hooks (35:49) — event-driven automation: tests after a response, blocking dangerous commands, notifications.
  7. Managing Context (40:20) — understanding the context window and /compact directly affects quality and cost.