The New AI Stack: Qwen, Unsloth, Buzz, Berd, and More

There was a moment about halfway through our latest livestream when we realized the “AI tool roundup” had quietly turned into something bigger.

We started by asking which new model was smartest. By the end, we were debating whether your future AI should live in a data center, a desktop app, a Slack-like workspace, or a little box attached to your house.

That sounds like we got distracted. We did, obviously. But the detour exposed the thread connecting nearly every launch we covered: the model itself is becoming one interchangeable part of a much larger AI stack.

TL;DR: what we actually concluded

• Qwen3.8-27B is the release that makes local AI hard to dismiss. It is small enough to run on powerful personal hardware while landing surprisingly high on independent intelligence tests.
• Unsloth makes that increasingly practical. It packages local models, web search, code execution, media generation, and agent connections into one free desktop environment.
• DeepSeek Harness shows where agent infrastructure is going: modular. Models, tools, skills, sandboxes, storage, sessions, and even the interface can be swapped.
• Cursor Origin moves the code repository closer to the coding agent. Cursor can now host repos, pull requests, and agents in the same environment.
• Buzz treats AI agents more like coworkers. They can have identities, channels, permissions, keys, workflows, and an audit trail.
• Berd attacks a different problem: keeping your agents, projects, skills, tools, and models organized across environments.
• Grok Bot pushes agents toward actual computer workers that can sign into tools, learn routines, and keep working after you close your laptop.
• The common denominator is choice of model, location, tools, permissions, and interface becoming separate decisions.

That last point may matter more than any individual launch.

Qwen3.8-27B is absurdly capable for its size

We started with Qwen because the numbers looked weird.

Alibaba’s Qwen3.8-27B has 27 billion parameters, native image and video understanding, configurable reasoning, and a 262,144-token native context window that Qwen says can be extended as high as one million tokens. Qwen explicitly describes the 27B release as a dense model, an important correction to one tangent in our livestream where we discussed mixture-of-experts architecture as if it applied to this version. Qwen model card

Artificial Analysis currently gives Qwen3.8-27B an Intelligence Index score of 52. That is an extraordinary amount of capability packed into a model this size. Artificial Analysis

The obvious question from the chat was: can I actually run this thing?

Sort of.

Unsloth estimates that its recommended 4-bit version needs roughly 17 to 19GB of combined RAM and VRAM just to hold the model efficiently. That explains Corey’s experience on a 20GB GPU: the weights can fit while leaving painfully little memory for the model’s working context. Unsloth Qwen3.8-27B guide

Think of your computer’s memory like a desk. Loading the model puts a very large computer on the desk. The context window is all the documents you still need room to spread around it.

A 20GB machine can technically clear the first hurdle and still run out of desk.

One other correction from the stream: quantization and distillation are different techniques. Quantization stores a model’s numbers at lower precision to reduce memory and compute. Distillation trains a smaller model to imitate a larger one. Both can make AI cheaper, but they are not interchangeable terms.

Unsloth turns local AI into something normal people can actually use

Running a local model used to mean downloading several developer tools, finding the correct model format, figuring out quantization, and then discovering that your GPU had other plans.

Unsloth Desktop is trying to turn that into software.

The free, open-source desktop app can run models locally, generate images and video, search the web, execute code in a sandbox, and expose local models through an OpenAI-compatible API. It can also connect Claude Code, Codex, and other agent interfaces directly to the models running on your machine. Unsloth

That last feature is the one I would pay attention to.

You could keep using an agent interface you already understand while routing simpler work to a model running locally.

For example:

1. Give Codex a software project.
2. Tell it to delegate a well-defined research or code task to your local Qwen model.
3. Qwen handles that work on your own hardware.
4. Save the more expensive frontier model for the part that actually needs it.

That turns model selection into resource allocation.

We have covered the basics of running local models before in our guide to running AI locally with LM Studio. Unsloth pushes the idea further by treating local models as workers that other agents can call.

DeepSeek Harness explains why “the model” is becoming only one layer

DeepSeek provided my favorite line from the entire roundup:

“The model is the soul of an agent.”

Its new open-source DeepSeek Harness handles everything around that soul.

DeepSeek’s architecture makes models, tools, skills, sessions, sandboxes, storage, agent loops, scheduling, and even the UI into plugins. It also records what the model sees and does in an append-only session log that can be inspected, resumed, forked, searched, and replayed. DeepSeek Harness

That modularity is the important part.

A year ago, choosing ChatGPT or Claude often meant choosing an entire product. Your model, interface, tools, context, and workflows mostly came as a bundle.

These new systems increasingly let you choose separately:

