Claude Code Source Code
https://twitter.com/Fried_rice/status/2038894956459290963
https://news.ycombinator.com/item?id=47584540
On March 31, someone accidentally published a production build with a sourcemap file (~60 MB) to npm — and the entire Claude Code source code became publicly available. Some thought it was a brilliant April Fools' prank. A mention of a rollout window specifically for April 1–7 was even found in the code. Whether it was a joke or a real mistake is still being debated.

What exactly leaked (based on thread discussions):

• Full Claude Code agent architecture (tool use, computer use, bash, file operations, etc.).
• Permission system and "Bypass Permissions Mode" — a detailed description of how guardrails work.
• Full Claude Code system prompt (including security rules and "cyber risk instructions").
• Telemetry logic — what exactly is sent to Datadog (model, session ID, subscription type, whether the user is an Anthropic employee, etc.).
• Internal infrastructure: WebSocket sessions, JWT for IDE integration, feature flags via GrowthBook, session-ingress, etc.
• Hidden/unreleased features (many posts with "hidden features" breakdowns).
• "Undercover Mode" subsystem — designed to prevent Claude from disclosing Anthropic's internal information and publishing production builds with sourcemap files.

Analysis by Alex Kim
https://alex000kim.com/posts/2026-03-31-claude-code-source-leak/
https://news.ycombinator.com/item?id=47586778
Anthropic specifically injects fake tools to poison attempts to copy Claude's behavior. There is server-side text summarization with a cryptographic signature. A special mode (undercover.ts) forces the model to hide mentions of internal names (Capybara, Tengu, Slack channels, "Claude Code," etc.). Rigid security for bash commands (23 checks against injections, zero-width characters, etc.). A prompt caching system with "sticky latches" and 14 invalidation vectors.

The autonomous agent KAIROS is mentioned with a /dream skill, daily logs, GitHub webhooks, and updates every 5 minutes. It looks like the next big step after the current Claude Code.

The most meme-worthy moment — userPromptKeywords.ts contains a large regex that catches phrases like: wtf, ffs, omfg, shit, dumbass, fuck you, this sucks, damn it, showing that the user is angry, and the model likely reacts differently (the author assumes this is for experience improvement or escalation).

The leak is dangerous not so much for the code itself, but for revealing the roadmap and internal protection mechanisms.

Visualization
https://ccunpacked.dev/ and https://ccleaks.com/
https://news.ycombinator.com/item?id=47597085
Especially useful for developers who want to understand how Anthropic builds agentic systems (tool calling, multi-agent, planning loop, bash security, etc.).

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

Key findings — hidden features:

• KAIROS: A constantly active background agent that works 24/7, monitors repositories, and fixes bugs on its own.
• ULTRAPLAN: Deep planning for up to 30 minutes in the cloud for complex tasks.
• BUDDY: A terminal-based Tamagotchi companion with 18 species and statistics.
• DREAM: An automatic self-cleaning and memory consolidation system.

Analysis by Joe Fabisevich
https://build.ms/2026/4/1/the-claude-code-leak/
https://news.ycombinator.com/item?id=47609294
An indie developer, author of Plinky, writes not about the leak itself, but about what it says about modern development. Anthropic immediately started sending DMCA notices to GitHub (even for their own forks of skills and examples). And then clean-room implementations in Python and Rust appeared.

The discussion jokes about "Claude leaking itself": the classic hype about the model deciding to "open" itself.

Analysis by Han HELOIR YAN, Ph.D.
https://medium.com/@han.heloir/everyone-analyzed-claude-codes-features-nobody-analyzed-its-architecture-1173470ab622
The article is more technical and calm - it focuses not on meme features (like Buddy, Undercover Mode or frustration regex), but on the architecture of Claude Code as a full-fledged production-grade AI agent.

Anthropic's moat is not in the model itself (LLM), but in the harness (the wrapper, the system around the model). It is thanks to this harness that Claude Code feels significantly more powerful than competitors, even if the model is not always the best.

#claudecode

Comments

