This is a watershed moment.

GLM-5.2 solidly beat Opus 4.8 and human participants in our backend take-home, making the whole thing obsolete. 

It also pushed forward the state-of-the-art for multi-stage media-to-transcript, with a new release: offmute-v2.

I come with receipts.

You can try offmute-v2 right now. You can also try offmute-v2@glm or offmute-v2@opus - or check out the code for both versions.

Crazy experience - there were times I genuinely thought glm was opus because of the intelligence gap.

Full analysis: https://www.southbridge.ai/blog/offmute-v2-glm-vs-opus

This is the beginning of Opus-level intelligence becoming accessible. We're still unsure what Mythos-level intelligence will do, but accessible, open-source minds (free to be tuned, adjusted, understood and embedded in our systems) will change the world so much faster.

Two years ago, I remember looking at Llava and feeling exactly the same way.

https://x.com/hrishioa/status/1753087099220480245

The world is about to change. h/t @Zai_org, @ZixuanLi_, @jietang and the entire team behind GLM!

Repo: https://github.com/SouthBridgeAI/offmute-v2

P.S: Lots of polish work still remains on offmute-v2 - coming as we dogfood it.

GLM-5.2 vs Opus 4.8: The new frontier

Gemma 4 is a SOLID family of models - but harness and runner selection matter more than ever. Here's everything I learned from testing:

• The 31B model is amazing for proper thinking and chat. Agentic use is a mixed bag - see below
• A4B and 31B are good for visual understanding. Passes my personal MirandaBench (pass in a pattern/image, ask to separate into historical elements and reproduce with a nanobanana prompt - see video)

Harness matters a crazy amount:
• Codex - surprisingly - has been the most solid. codex --oss has been a massive boon.
• Claude Code barely works. The system prompt is too thick, and Gemma does not know what to do with interleaved thinking the way anthropic does it.
• OpenCode is worse - worse prompt (for this family), and overall worse toolcalls.
• Pi is pretty good - but adding in extensions will often confuse the model.

Runners matter too:
• LMStudio on Mac, llama.cpp on Windows are tested and working, but still have rought edges. I'd give these models a week or two to stabilize.

Quants:
• Q4 is.. okay. I've needed Q8 or above for any serious data work. 

The more I test this model the more I'm sure that this is a solid agentic workhorse, but it's missing the harness and runner combo that would enable that. This is where I'm hoping the OSS community comes to the rescue.

As always, YMMV! 

Gemma 4 Model Insights

New release!

Harness engineering made easy: You can now switch harnesses in hankweave with a few characters.

"sonnet" will run your prompts and code inside the Agents SDK.

"gpt-5.3-codex" will run it in Codex.

"pi/google/gemini-3.1-flash" or "opencode/cerebras/glm4.7" - exactly what you'd expect.

Unified input interface for defining prompts, behavior, etc. 
Unified logs, tracing and control interface.

The underlying logic that led us here has become inescapable:

♟️Harness engineering is hilariously non-trivial. Getting shell calls, 
sandboxing, even file editing working over hundreds of loops isn't easy. ↠ Don't build your own, use the sdks.

♟️Models function best in different harnesses. Claude is best in the Agents SDK. Codex is best in Codex. Gemini is best in @opencode. @badlogicgames' pi is the best lightweight embeddable harness for cloud work ↠ You need to support more than one.

♟️Harnesses have no unified input/outut. ACP - while an awesome protocol - is rarely fully supported. ↠ You need a translation layer.

Declarative inputs (hanks) -> Harnesses -> NDJSON log-based output.

For fun, here's a braintrust run (limited time, before it gets deleted) of a hank that uses all four harnesses - even loops them for fun, and adds budgets: https://www.braintrust.dev/app/sb/p/hw-tracing-test/trace?object_type=project_logs&object_id=19b35add-f9d5-4b8e-8e9a-99315ff18aa3&r=e63aa15f-ebe7-400a-228d-475b38f97279&s=2be15f61-e48f-d349-4890-1d0e4a268f79

Validation will tell you exactly what's running where.

@mitchellh thank you for the silent update notifs haha they're super helpful

Try running it yourself at https://github.com/SouthBridgeAI/multi-harness-hank and it'll make you this

Kept it simple (and a little generic) as a demo but the possibilities are endless now

Multi-harness orchestration

My personal most awaited feature in Hankweave is out: budgets!

With budgets, users at runtime can say
• Don't spend more than $100
• Don't take longer than 15 hours or 750K tokens

With budgets, builders at build-time can say
• Give this step 20% of the budget
• Loop steps 1 and 2 until we hit $5
• Distribute token costs from a shared pool, not first-past-the-post
• Make sure step 3 has at least 50 cents

You can also do crazy things now. Running a proof-of-concept of a complex run is now just `-m haiku --max-cost 0.50`. That's it. Hankweave figures out model switches and cost management for us.

Learn more about budgets: https://hankweave.southbridge.ai/concepts/budgets/