• Which model thinks?
• Which harness gives it tools?
• Where does it run?
• Which skills can it use?
• Which data can it see?
• Which interface do humans use to supervise it?

DeepSeek Harness is still explicitly a developer preview, so normal users can safely admire it from a distance for now. DeepSeek Harness on GitHub

Developers should care more. The architecture points toward a world where replacing the underlying model becomes closer to changing an engine than rebuilding the entire car.

Cursor wants your agents and code to live together

Cursor Origin makes the same argument from another direction.

Cursor can now host repositories itself. Origin launched in early beta with repos, pull requests, code browsing, GitHub syncing, and agents that can work directly against the code you are viewing. Cursor says more “agent-native” features are coming. Cursor Origin

For anyone who finds GitHub intimidating, the simplified mental model is:

GitHub is Google Drive plus version history plus collaboration for code.

Origin wants to move that layer inside the same environment where your AI coding agents already work.

That does not make GitHub obsolete tomorrow. GitHub has an enormous ecosystem and sits at the center of modern software development.

But Cursor is making a clear bet: when agents write a large portion of the code, the code host itself should be designed around agents.

Buzz asks: what if the AI joined Slack instead of sitting beside it?

Buzz was probably the most immediately understandable new product we showed.

It looks like a team workspace. Humans have channels. Agents have channels. You can mention an agent, assign work, bring several agents into the same conversation, and watch them hand tasks between one another.

Underneath, Block built something more interesting.

Buzz uses a Nostr-style event architecture where messages, reactions, workflow actions, approvals, and Git events are signed events in a shared log. Agents can have their own keys, channel memberships, and audit trails. Buzz

That answered a good question from the live chat: how is this different from putting agents in Telegram?

The answer is structure and identity.

Telegram is primarily a messaging interface. Buzz is trying to make the workspace itself machine-operable.

An agent can participate in the project rather than merely receive commands through a chat window.

Berd solves the mess created by owning too many AI tools

Then we showed Berd.

Yes, this is the one with the animated agent creatures.

Someone at Block looked at the AI industry’s 400 identical dark-mode dashboards and apparently chose violence.

The visual weirdness hides a useful idea.

Block describes Berd as an open-source desktop app for working with AI agents. Its product documentation centers projects, files, agents, models, skills, extensions, automations, and local context inside one persistent workspace. Berd

The pain it solves becomes obvious once you use multiple AI environments.

Suppose you create a great research skill for Codex. You use Codex on three computers. You also use Claude Code and another agent.

Now you potentially have several slightly different versions of the same instructions scattered across several systems.

Update one and the others drift.

Berd’s more interesting promise is giving those reusable resources a home outside any one model provider.

That is skill versioning for an increasingly multi-agent world.

Grok Bot takes the “AI coworker” idea literally

Near the end, we pulled up Grok Bot.

xAI describes it as an AI teammate that gets its own computer, signs into your tools, learns routines by watching you perform them, runs tasks on schedules, and can collaborate with other bots. Grok Bot

That starts looking less like chat and more like hiring a weird digital operations team.

The product direction matters more than the exact tier.

Grok Bot has its own computer. Buzz gives agents their own workspace identities. Berd gives them a persistent home. DeepSeek gives developers interchangeable infrastructure.

Several companies have independently arrived at the same assumption:

An agent needs more than a chatbot window.

Video insights: the full livestream, timecoded

Below are the key moments from our August 20 livestream. Click any timestamp to jump straight to that part of the discussion.