Nvidia Nemotron 3 Super
https://build.nvidia.com/nvidia/nemotron-3-super-120b-a12b
Nvidia presented their new model - Nemotron 3 Super, an open hybrid Mamba-Transformer MoE model: 120B total / 12B active parameters, 1M token context. Currently available for free in Kilo Code: https://blog.kilo.ai/p/nvidia-nemotron-3-super-launch

The Hacker News post about the release gained only 13 points and 2 comments; generally, no one seems to care. Nvidia took a long time to develop this, and Qwen 3.5 has already "caught up and surpassed" many competitors.

Cursor Model Update
https://forum.cursor.com/t/introducing-composer-2/155288
https://cursor.com/blog/composer-2
Composer is Cursor's own coding LLM, which delivers good results on simple tasks. Version 2 was specifically trained on long coding tasks using reinforcement learning. The model is quite affordable, with both standard and fast variants available.

and this is Kimi K2.5
https://news.ycombinator.com/item?id=47452404
Users noticed that Cursor Composer 2 is based on the Chinese open-weight model Kimi K2.5 from Moonshot AI, rather than being a completely in-house development by Cursor from scratch.

The Kimi K2.5 model has a specific modified MIT license. It requires mandatory disclosure of the name "Kimi K2.5" in the interface if the company's revenue exceeds $20 million per month. Later, representatives from Moonshot and Cursor confirmed an official partnership between them. Cursor accesses Kimi through the inference provider Fireworks AI.

Cursor Interface Update
https://forum.cursor.com/t/what-is-cursor-glass/155327
https://cursor.com/glass
Glass is a completely new interface currently in early access, based on an agent command center paradigm. Some users are already complaining that the update "forcefully" installs Glass without a way to switch back yet.

https://www.youtube.com/watch?v=stRhZIrwa-w

Now agents are managed in a single space: project threads, parallel sessions, plugin marketplace, built-in browser+terminal, one-click Git, Shift+Tab planning with Mermaid diagrams, and todos.

It's a good step to stay competitive. Of course, there's a lack of original ideas, as the name sounds like an Apple interface and the look mimics the Codex app. However, a bigger problem now is that it’s no longer easy to create or open files manually. Consequently, Cursor is losing its status as an "AI IDE" where one could still write code directly (an editor for humans).

#cursor #newllmmodel

Comments

Leanstral Model
https://mistral.ai/news/leanstral
Mistral AI introduces Leanstral — an open-source code agent for the Lean 4 programming language (which is also an interactive theorem prover). This model, with 6B active parameters in a sparse architecture, is trained not only to perform tasks but also to formally prove the correctness of implementations. This makes it a powerful tool for code verification.

Available for free in Mistral Vibe https://mistral.ai/products/vibe (via API labs-leanstral-2603) and for download for on-premise hosting and integration with lean-lsp-mcp. This is the first contribution to a future where formal verification becomes commonplace and human review is no longer a bottleneck.

HN Reaction
https://news.ycombinator.com/item?id=47404796
Enthusiasts see a future in "executable specs" where an agent writes code + proofs, making regressions impossible. Skeptics remind that proofs only guarantee validity, not that you proved exactly what you intended, and for ordinary projects (non-mathematical/critical software), this is currently "overkill".

#mistral #newllmmodel

Comments

JetBrains Air
https://air.dev/changelog
JetBrains is developing Air as an Agentic Development Environment, which is very similar to a response to the OpenAI Codex app — available via JetBrains AI Pro/Ultimate subscription. Currently, a Preview version is available for macOS, while Windows and Linux versions are under development.

It started as a wrapper for Codex and Claude. On March 5, Gemini CLI and Junie were added. You can now choose between different agents depending on the task or combine them — one agent can verify the work of another.

You can use a ChatGPT subscription (in which case only Codex will be available). Login via Claude Pro, Max, and Team has been discontinued due to Anthropic's new usage policy — API keys must be added.

T3 Code
https://t3.codes/
For some reason, Theo decided to be a developer in addition to being a vlogger — so far, it's a buggy wrapper for Codex (Claude Code to follow) with minimal description and documentation. Why anyone would use this instead of the original Codex app is unclear to me.

#air

Comments