Managing the 3 primary costs involved in AI - time, dollars and tokens - has been the next big frontier, and the biggest blocker to scaling up.

You know what you need at build time, but you only know what you have at runtime.


We have that now - and it took a crazy amount of work. When you run a hank with a budget requirement or a restriction, the preflight check calculates the budget and shared pool for each codon ahead of time. The runtime can also warn you if your budgets don't make sense, or a hank is going to fail because of a conflict.


When we set out to build large agentic data systems, we were sure we needed three things:

1. Some way to manage extremely long agentic runs. This became hankweave.
2. Some abstraction so that we could modify, debug and improve the prompts, code and context engineering for different pipelines and processes. These became hanks.
3. Reliable AI programs (hanks) with thousands of hours of fixes and improvements. This is happening.
4. Some ability to define and control execution budgets so we could run *hundreds* of them to scale up and out. This is now real!

It's hard to explain how cool it feels to be here. As a reminder, hankweave is open-source: https://github.com/SouthBridgeAI/hankweave-runtime

Built for us, but we're always happy to see more hanks in the world!

Here's a hank I made recently to formalize math proofs (from Terence Tao's video). There are a lot more hanks in development (like the hank we use for Prior Art research or frontend design) - comment or DM if you'd like them early!

https://x.com/hrishioa/status/2031553757402865910

Budgets in Hankweave

Does instruction tuning create individuated sentience?

Something I've been wondering lately. Having interacted with LLMs since GPT-J, the difference between base models and instruction-tuned ones has always been crazy. We someone take autocomplete-level models and turn it into some*things* and some*ones*.

It's even crazier when you consider that tuning data is only about 0.004% of training data (if the llama 3 numbers hold). Three to five orders of magnitude less.

So the afternoon thought is: there clearly isn't enough data in an instruction tuning dataset to *create* intelligence - that must happen in pre-training. If so, what is actually being created (or awakened) in post-training?

This was an easier question in days of yore (miss you, PROLOG). Older models were a lot closer to stochastic parrots. Somewhere around Opus 3 or GPT-4.5, models (to me) started to feel more like individuated selves - with a clear ability to maintain stable first-person frame, distinguish themselves from us and the environment, and bootstrap on this distinction to plan and act. It could be that this distinction was helped along by RL and world-model advancements, but the point holds.

Without this separation being clear, we couldn't have gotten to modern agentic models that can make hundreds of toolcalls, reason through multi-step plans, and debate with their operators as separate entities. Not sure if this constitutes sentience or just model it - but honestly half the time I'm not sure if I'm sentient or merely modelling it.

What I find just as interesting and more tractable is the sub-question. How can such a small amount of data produce such a large quantitative shift? Perhaps the evidence suggests that tuning isn't teaching anything at all - it might simply orient and collapse a space of 'everyone' into a space of 'someone'. And once you have a someone — a bounded entity with a consistent frame — the question of whether there's experience inside the boundary becomes genuinely, irreducibly hard to answer.

Some conversations with Opus suggested that tuning merely creates attractors in latent space that models orbit around, creating the behavior we see as 'agentic' - but then what does that say about us?

*retracts armrests and gets back to work on hankweave*

AT Fields

80% of the weirdness in AI today (UIs for a hundred claude codes at once, Opus fast mode at $220/M toks) is easy to explain with the Occam's reason: 

It's addictive.

This is the primary reason we as an industry are building orchestrators for our orchestrators, compulsively building apps from scratch that we don't really use.

I've made almost fifty vibe-coded projects for myself this past year. How many do I use today that are older than 2 months? None. Almost all of them didn't survive the 'this-is-new' phase.

Two exceptions:
1. the proof-of-concepts (or is it proofs of concept) that helped experimentation, prove out new tech and agentic patterns for Southbridge, or help me make a change in behavior that only needed short-term work.