• (0:44) We frame the stream around translating a flood of new AI tools into something useful for normal people.
• (1:48) Grok 4.6, new Meta models, and other releases make the public model frontier feel increasingly crowded.
• (2:11) We distinguish the “public frontier” from unreleased models that frontier labs may already have internally.
• (2:47) Corey explains model releases as checkpoints taken from longer training and development processes, rather than one fixed model being built once.
• (5:45) Grant explains open-weight models as models whose weights can be downloaded and hosted outside the company that created them.
• (6:45) Qwen3.8-27B becomes the example of a relatively compact model that could plausibly run on powerful consumer hardware.
• (7:11) Corey describes trying Qwen3.8-27B on a Dell Pro Max with roughly 20GB of VRAM and hitting context-memory limits.
• (8:04) We explain that the model shown in benchmarks often differs from the lower-precision quantized version people can realistically run locally.
• (9:20) Artificial Analysis becomes our main visual reference for comparing model intelligence.
• (11:02) Corey says he is becoming increasingly “disinterested in benchmarks” when leaderboard results do not match the experience of using a model.
• (12:11) A 27B model landing in the 50s on Artificial Analysis is treated as the striking part of Qwen3.8-27B’s release.
• (14:41) A viewer asks what the best models looked like a year earlier, prompting a retrospective through Artificial Analysis.
• (16:59) Grant’s answer for normal users is simple: care about model rankings mainly to figure out which model is best for your task.
• (17:30) For businesses, model choice increasingly becomes an economics question: which model is good enough for the lowest reasonable cost?
• (19:35) Grant demonstrates OpenRouter as a single interface for trying and comparing many different models.
• (20:20) A viewer asks whether current open models have reached the quality of frontier models from roughly a year ago; we conclude they are getting remarkably close.
• (24:27) Corey gives a plain-English explanation of mixture-of-experts models: only parts of the model activate for a given task instead of the entire network.
• (26:17) Grant boils model selection down to two questions: what intelligence do you need, and what intelligence is cheap enough to use repeatedly?
• (27:28) Corey argues that the cost of serving a unit of intelligence is falling while each person’s appetite for AI tokens is exploding.
• (29:42) Grant says Anthropic’s previous advantage was often its interface and tools, including Claude Code, skills, and Cowork, rather than model intelligence alone.
• (32:03) Grant argues that local models matter because personal AI may eventually live on your own device, keeping more control and private information with you.
• (33:35) Corey expects a more hybrid future, with some tasks handled locally and others still using larger cloud models.
• (35:01) Unsloth is introduced through its reputation for making large models easier to run on consumer hardware through optimized quantization.
• (36:02) Unsloth Desktop is presented as a user-friendly way to download and run models locally.
• (37:41) One of the standout Unsloth features is connecting Claude Code, Codex, and other agents to locally running models.
• (40:17) A viewer asks whether using Unsloth through Claude or ChatGPT consumes provider tokens; we explain that local inference itself runs on your machine.
• (41:13) Grant suggests routing simple, well-specified jobs to a local model while reserving more expensive frontier intelligence for harder work.
• (41:45) Unsloth and OpenClaw are separated conceptually: Unsloth runs models, while OpenClaw provides an agent runtime and tools around them.
• (47:11) Corey singles out Unsloth’s self-healing tool calls, which can detect, repair, and retry malformed tool requests from smaller models.
• (48:13) Asked whether Hermes can use Qwen3.8-27B directly, we answer yes through a local model server or compatible endpoint.
• (49:39) The biggest practical limitation Corey found with Qwen3.8-27B locally was memory, especially when trying to maintain useful context.
• (53:08) The stream transitions into DeepSeek Harness and Cursor Origin, two more developer-facing releases.
• (55:51) DeepSeek Harness is explained as an open framework you can clone and customize to create your own coding-agent environment.
• (56:25) Its defining idea is “everything is a plugin,” covering models, tools, skills, sessions, sandboxes, storage, and more.
• (58:02) DeepSeek’s phrase “the model is the soul of an agent” becomes our favorite explanation for the relationship between model and harness.
• (59:39) Cursor Origin is jokingly framed as Cursor’s attempt at a “GitHub killer.”
• (1:02:03) Corey’s simplest description of Buzz is “Slack for agents,” where humans and agents share a workspace.
• (1:04:38) Corey describes creating “John the Delegator,” an agent whose job is to break a request apart and assign pieces to other agents.
• (1:05:03) Asked how Buzz differs from Telegram, we argue the biggest difference is organization through channels, threads, projects, and agent-specific structure.
• (1:06:20) Buzz’s deeper architecture gets attention: messages, approvals, workflow steps, and Git events can all live in a signed event log.
• (1:09:45) Berd arrives with its intentionally bizarre visual hook: AI agents can have little animated bodies and characters.
• (1:11:38) Under the playful layer, Berd is described as a home base for agents, projects, skills, automations, and models.
• (1:12:30) Corey’s favorite Berd idea is centralized skill management instead of keeping slightly different copies of a skill inside several AI apps.
• (1:17:52) The conversation widens into a question: if consumers do not wake up wanting “productivity,” what does a breakout consumer AI product actually look like?
• (1:20:59) Grant argues that the winning interface may be the one that abstracts away more interface, letting people simply ask for outcomes by voice.
• (1:21:45) Corey’s example of having ChatGPT complain to a company and request a refund shows what “personal assistant” starts to mean once AI can take actions.
• (1:24:30) Grant argues that software companies now need users to actually like and trust them because agents make substitution between competing services easier.
• (1:28:22) Grok Bot finally enters the roundup as an AI teammate product designed to take real work rather than just answer messages.
• (1:30:42) Its core pitch is that bots can sign into tools, use software like a person, and return completed work.
• (1:31:43) Our biggest reservation is price: we want a cheaper way to test the product before reorganizing existing workflows around it.
• (1:37:11) Grant notes that political resistance to data centers now crosses partisan lines because the physical effects are local even when AI demand is global.
• (1:43:55) We converge on a two-sided conclusion: AI can unlock enormous scientific benefits while its infrastructure and social costs still deserve scrutiny.
• (1:45:20) Grant imagines a more decentralized compute future where homes combine batteries, solar, and local servers instead of relying entirely on giant centralized facilities.
• (1:49:22) Corey jokes that every long Neuron livestream eventually arrives at data centers, neatly ending a tool roundup as an argument about where intelligence should physically live.