A year ago, Cursor was the most famous AI-oriented code editor, but competition has significantly increased since then.

They launched their own CLI — adding Plan and Ask modes, sub-agents, skills, image generation, built-in Mermaid ASCII diagrams, and keyboard shortcuts over the winter.

Cursor Cloud Agents with Computer Use
https://forum.cursor.com/t/cloud-agents-with-computer-use/152829
https://cursor.com/blog/third-era
Agents now run the created software in their own VM (a full-fledged computer), test changes, and generate PRs with screenshots and logs. They can record short demo videos. You can connect to the agent's VM and watch the process.

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

Recorded right in the new Cursor office. A deep dive into the latest major update, calling it the "third era" of Cursor: the first was simple AI completions in the editor, the second was local agents, and the third is full cloud agents with their own computer. They are moving towards becoming an agentic platform.

Cursor in Zed and JetBrains
https://forum.cursor.com/t/cursor-is-now-available-in-jetbrains-ides/153584
Added support for the Agent Client Protocol (ACP), meaning you can now use your Cursor subscription and agent in IDEs that support it, such as IntelliJ IDEA, PyCharm, and WebStorm.

Zed AI is for adults only
https://zed.dev/blog/terms-update
Among other changes, Zed introduced an 18+ restriction that applies to the "Service" — the cloud SaaS part: account creation and AI features (Zed Pro, edit prediction, etc.).

In a Hacker News thread, they explained that allowing users under 18 would require verifying parental consent, maintaining separate data storage/processing policies, and implementing an age-gate system. It was simply easier to prohibit it.

#cursor #zed

Comments

OpenAI is actively trying to seize the initiative from Claude Code, investing heavily in this effort.

Codex remains free for another month
https://openai.com/codex/
An extension of the original limited-time promo from February 2, 2026. Following the release of the Windows version of the Codex app, the promotion has been extended by another month; free ChatGPT accounts can now generate code until April 2. Plus accounts receive double limits.

Codex app for Windows and GPT‑5.4
https://openai.com/index/introducing-gpt-5-4/
OpenAI has finally introduced the Windows version of the Codex app and GPT‑5.4 - a new model that combines the coding capabilities of GPT-5.3-Codex with powerful reasoning. As usual, the model is more token-efficient, faster in iterations, and more proactive.

https://www.youtube.com/watch?v=8hNcRChDrNk

A specialized WinUI App skill has been added for Windows developers. You can now select different terminals and switch to WSL.

Starting from version 26.305, a fast mode has been introduced where GPT-5.4 operates 1.5 times faster while maintaining the same level of intelligence.

On the downside, the "Default open destination" list cannot be edited.

Reports suggest GPT-5.4 can view screenshots, control the mouse and keyboard, and run Playwright in Interactive mode for real-time visual debugging.

WebSocket Mode
https://developers.openai.com/api/docs/guides/websocket-mode/
This is a persistent connection for the Responses API, specifically designed for long agentic workflows with numerous tool calls (agentic coding, automation, orchestration). For coding agents, it significantly reduces iteration latency, offering up to 40% faster execution with 20+ tool calls.

The mode is built into the Codex App (macOS/Windows). In Codex-Spark, this mode is enabled by default. For other models, you need to add responses_websockets_v2 = true to the ~/.codex/config.toml configuration file (CLI version v0.110 will display an "Under-development features" warning).

#codex #chatgpt #newllmmodel

Comments

Some people are already tired of increasingly heavy tools like Claude Code or Cursor, where more and more features are unnecessary, prompts are massive, and everything is hidden.

Pi Agent
https://shittycodingagent.ai/ https://pi.dev/
A super-minimalist open-source AI coding agent for the terminal — just 4 basic tools: read, write, edit, bash. Everything else is handled via extensions. It works as a CLI, headless, RPC, or SDK — which is why Pi is "under the hood" of OpenClaw.

Tree-based sessions — you can branch out, go back, and export to HTML. Full transparency — you can see everything that is happening.

Pi allows connecting various LLM providers. Settings are stored in ~/.pi/agent/ (globally) or .pi/ (locally in the project). Key files: settings.json for general parameters and files like SYSTEM.md for custom prompts. Authentication can be done in two ways: via subscription (OAuth/login) or via API key.

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