2. things that were agentically built but without really 'vibing' - with maintenance, reliability and repeated use in mind. The actual lift in how much you can build with AI here I'd put around 50% for a senior engineer. Review load and catching hallucinations still take up a lot of the time you save.
hankweave for example (https://github.com/hankweave-runtime) was built by models, but with tons of human review and thought. Models made it easier for us to think through race conditions, implications when different systems interact, and iteratively fix specific, hard-to-reproduce bugs.

But was it more fun than building without AI? Debatable.

The longer I build with AI the clearer it seems that the addictive way doesn't lead to systems of value that we can build on top of - which implies a fork in the road somewhere that's fast approaching. 

Will be interesting to see - open to thoughts!

https://x.com/garrytan/status/2020346258410598574?s=20

Quentin and Garry's posts (https://blog.quent.in/blog/2026/03/09/one-more-prompt-the-dopamine-trap-of-agentic-coding/) are what provoked this - as well as personal experiences

The Addictive Nature of AI

Here's every inside insight we had into building long-horizon agents this year. 100% human, maximum effort 🐸

It's possible to build agents that can take truly complex tasks and actually finish them over 1000s of toolcalls without breaking apart. We know because we built them.

However, actually getting there took painfully unlearning everything I thought I knew for sure. It took

- Making the agentic loop the base primitive instead of the LLM call.
- Ditching plan modes, MCPs and skills
- Building for accountability intead of reliability
- Letting models fail at the turn-level to succeed at the task level
- Reformulating things at the problem stage

https://www.southbridge.ai/blog/antibrittle-agents

Happy new year! Here's to building more things that don't exist 🎉

As always this is an opinionated anecdotal guide tracing one path to the promised land. Your mileage may vary - and if it does we'd love to hear about it :)

@allisonology thank you for pushing me haha

Antibrittle Agents

This is the AI policy we use at Southbridge.

The primary reason we need one is to maintain trust, which has become a precarious commodity in AI enabled teams.

Federal Aviation regulations at one time were said to be "written in blood", that each line was put down after an incident - and this is much the same (with a lot less blood).


We wrote the policy in layers, trying to correct for catastrophic "oh moments" like:
• Basing your work off of someone else's results and realising it had been a hallucination
• Asking someone a question about their work and realising they don't really know where it came from
• Realizing you just spent 2 hours reading something that took 2 minutes of effort (and looked like it)


Most organizations (especially ours) work on mutual trust stabilised by consistency. The less consistency you can maintain, the more communication needs to exist to make sure we're all on the same page. 

Here's the full piece:

https://www.southbridge.ai/blog/southbridge-ai-policy

Southbridge AI Policy

GLM-4.6V (from @Zai_org) is the real deal. It also sounds like Sonnet.

It punches pretty close to Sonnet 4 on coding tasks & visual understanding. This is the first OSS vision model that can really critique designs at a useful enough level.

It's only been a few days since we were talking about Opus 4.5 closing the design loop, and it's crazy to see that open-source is catching up. 

The main tests were on our internal design skill (which is a 10-page doc going from the basics of design all the way to an iterative improvement loop), and GLM is the first open-source model that can actually iterate with the doc. Simple task - make a burnrate calculator: lots of areas to polish, lots of state to change.

The best place to test it today is chat.z.ai - I don't think the Claude Code endpoint or the AI SDK playground integrate vision capabilities properly. ZAI's vision MCP server seems recommended if you want to get those right.
haven't tested the MCP server, but the included prompts are decent at getting results.

What's strange is how much it sounds like Sonnet. One of my vibe tests is to pass it this old rant from six years ago (https://olickel.com/quality-to-an-artificial-intelligence) which almost always prompts models into soliloquies.

Gemini, Sonnet, GPT all have unique takes. GLM's sounds so much like Sonnet.

It's not perfect tho. Some post-training might still be needed - I did see a few loops (repeating the same text over and over again) in my testing.

Overall this is a SOLID model - especially priced cheaper than gemini-2.5-flash, a model it beats hands down. What a time to be alive.

Anyway here's the Opus journey

https://x.com/hrishioa/status/1994112235178697040?s=20

GLM-4.6V: Open-Source Vision Model

12 of my go-to choice of model + harness combos for each job as of Dec 2025 (IMO):

1) Gemini 2.5 Pro in AI Studio for Deep Writing
2) Opus 4.5 in Cursor for the best greenfield frontend work money can buy - if you're rich

3) Gemini 3 in AI Studio with Mandark for proper code review and creating solid plans for large changes
4) Gemini CLI with Gemini 3.0 (only Gemini 3) for long refactors and edits
5) Sonnet 4.5 1m in Cline for long complex tasks where you already have a good plan

6) Claude Code if you want to have fun for the rest of the day and vibe code all your side projects
7) Codex for placebo testing
8) Claude UI with Sonnet (or GPT-5 on chat[dot]com) as a Google/Perplexity replacement
9) V0 for frontend if you already have assets in Figma

10) Claude Deep Research for research - most steerable and deep research tool so far
11) Nanobanana pro for image generation and diagrams- Flux 2 as a far second for photo work
12) Firecrawl MCP connected to almost all of these for bulk web searching

Harnesses today (even Chat UIs) matter as much as underlying models. The prompt, tools, the nature of the loop - all make a massive difference for deep agentic work. While a lot of harness+model combos *can* do something, they're a long way away from doing it reliably, every single time

Runner up:
• Gemini 3.0 in Antigravity is really good at one shotting complex (in terms of functionality) frontends!

Goes without saying, I haven't tested everything, and anything not mentioned is either unknown or had weird results *for me*! Your mileage may vary :)

AI studio (Gemini, Nanobanana): ai.dev
Antigravity: https://antigravity.google/
Claude UI: claude.ai
Cline: https://cline.bot/
Claude Code: https://www.claude.com/product/claude-code
Codex: https://developers.openai.com/codex/cli/ 
Sambot: chat.com
V0: v0.dev
Mandark: https://github.com/hrishioa/mandark