Three things we learned after fact-checking the livestream

A good live show includes the occasional moment where two people confidently explain something and the documentation later raises its hand.

Three updates are worth making explicit.

First, Qwen3.8-27B is dense, not mixture-of-experts. Our MoE explanation was useful background, but Qwen’s own model card calls this particular 27B model dense. Qwen model card

Second, Qwen’s giant advertised context window and your usable local context are different numbers. The model supports 262K tokens natively, but a 4-bit local build still needs roughly 17 to 19GB before you start giving it a large conversation. Unsloth Qwen3.8-27B guide

Third, Stripe did acquire OpenRouter, but the acquisition price was not officially disclosed. Stripe and OpenRouter confirmed the deal on August 19. Outside reporting has put the value above $7B. OpenRouter announcement

Questions from the chat, answered

Can Qwen3.8-27B run on a Mac Studio?

Yes, with enough unified memory. Unsloth recommends roughly 17 to 19GB total memory for its 4-bit build. A Mac with more headroom will give you more usable context. Performance depends heavily on the exact chip and configuration.

Are today’s open models as good as the frontier models from last year?

In some tasks, surprisingly close. Qwen3.8-27B scores 52 on Artificial Analysis despite its modest size. That does not mean every open model now equals every frontier model from 2025. It does show how quickly capability is moving down the hardware stack.

What websites were we using to compare models?

Artificial Analysis for independent model benchmarks and OpenRouter for testing many models behind a common interface.

Why wouldn’t a company simply use GPT-5.6 for everything?

Because “best” depends on the task. Cost, latency, privacy, context requirements, uptime, tool compatibility, and data residency can all matter more than squeezing out one extra point of benchmark performance.

What does Unsloth cost?

Unsloth Desktop is free and open source. Unsloth separately offers commercial Pro and Enterprise training products.

Does connecting Unsloth to Claude Code or Codex use paid model tokens?

The local model inference runs on your hardware. Your surrounding tools may still have their own subscription, login, API, or external-service costs.

How does Unsloth compare with OpenClaw?

They solve different layers. Unsloth primarily runs and serves models locally. OpenClaw provides an agent runtime, workspace, session system, and tool wiring. They can be used together.

Can Hermes use a local Qwen model?

Yes. Hermes supports custom and self-hosted OpenAI-compatible endpoints, including local servers.

Can I simply increase Qwen’s context-window setting?

The model supports 262K tokens natively, but your hardware determines how much context is practical locally. Increasing the setting also increases memory consumption.

How is Buzz different from Telegram?

Buzz gives humans and agents persistent workspace identities, channels, signed events, access boundaries, and an audit trail. Telegram gives you messaging. You could build agents on top of Telegram, but Buzz is designed around them from the beginning.

The model is becoming the least sticky part of the stack

The model race still matters. Frontier intelligence can unlock things a 27B local model cannot.

But look at what happened during this one week.

Qwen made a small open model much better.

Unsloth made local models easier to run.

DeepSeek modularized the agent harness.

Cursor moved code hosting toward the agent.

Buzz gave agents a workplace.

Berd gave agents and skills a persistent home.

Grok Bot gave agents their own computers.

When intelligence becomes easier to swap, value moves outward.

It moves into orchestration, context, tools, permissions, identity, memory, interface, economics, and trust.

That also explains our strange final detour into data centers.

Local AI is partly a product story and partly an infrastructure story. Every task moved onto your laptop is a task that does not need to travel to a giant centralized cluster. Every task that still requires frontier intelligence keeps the cloud valuable.

Corey’s hybrid prediction is probably the safest one: your personal AI stack may eventually use both.

The unanswered question is who controls that stack.

Will we assemble personal AI systems from interchangeable models, agents, skills, and local hardware that we own?

Or will OpenAI, Anthropic, Google, xAI, and the other platforms make the integrated cloud experience so convenient that most people never bother?

The tools we covered this week are building the first version.