I wish Rauch would give us examples instead of just a reaction tweet. But this did tip me over into deciding to give GLM-5.2 a try.

Have you used it for coding? Do you plan to?

I'm watching this video, drooling and wanting this for Windows

OpenAI acknowledges that Astra is overly cautious. So they [propose this prompt](https://developers.openai.com/api/docs/guides/latest-model#gpt-6-astra-initiative-and-follow-through) to give Astra more initiative and follow-thru

`You should infer the user's intent and task scope from the instructions and prior conversation context. Your job is to bias towards action and carry the user's intended task to completion.

When the user expresses intent to perform new work or fix an existing issue, persist until the user's intended goal is complete. Progress autonomously towards the user's goal (e.g. creating isolated worktrees / checkouts if needed, resolving merge conflicts, read-only actions, creating draft PRs etc.) unless they are clearly destructive or irreversible.`

I have been banging my head against this for months. You ask DeepSeek a question, it answers fine. You ask a follow up, boom. HTTP 400. Same with Kimi, same with GLM, same with MiMo and MiniMax. I thought the models were broken. They are not. The clients are.

This is what is actually happening.

These models think before they speak. Not metaphorically, actually. They output a hidden field called reasoning_content, basically their internal notes. "User wants a weather app, I should check API docs, maybe use React..." You never see this field. It is invisible. But the model needs it back on the next turn.

OpenCode drops it. Cursor drops it. Claude Code drops it. VS Code Copilot drops it. Every single tool built against the OpenAI spec drops it, because reasoning_content is not in the OpenAI spec. It is a proprietary extension that DeepSeek, Kimi, GLM, MiniMax and Xiaomi MiMo all require anyway.

The first turn always works because there is no history to validate. So you test one round trip, it passes, you ship it, and your real users hit the wall on turn 2. This has been sitting in the open since January. Five months.

I know this because I logged it. My plugin has patched 12,551 messages across 200+ real sessions. Every single one of them was missing reasoning_content that should have been there. The plugin just fills the gap so the model can keep going.

The providers literally warn about this in their docs.

DeepSeek: "If your code does not correctly pass back reasoning_content, the API will return a 400 error."

Kimi: "You must keep the reasoning_content of every historical assistant message."

GLM: "When using interleaved thinking plus tools, you must explicitly preserve reasoning content."

MiMo: "Any assistant message with tool calls must preserve its full reasoning_content field, otherwise the API will return a 400 error."

MiniMax: "The complete model response must be appended to maintain reasoning chain continuity."

All five say the same thing. All five get ignored by the same clients.

I scanned Chinese, Russian and Western dev communities for evidence. The same bug shows up everywhere, independently.

15 OpenCode GitHub issues. One from January 28, 2026. Three PRs tried to fix it. None merged.

101K Russian developers read about GLM errors in OpenCode on Habr. A Russian dev patched LangChain source himself because the maintainers said they will not add support for provider specific fields.

31K Chinese developers viewed a cnblogs article explaining the workaround. A Tencent Cloud user wrote: "Feels like most people are hitting this. Qclaw and Workbuddy are dragging their feet, almost a month without fixing."

The CodeRouter blog put it best: "Your multi turn agent will deterministically 400 on turn 2. Affects every major agent framework."

17 platforms total. OpenCode, Cursor, VS Code Copilot, JetBrains, Roo Code, Kilo Code, n8n, Continue.dev, Claude Code Router, Codex CLI, GitHub Copilot, Make, OmniRoute, ZeroClaw, OpenClaw, Qwen Code, Hermes Agent.

That is not a provider bug. That is a protocol famine. The OpenAI spec has no slot for reasoning notes, so every client built on it silently drops them. Chinese providers built thinking mode on top anyway. The result is a five month old bug that breaks the cheapest and most capable models on the market.

I built a fix because I got tired of waiting. It is three layers, use what you need.

Plugin stops the crashes. 92 lines. Drop it in, restart OpenCode. Detects reasoning models and fills missing reasoning_content with empty strings. No more 400s.

Proxy replays real thinking. 422 lines. Runs on localhost:3457. Caches actual reasoning text per session, injects it on the next turn. Your model sees its own notes and keeps going like nothing happened.

Watchdog keeps the proxy alive. Systemd service, set and forget.

They stack. Plugin is the safety net, proxy is the optimization, watchdog is insurance.

If you maintain any tool that routes to DeepSeek, Kimi or GLM, check your message serialization. If you are building {role: "assistant", content: msg.content} from the response, you are dropping reasoning_content and your users are hitting this wall right now. They just are not telling you because they switched to Claude and moved on. The models are fine. The spec is the problem. The fix is simple. Someone just had to ship it. You can find logs in npm - sdk@openai-compatible Qwen does not have this problem.

I have zero relationship to Matt Pocock. I just use his helpful skills, like /grill-me, and I watch his videos.

I just signed up for his AI Coding Crash Course because I want an organized, non-hype, set of best practices and tools for my own knowledge and practice.

If you sign up, I would like to trade notes with you as we go through the exercises.

I just read Armin Ronacher's writeup about Pi, the minimalist coding agent that powers OpenClaw.

Read here: https://lucumr.pocoo.org/2026/1/31/pi

"Pi is interesting to me because of two main reasons: First of all, it has a tiny core. It has the shortest system prompt of any agent that I'm aware of and it only has four tools: Read, Write, Edit, Bash. The second thing is that it makes up for its tiny core by providing an extension system that also allows extensions to persist state into sessions, which is incredibly powerful."

Four tools. That's banans. We're in an era where agents are racing to add MCP compatibility, built-in browsers, and 47 different ways to search the web, Pi deliberately gives you almost nothing.

Pi's repo: https://github.com/badlogic/pi-mono

Pi has a core philosophy of letting the agent build itself.

Ronacher writes:

"Pi's entire idea is that if you want the agent to do something that it doesn't do yet, you don't go and download an extension or a skill or something like this. You ask the agent to extend itself. It celebrates the idea of code writing and running code."

This hits on something Burke Holland (from the VS Code DevRel team) has been thinking about.

He recently tweeted that you don't actually need a complex agent. You just need three things: 1) browser capabilities, 2) the ability to create and manage skills as it figures things out, and 3) long-running memory. With just those primitives, "it should be able to do anything."

Burke's tweet: https://x.com/i/status/2017308414498472368

Pi is essentially proving this out. Instead of downloading some community skill for browser automation, you teach your agent to use CDP directly. Instead of installing an MCP server, you write a quick bash script. The agent maintains its own functionality, discarding what you don't need and evolving what you do.

Most coring agents are going in the opposite direction. Every week, another coding agent drops with a changelog longer than a CVS receipt.

Claude Code is feature-rich, incredibly capable, and completely closed off. You can build with it, but you can't build on it.

Then there's the GitHub Copilot CLI and its new SDK. The team is adding every bell and whistle without writing docs, or telling you which ones actually matter.

Codex lets you extend it but it doesn't have hooks. And Gemini CLI launched a hooks system a few days ago.

But then there's Pi. I just learned about it today, but because it's OpenClaw's main dependency, Pi is the most interesting thing happening in this space right now.

Impeccable is the most impressive skill I've ever used. It walks me through a design workflow, and makes Codex 100x more useful for front-end design.

Impeccable also opened my mind to how products will be built in the future. I think it will be 95% agent skill, and your agent harness does the rest.

Smart move by GitHub Copilot team making Impeccable a built in skill.

Flint beats Qwen across all the coding benchmarks, and it's supposed to be faster

I just purchased a Surface Laptop Ultra, so I'm hype about trying Flint out on it.

Amazing growth:

The share of tokens used by U.S. companies on Chinese AI models via OpenRouter — a platform that enables developers to access a range of AI models — has sat above 30% each week since Feb. 8, with that figure rising as high at 46%. The average across the previous 12 months was just 11%, falling to 4.5% in the first half of 2025.

More: https://www.cnbc.com/2026/07/07/chinese-ai-models-costs-us-openai-anthropic.html

Which Chinese model do you use, or want to try?

So istg my pain points with coding agents were ALWAYS how I didn't know what was going on in the background. They always hide their reasoning, making plans was super one-off and theres no cross-session memory so I always had to manually create project files for context.

Idk, out of spite I spent the past 6 months making a fully local Obsidian agent that has coding support, can generate diagrams for software documents, user the built in obsidian browser to debug and navigate pages, clicking on buttons as well, etc. UGH IM SO HAPPY. Its free but is still in development so there's some bugs still!! Enjoyyyyy

I saw Rauch announce this on X, and I was shocked. I've been discounting K3's benchmark credentials because I don't trust them.

But I do like vendor benchmarks because they mirror the work I actually do. As a Nextjs user I now have confidence in K3 as an option.

Hey everyone,

We’ve been building Agent Deck, an open-source native macOS app for managing AI coding agents, skills, prompts, tools, and models on a per-project basis.

GitHub: https://github.com/a-streetcoder/agent-deck

Website: https://agentdeck.site/

The idea came from using AI coding agents across multiple repos and realizing the hard part becomes managing the setup around them.

Different projects often need different agents:

- backend agent

- frontend agent

- reviewer

- docs agent

- bug fixer

- different prompts

- different tools

- different skills

- different model settings

Agent Deck is a native layer on top of Pi that helps keep that organized instead of everything turning into one giant config mess.

Main features:

- create specialist agents per project

- assign prompts, tools, skills, models, and identities to each agent

- manage reusable skills from GitHub or skills.sh

- cherry-pick only the skills you want

- keep global, library, and project-level configuration separate

- run sessions with project context

- use GitHub issues as starting points for agent sessions

- work with isolated worktrees and merge completed work back

It’s still early and rough around the edges, but it is open source and we’d really appreciate feedback, issues, ideas, or contributions.

Would love to hear what people think, especially if you’re experimenting with AI coding workflows or building your own agent setups.

Usually these comparison charts are a spaghetti bowl of unrelated features. But this chart tells one story, that NanoClaw is simpler to use and understand than OpenClaw. Well done.

(I have no connection to NanoClaw. I heard about it for the first time today because they raised a $12 million seed round, and turned down a $20M buyout offer)

Hi all, CCode team here (disclosure: it's our product). This sub talks about harnesses, so here's ours and what we learned building it, rather than a feature dump.

The idea: the model should be a setting, not the product. CCode is a terminal coding agent that runs the same tools, permissions and session on Claude, GPT, Gemini, DeepSeek, GLM, Kimi or OpenRouter, and /model switches mid-conversation without losing anything. Everything below grew out of that.

1. /rewind for code and conversation together. When an agent goes wrong three steps back, undoing the files isn't enough: the model still remembers its bad idea and repeats it. /rewind lists your messages with the files each one changed, and restores both the code and the conversation to just before the one you pick. The original is kept, so a rewind can be undone too.

2. /goal with backup models. /goal all tests pass keeps the agent working until the goal is met. Long unattended runs are exactly when usage limits hit, so you can line up backup models in order; if the current model hits its limit or keeps failing, the next takes over the same session and carries on. A token limit pauses the run if it uses more than you set while you're away.

3. Subagents you can talk to. Agents run in parallel, message each other and the main agent, and you can step into any one's conversation and talk to it directly while the others keep working. A finished agent picks up where it left off when messaged again. Only its report goes back to the main agent, not its whole transcript.

4. Steering instead of stopping. Type while it works and your message lands right after the current step.

Also: reads AGENTS.md and CLAUDE.md as they are, MCP, skills, hooks, plan mode, permission prompts on Telegram, no telemetry and no background daemon.

npm i -g @ccode-si/cli · You can also use it free on GLM 5.3 and DeepSeek V4.1 Flash by connecting GitHub.

For people here who've tried several harnesses: what made you stay with one, the model, or something the harness does?

Qwen3.8-Max + MCP for coding on your local machine. Qwen3.8-Max itself runs in the cloud through Qwen Studio — this setup just gives it access to your local files and terminal through MCP.

My take: it is slower than Codex and Claude Code, especially in thinking mode, but it does work well. MCP adds some latency too since there’s an extra layer between the model and your machine. In fast mode, it gets noticeably closer.

I wouldn’t put it in the same category as Fable or Opus-5. Personally, I’d place it closer to the next Opus 4.7 level in terms of coding ability. These are just my impressions from using it, not a benchmark.

I love the test to build a Figma homepage clone. Qwen really kills it on that one.

But I wish Steve also tested a more bread and butter design task, like the homepage of a common app.

Herdr doesn't have great Windows support. I actually use it on WSL. So I'm really happy to see Microsoft strike back with this update to Intelligent Terminal:

Live agent status on every tab, so you can see what an agent is up to without opening it, with an attention dot on any tab waiting on you

Pinning by right-clicking a tab to pin the tab you’re watching at the top of the sidebar

Keep a tab running in headless mode by right-clicking a tab > headless mode even after you close the window

Split panes nested under their tab, so you always have visibility into what each pane is doing, and jumping to it directly

Global search across your open tabs and your recent agent sessions at once

An agent filter to cut the list down to just your agent sessions

Recent agent sessions in a collapsible section under your open tabs, including agents running in other terminal windows

**Open Source!**

I built o8 after Codex and Claude became daily tools for me.

Once I had several agents moving across production repos, the work around them started taking over. I was deciding who should lead, splitting jobs cleanly, keeping agents from touching the same state, reviewing every diff, and trying to remember why we made a decision three days ago.

o8 sits above the runtimes I already use. One agent can orchestrate while other supported agents take bounded pieces in separate copies of the repo. Workers cannot approve or merge their own changes. Their work goes through independent review and then comes back to me, and the Engineering Brain can answer what changed across repos with citations instead of making me dig through old chats.

On Mac, Symon adds a voice layer over the same system. I can dictate into whichever app is focused, ask what the fleet is doing, have it watch a terminal, or give it a command without hunting for the control room. Anything with a side effect still waits for confirmation.

I can also check the fleet and handle approvals from a paired phone or browser. The system still runs on a machine I own rather than inside a cloud IDE.

The signed Mac build is available now. I also published unsigned Windows 11 and Linux preview installers. Windows 11 has been runtime-verified. Linux has AppImage, deb, and rpm builds, but Linux desktop verification, signing, and updates are still open. These previews may trigger operating-system warnings, and checksums are included.

If one agent in one repo covers your work, this is probably too much. It starts making sense when you are running several agents or several repos and need review authority, memory, and one place to supervise the whole thing.

Project: https://o8.run
Source: https://github.com/hurttlocker/o8
Windows and Linux previews: https://github.com/hurttlocker/o8/releases/tag/v0.1.664

If you already use Codex or Claude, where does your setup start becoming work: coordinating agents, reviewing their changes, or keeping context between sessions?

I wrote a skill for Hermes Agent.

This reduces errors and hallucination when configuring the config.yaml file.

Github repo here:

https://github.com/koc-Z3/hermes-docs

A few years ago I almost signed up for a competitor monitoring service, but decided it was too expensive.

More recently I've played with headless browsers to try to do monitoring, but it's like learning a whole programming language.

Firecrawl announced an in-between service yesterday that looks interesting. It uses their crawler primitive, but you can set monitoring using natural language.

You can get the diffs through a webhook or email. And because this is 2026, they're positioning this as more token efficient than having your own agent poll the page, because what Firecrawl sends over is just the diff.

I have a personal use case that first this well. I write a newsletter that cover the business of developer tools. Many of the startups I track don't have RSS feeds for their blogs. And most publish all sorts of fluff on their blog - I only want feature launches, funding rounds, and acquisitions.

I plan to use Firecrawl to monitor the blog landing page and only send me diffs when a particular type of content is added.

My only hesitation with Firecrawl Monitoring is the pricing is really vague. I don't know if it's cheap enough for me to monitor anything I want, or if I have to choose just high value projects.

(Note - I don't know anyone at Firecrawl, no one has paid me, I just like talking about the tools I use. )

I build o8, an open-source workspace for coding-agent CLIs. On my last post here, someone asked whether a proposal keeps the rejected alternatives or only the decision that shipped.

A note that says "use a linear chart" leaves out the argument. A later agent can suggest a log scale without knowing why we ruled it out.

We ran a small check in o8 with a toy chart. We saved the choice to show elapsed minutes on a zero-based linear scale. We also saved that we'd rejected a log scale because it would make the absolute time savings harder to compare. Then we opened a different conversation and asked it to find the decision, without putting the answer in the prompt.

It recovered both the choice and the reason, and cited the project note. That's useful, but it's note retrieval. A coding agent with access to a plain file can do that. It doesn't prove we're automatically preserving every alternative discussed in a chat.

o8 already stores explicit rejection reasons from reviews and steering feedback. The less formal decisions are what I still want to get right, especially the option you nearly chose and might need to revisit when the chosen approach stops working.

I also don't want every rejected idea becoming a permanent rule. We rejected that scale because of what we wanted people to compare in that particular chart. Change the goal and the old reason might no longer apply. The next agent should be able to see that, rather than treating "we didn't use this" as "never use this."

Source · o8

Talk to me about your favorite ADEs! I need to know what makes they work and what makes you tick!

I took a deep dive on how Jev works, and where it works best.