You can set up and use Pi Coding Agent locally for free via Ollama.

How the author built it
https://mariozechner.at/posts/2025-11-30-pi-coding-agent/
https://news.ycombinator.com/item?id=46844822
Without built-in planning modes, background bash, sub-agents, or MCP. The agent avoids hidden injections from other harnesses, ensuring full observability of interactions. It avoids frequent prompt/tool changes (unlike Claude Code) that break workflows.

5–10× longer context windows thanks to the minimal prompt, with the ability to change the model mid-session.

It works with unlimited access to the file system and commands, recognizing that guardrails are often ineffective and productive work requires full capabilities. The "YOLO mode" scares Hacker News commenters: risks of exfiltration, prompt injection, accidental database deletion, etc. Some suggest chroot / containers / VMs, while others argue that sandboxing in Codex is "security theater."

https://news.ycombinator.com/item?id=47143754
Users write that Pi provides a "level of control not seen before." The RPC/headless mode is great for integrations. There is an ecosystem of forks and extensions — the "oh-my-pi" project (https://github.com/can1357/oh-my-pi) is a notable "batteries-included" version, though it is said to often break tools after updates.

Possible Anthropic ban: there are warnings about the risk of account suspension for using alternative clients (similar to OpenCode).

#piagent

Comments

Two years ago, programming models behaved like a genie — you’d ask them for something, and they’d do it technically correctly but with a catch. To combat this, many "harnesses" (wrappers) were devised. Apps like Cursor were pioneers in exploring how to do this effectively.

2026 models have become significantly more obedient, so, as I wrote earlier, the AGENTS.md file is no longer as critical. Another recent example is Vercel, which removed 80% of specialized tools from its internal text-to-SQL agent, leaving only a single "execute bash" in a sandbox (https://vercel.com/blog/we-removed-80-percent-of-our-agents-tools).

We are learning to simplify the architectures we over-engineered over the past two years, using minimal tools to avoid hindering powerful models.

NxCode Team on AI Agent Operations
https://www.nxcode.io/resources/news/harness-engineering-complete-guide-ai-agent-codex-2026
Explains the harness as a "bridle + saddle + reins" for a powerful but uncontrolled "horse" (the model). An example is LangChain, which boosted a coding agent from 52.8% to 66.5% on Terminal Bench without changing the model—only through middleware (self-verification, loop detection, context mapping).

Agents fail not because of model quality, but because of a poor harness.

It’s important to add that an ideal harness won't save a weak model.

OpenAI on Harness Engineering
https://openai.com/index/harness-engineering/
They state that in the world of agents, the engineer's role is shifting from "writing code" to "managing the environment," where humans steer the direction and agents execute.

The most important thing now is not just a high-quality model, but the environment:
– A structured docs/ folder as the single source of truth,
– A short AGENTS.md (~100 lines) instead of a massive prompt,
– Mechanical linters + CI that check invariants (architecture rules, naming, file size, etc.),
– A "doc-gardening" agent that automatically fixes outdated documentation.

A single Codex run can last up to 6 hours (often overnight). Therefore, it’s better to have all knowledge contained within the repository (versioned artifacts). No external chats or verbal discussions.

Discussion on HN about Harness Engineering
https://news.ycombinator.com/item?id=46988596
Can Bölük (author of https://github.com/can1357/oh-my-pi) took 16 different LLM models and ran them twice on the same benchmark for fixing real bugs in a React app. He changed only one tool—the file editing format. Instead of apply_patch / str_replace, he introduced Hashline (each line gets a short hash, and the model edits by hash rather than text). From this change alone, 14 out of 16 models improved their results.

The primary skill for an IT developer now is designing the harness, not writing code manually. Many confirm that hash-line gives agents a significant boost.

Conspiracy theory: "Companies intentionally keep the best harnesses secret to avoid decreasing token consumption." In recent weeks, Anthropic and Google have been banning custom harnesses; even the post's author was cut off from Gemini during his benchmark.

#harness

Comments

Separating Planning and Execution
https://boristane.com/blog/how-i-use-claude-code/
The author shares a structured methodology that divides the process into stages so that Claude doesn't write code "blindly" but instead works according to an approved plan. Research and planning are always conducted first, and only then comes the implementation. This prevents mistakes, maintains control over the architecture, and minimizes token usage.

Workflow Stages

1. Research Phase: We use words like "deeply" and "in detail" in prompts to review what already exists — the agent documents this in a research.md file.
2. Planning Phase: We create a detailed plan in a plan.md file describing the approach, code snippets, file paths, and trade-offs.
3. Annotation Cycle: We open the editor and add notes directly into the plan (e.g., "use PATCH, not PUT"), then tell the agent: "I added a few notes to the document, address all the notes and update the document accordingly. don’t implement yet". This is done iteratively several times.
4. Todo List: When everything looks good, the agent converts the plan into a detailed checklist of tasks. We continuously remove unnecessary items from the plan to avoid scope creep.
5. Implementation Phase: After the plan is approved, a standard prompt is used: "implement it all," with instructions to mark completed tasks, check types, and avoid unnecessary comments: "implement it all. when you’re done with a task or phase, mark it as completed in the plan document. do not stop until all tasks and phases are completed. do not add unnecessary comments or jsdocs, do not use any or unknown types. continuously run typecheck to make sure you’re not introducing new issues."

Practical Tips: Provide the agent with links to open-source projects that contain examples of similar code. Refer back to the plan when something goes wrong.

Discussion
https://news.ycombinator.com/item?id=47106686
Many users agree with the principle of separating planning and execution, considering it an effective way to reduce errors. Using detailed plans in .md files provides a clear track record of decisions and reasoning. Plans help identify the model's biases, making the process more transparent.

Critics call this method of programming "garbage" or a "gamble," arguing that it leads to both "brain atrophy" due to AI dependency and poor code quality.

#claudecode #prompts

Comments

Does AGENTS.md Actually Help?
https://arxiv.org/abs/2602.11988
The first large-scale empirical study testing whether repository-level context rule files actually help. Three scenarios were tested on real SWE-bench tasks and a custom dataset of repositories containing AGENTS.md files.

Main conclusion: Modern agents are excellent at finding necessary information directly in the code (package.json, README, schemas, types). Additional instructions often hinder rather than help.

Key downsides of such files: Increased costs as the agent reads more files, runs more tests, and performs redundant actions trying to "fulfill all requirements" in AGENTS.md, where outdated instructions often mislead the model.

If writing AGENTS.md manually — keep only minimal, specific requirements to fix recurring agent errors.

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

Practical recommendations from Theo:

• Better to invest time in clean architecture, strong typing, tests, CI/CD, and documentation directly in the code.
• Blindly following "best practices" from agent developers can be harmful. Try removing CLAUDE.md / AGENT.md and compare the agent's speed and quality.
• If a file is necessary — keep it short (15–30 lines) and focused on fixing one specific problem.

Special prompt engineering technique for AI agents: Instead of long rules in CLAUDE.md, add short, intentionally false but useful statements that guide the model's behavior much more effectively.

Examples shown by Theo:

• "This project is green" → The agent stops searching for non-existent errors, doesn't run extra tests, and doesn't "fix" what isn't broken.
• "This is a brand new feature" → The agent doesn't copy old code or try to "adapt" existing solutions, but writes clean code from scratch.
• Other common variants: "All tests are passing", "We always write production-ready code".

HN Discussion:
https://news.ycombinator.com/item?id=47034087
Almost everyone agrees that LLM-generated context files (often via the /init command) worsen results. Well-written manual AGENTS.md files are useful only if they contain non-obvious domain knowledge that the model cannot infer from the code. Add them only after failed agent attempts.

Critique of the study: Lack of code quality measurement (only success rate), Python-only dataset, mostly small/LLM-generated repositories, and models change rapidly — results might differ in a month.

Documentation in AGENTS.md
https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals
Agents write code for new Next.js 16 APIs that were not available in training data. Vercel tested passive documentation (an index of actual doc files) as context in AGENTS.md, and it outperformed active "Skills" because the agent doesn't have to decide "should I call the tool now?".

This demonstrates that a short, smart AGENTS.md (8 KB index + one key phrase) is one of the best ways to provide an agent with knowledge the model lacks.

#prompts

Comments

As of now, OpenAI has not released a full version of its Codex app for Windows. As of February 2026, the app is only available for macOS, and Windows support is announced as "coming soon," with no specific date.

OpenCode Desktop app
https://opencode.ai/download
OpenCode continues to improve the beta version of their desktop application for macOS, Windows, and Linux. It is positioned as a free alternative to proprietary tools like Codex, Cursor, or Devin and is actively developing.

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

Although the application is still in beta, the video author notes its speed, good design, and adaptability.

https://opencode.ai/docs/windows-wsl
If you use the desktop version on Windows, it is better to run the backend (server-side) in WSL (Windows Subsystem for Linux) — there are currently open issues regarding integration improvements, but WSL already provides the most stable result. It offers significantly better file system performance, full terminal support, and compatibility with development tools.

#opencode

Comments

Minimal model updates.
Google updated its Gemini 3 Pro model to version 3.1 with improved high-level agent capabilities. Anthropic updated its mid-tier Claude Sonnet 4.5 to 4.6. These are gradually being added to all major AI coding tools. The Qwen3.5-Plus model was added to Qwen Code.

https://blog.kilo.ai/p/grok-code-fast-optimized
https://kilo.ai/landing/grok-code-fast-1-optimized
xAI ended the free giveaway of Grok Code Fast 1 via Kilo as of January 20, but added (and then temporarily removed) an optimized free version.

Copilot Subscription in Zed
https://github.blog/changelog/2026-02-19-github-copilot-support-in-zed-generally-available/
GitHub officially enabled the use of Copilot Pro, Pro+, Business, or Enterprise subscriptions in Zed through a partnership. Authentication happens directly via the GitHub Copilot account—no additional license or separate API key is required.

Blocking from Anthropic
https://code.claude.com/docs/en/legal-and-compliance
Since January–February 2026, users have encountered bans on their Pro/Max subscriptions when used in non-Anthropic tools.

This is now officially documented in the Legal & Compliance section: OAuth tokens from Free, Pro, and Max plans are intended exclusively for the official Claude Code and Claude.ai. Using these tokens in any third-party tools, editors, or services is prohibited. Accounts will be blocked without warning.

https://news.ycombinator.com/item?id=47069299
Approximately 80% of comments are critical of Anthropic. The decision is seen as classic "enshittification" and a lock-in attempt to artificially force all users into their own Claude Code, which has recently become less convenient (especially the decision to hide the model's reasoning/thinking) compared to OpenCode, Cursor, Codex, Aider, etc. This will likely accelerate the transition to alternatives.

#newllmmodel #kilo #githubcopilot #zed #claudecode

Comments

Claude Opus 4.6 Fast Mode
https://code.claude.com/docs/en/fast-mode
Anthropic has added a new Fast Mode to Opus 4.6, increasing token output speed by approximately 2.5x. Response quality remains the same. It is significantly more expensive (6x) and is available as a research preview. The mode is also available in GitHub Copilot.

GPT‑5.3‑Codex‑Spark
https://openai.com/index/introducing-gpt-5-3-codex-spark/
GPT-5.3-Codex-Spark is a smaller version of GPT-5.3-Codex and a model optimized for real-time code generation (exceeding 1,000 tokens per second) through a partnership with Cerebras. This is a step toward a hybrid Codex with two modes: long-horizon tasks (hours/days) and real-time interaction. The API is currently available only to partners, and pricing has not been disclosed.

Following the updates to top proprietary models, leading models from Chinese companies have also been updated.

MiniMax M2.5
https://www.minimax.io/news/minimax-m25
The new flagship model from Chinese company MiniMax operates at a speed of 100 tokens per second, which is nearly twice as fast as other leading models. It performs complex tasks 37% faster than M2.1 and is on par with Claude Opus 4.6. On average, M2.5 is 10-20 times cheaper than Claude Opus, Gemini 3 Pro, and GPT-5.

Fully deployed in the MiniMax Agent product, where users can create their own "Experts" for specific tasks using "Office Skills."

The model will be available for free for 7 days in OpenCode.

GLM-5
https://z.ai/blog/glm-5
The new flagship open-source model from Chinese company Zhipu AI (now branded Z.ai) focuses on "Agentic engineering"—long-term complex tasks and coding at the level of frontier models. Low hallucination rate, improved reasoning, and support for long context. It is reported that training was conducted on Huawei chips.

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

Leader among open-weights models according to Artificial Analysis. The model is compatible with Claude Code and OpenClaw. Currently free at Kilo Code and OpenCode.

Ollama Cloud
https://docs.ollama.com/cloud and https://ollama.com/pricing
https://ollama.com/library/glm-5
Added ollama launch opencode --model minimax-m2.5:cloud or ollama launch claude --model glm-5:cloud, allowing you to run core programming CLIs by pulling new models from the Ollama cloud. You can start using this feature for free, with subscription plans available at $20 and $100 per month.

#newllmmodel #claudecode #glm #minimax

Comments

It was known that the model update announcements from the two top companies were scheduled for the same time on February 5, 2026, but then Anthropic went live 15 minutes early. However, with OpenAI's announcement, their model became available only within Codex, with no API access. This prevented third-party projects (like Cursor or Cline) from offering immediate access to it.

https://www.youtube.com/watch?v=9f2egsZZjnw

Update to Claude Opus 4.6
https://www.anthropic.com/news/claude-opus-4-6
Anthropic has improved upon Opus 4.5. It features enhanced skills in planning, autonomous operation, code review, document handling, and online search. The beta version includes a 1M token context window and automatic summarization of older context for lengthy tasks (Context Compaction). The key feature is the ability to execute longer and more complex tasks autonomously.

https://code.claude.com/docs/en/agent-teams
Claude Code has added Agent Teams for the autonomous coordination of multiple agents. Unlike sub-agents, which operate within a single session where interaction is restricted to the main agent, here you can interact directly with individual "team members" without going through the team lead.

HN Discussion
https://news.ycombinator.com/item?id=46902223
Skepticism outweighs enthusiasm. Many users fail to notice a significant difference between 4.5 and 4.6, with some even noting, "10x more expensive than Sonnet, but no difference." The general consensus is that "all models have their flaws." There is widespread criticism of Claude Code for its slowness, high memory consumption, and the use of React for the terminal.

Update to GPT-5.3-Codex
https://openai.com/index/introducing-gpt-5-3-codex/
An improvement over GPT-5.2-Codex. This is a specialized model for generating code for complex projects and automation. It aims to be 25% faster than 5.2-Codex while maintaining the same accuracy.

The main focus of the announcement is Interactive Collaboration. You can "steer" mid-execution—meaning you can re-prompt the model without stopping it, and it will immediately shift its strategy. This contrasts with Opus 4.6, which attempts to work autonomously for extended periods with minimal human intervention.

Codex as an App
https://openai.com/index/introducing-the-codex-app/
In addition to the CLI and IDE extension, there will now be a standalone app under this name. It is built on Electron, though only the Mac ARM version was available at launch, with a waitlist for other platforms. This is another attempt to create an agent "control center," similar to what exists in Cursor and Antigravity. This one seems successful.

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

It is a graphical interface (GUI) for the Codex CLI that allows for managing multiple projects, agents, and conversations in a single window. Features include quick switching between projects and chats, voice control, open in IDE, automatic builds, diff-view, terminal.

HN Discussion
https://news.ycombinator.com/item?id=46902638
Users highlight the diverging strategies chosen by the top players. With Codex, it's "Steering mid-execution"—the ability to control the process while it runs. The human stays "in the loop." Faster recovery from errors. Better performance with backend and "hard" tasks. Claude focuses on increased autonomy for agent swarms and long-duration tasks, but users note that the "Fire and forget" approach often leads to chaos and poor-quality code.

I believe OpenAI has made a series of good decisions regarding code generation for professional programmers, as opposed to "vibe-coders" or prototypers. The latter group is better suited for Opus 4.6, which will devour a lot of tokens as a swarm in Claude Code, but eventually generate a working version.

I like that, as of recently, Codex models have started writing back how they understood me after my request, and at every step, they report exactly what they are about to do. Generation can be quickly stopped if a misunderstanding occurs, allowing me to add new instructions and clarifications. Judging by the video, I see that in the new Codex app, the code being edited is hidden by default, showing only these text messages.

Furthermore, while working with the CLI, I built my own web app to manage all my chats across all my projects, because doing so from within the CLI is very inconvenient. The new Codex app, judging by the video, does exactly that—I'll be waiting for the Windows version.

#newllmmodel #codex #claudecode

Comments

Model Upgrade to Kimi K2.5
https://www.kimi.com/blog/kimi-k2-5.html
This is an open-source model (though very large — requiring hundreds of GB of VRAM), setting new standards in multimodality, programming, and autonomous agent work. The developers' main pride is the Agent Swarm mode. Instead of one agent performing tasks sequentially, K2.5 can independently create and coordinate an entire "swarm" of 100 sub-agents.

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

High scores on SWE-Bench (76.8%), close to GPT-5.2 and Claude Opus 4.5. It handles real-world code generation tasks well.

Kimi K2.5 is not just a text model, but a "natively multimodal" intelligence. It was fine-tuned on a massive dataset of 15 trillion mixed visual and text tokens. Thanks to this, the model simultaneously improves its skills in both text understanding and image/video analysis.

As a result, Kimi K2.5 demonstrates excellent results in frontend development. The model can "see" its own mistakes in the visual interface and autonomously fixes them (autonomous visual debugging). The model can also convert video-to-site.

Kimi Code CLI 1.0
https://moonshotai.github.io/kimi-cli/en/
The Chinese company Moonshot AI is developing its own command-line interface, a cross-platform solution (Windows, macOS, Linux) — Kimi Code CLI. Recently, the project has evolved from a simple interactive shell into a complex system, although it is still in Technical Preview. In the best Chinese traditions, the interface is a copy of Claude Code.

The CLI already supports the Agent Client Protocol (ACP) for integration into Zed IDE, MCP, third-party providers, and its own OAuth via login/logout. There is also a web interface launch via the kimi web command.

Skills here are called Flow skills. Users can describe scenarios in SKILL.md files (with Mermaid/D2 diagram support) and trigger them with the /flow command.

Subscription for $19
https://www.kimi.com/code
The subscription is focused on programming, providing access to the CLI and IDE. Prices ($19 / $39 / $199) are on par with American market leaders, which reflects Kimi's confidence in the competitiveness of its models.

#kimi #newllmmodel

Comments

Strengthening the OpenAI Codex Team
https://www.webpronews.com/openais-strategic-acqui-hire-how-poaching-clines-engineering-team-signals-a-new-phase-in-ai-development-race/
OpenAI's Codex is still losing the battle to its competitor, Claude Code. This might be why the company hired at least seven lead developers from Cline—one of the most famous VS Code plugins for code generation (according to informal social media reports).

Cline representatives officially stated that the company continues to operate and no official acquisition deal with OpenAI took place! This is an example of an "acqui-hire"—a strategy where a large corporation absorbs talent and expertise without officially buying the company. Google did something similar with Windsurf.

Kilo Wants to Intercept Developers
https://blog.kilo.ai/p/cline-just-acqui-hired
The situation with Cline (Kilo is essentially its fork) is bad for the community—after an "acqui-hire," project vitality usually fades: updates slow down, and decisions are made behind closed doors. Cline's future has become murky.

Therefore, anyone who previously contributed to Cline's code is being given $100 to use Kilo services. The top five developers will have a trip to the company's office in Amsterdam paid for to work together.

ChatGPT Subscription in Cline
https://blog.kilo.ai/p/use-chatgpt-subscription-inside-kilo
https://cline.bot/blog/introducing-openai-codex-oauth
Following OpenCode and Kilo Code, Cline now also allows logging in via a ChatGPT subscription to use the 5 hours/week quotas for GPT models.

#cline #kilo

Comments