Blender MCP With a Local LLM: Build Animations in VS Code Cline With Qwen3.8-Flash-Next (2026 Setup Guide)

You can now drive Blender with plain English prompts from VS Code, and you do not need a cloud model to do it. A Blender MCP server lets an AI agent read your scene, run Python inside Blender and look at the viewport, and agents like Cline can talk to a model running on your own PC through Ollama, llama.cpp or LM Studio. This guide shows the full local setup with Qwen3.8-Flash-Next, the 125B Qwen MoE that only activates 6B parameters per token, plus smaller models for normal GPUs. It covers every prerequisite, both Blender MCP servers (the official Blender Lab one and the community MCP for Blender), the exact config JSON for Cline and other clients, a worked example that builds a bouncing-ball animation from prompts, and the fixes for the errors you will most likely hit.

How Blender MCP With a Local LLM Works

Blender has no built-in connection to language models. The Model Context Protocol (MCP) fills that gap with three pieces that talk to each other:

1. The Blender add-on opens a small TCP socket inside Blender (port 9876 by default) and runs whatever Python it receives.
2. The MCP server is a separate Python process that your agent starts over stdio. It turns tool calls such as get_scene_info or execute_blender_code into socket messages for the add-on.
3. The agent (Cline in VS Code, Continue, OpenCode and so on) sends your prompt and the list of Blender tools to the model, then runs the tool calls the model asks for.

The model itself can live anywhere that speaks an OpenAI-style or Ollama API. In this guide it runs on your own machine, so your scenes, prompts and code never leave the PC.

Which Blender MCP Server to Use

There are now two free servers worth using, and the naming is confusing because the community one was called blender-mcp first.

My pick for this tutorial is MCP for Blender, because it runs with one uvx command on any recent Blender and Cline launches it without a cloned repo. If you are on Blender 5.1 or newer, the official server is a good second option because its API documentation search helps local models write correct Blender 5 Python. Both use port 9876, so run only one at a time or change one port.

Prerequisites

• Blender: 4.5 LTS or 5.x is ideal. The community server works from 3.0, the official one needs 5.1.
• Python 3.10 or newer. uv can download a managed Python for you, so you do not need to touch your system Python.
• uv (which provides uvx). Install it with the official installer, not pip install uv:

  # Windows (PowerShell)
  winget install --id=astral-sh.uv -e
  # macOS
  brew install uv
  # Linux / macOS (official script)
  curl -LsSf https://astral.sh/uv/install.sh | sh

  Open a new terminal afterwards and check with uvx --version. On Windows, run where uvx and note the full path, because VS Code sometimes cannot see it.

• VS Code with the Cline extension (version 4.1.25 or newer fixes the 5-minute timeout with slow local models).
• A local model server: Ollama, llama.cpp or LM Studio.
• Git, only if you want the official Blender Lab server.

Run Qwen3.8-Flash-Next Locally

Qwen3.8-Flash-Next is a sparse mixture-of-experts model released in late August 2026: 125B total parameters, about 6B active per token (512 experts, 10 routed plus 1 shared), a native 262K context and text, image and video input. It supports tools and thinking, and thinking depth is set with reasoning_effort. Only 6B parameters are used per token, so it generates quickly even when most of the weights sit in system RAM. The catch is that all 125B weights still have to be in memory.

Which file fits your machine

Option A: Ollama

ollama pull qwen3.8-flash-next:125b-a6b-q4_K_M
ollama run qwen3.8-flash-next:125b-a6b-q4_K_M "Say hi"

Before you start the Ollama app, set these environment variables (Windows: System Properties, Environment Variables, then restart Ollama from the tray):

OLLAMA_CONTEXT_LENGTH=65536   # Cline's prompt plus tool list needs a big window
OLLAMA_KEEP_ALIVE=-1          # never unload the model between requests
OLLAMA_FLASH_ATTENTION=1
OLLAMA_KV_CACHE_TYPE=q8_0     # halves KV cache memory

Ollama splits a model that does not fit on one card across all your GPUs and puts the rest in system RAM automatically.

Option B: llama.cpp (most control)

llama.cpp gives you control over which layers go to which GPU and how many MoE experts stay in RAM. Download a quant and start the OpenAI-compatible server (recent builds use llama serve; older builds call the same thing llama-server with identical flags):

hf download unsloth/Qwen3.8-Flash-Next-GGUF --include "*UD-Q3_K_XL*" --local-dir D:/models/qwen38-flash-next

llama serve -m D:/models/qwen38-flash-next/UD-Q3_K_XL/Qwen3.8-Flash-Next-UD-Q3_K_XL-00001-of-00003.gguf ^
  --jinja -ngl 99 --n-cpu-moe 36 --tensor-split 1,1 ^
  -c 65536 -fa on --cache-type-k q8_0 --cache-type-v q8_0 ^
  --temp 0.7 --top-p 0.8 --top-k 20 --min-p 0 --presence-penalty 1.5 ^
  --chat-template-kwargs "{\"reasoning_effort\":\"low\"}" ^
  --host 127.0.0.1 --port 8080

• Point -m at the first shard; check the real file name in your folder, because the shard count can differ.
• --jinja is required. Without it the chat template does not format tool calls and Cline sees plain text instead of tool use.
• -ngl 99 puts every layer on the GPUs, then --n-cpu-moe 36 moves the expert weights of the first 36 layers back to system RAM. Raise it if you run out of VRAM, lower it if your cards have spare memory.
• --tensor-split 1,1 shares the GPU part evenly across two cards.
• The sampling values are Qwen’s recommended non-thinking settings. For agent work, reasoning_effort of low or medium is far quicker than the default xhigh.

Unsloth also publishes an MTP (multi-token prediction) draft file that it reports gives 1.3 to 1.7 times faster generation, but at the time of writing it needs a custom llama.cpp branch, so start without it.

Option C: LM Studio

Search for unsloth/Qwen3.8-Flash-Next-GGUF in LM Studio, pick a quant that fits, set the context length to 32K to 64K, enable Flash Attention and turn on “Keep model in memory”. Then start the local server from the Developer tab (or run lms server start); it listens on http://localhost:1234. Update LM Studio’s llama.cpp runtime first, because older runtimes cannot load the new architecture.

Tested Hardware: 2x RTX 5080 and 128 GB RAM

This setup was tested on a Windows PC with two RTX 5080 cards (16 GB each, 32 GB of VRAM in total) and 128 GB of DDR5 system RAM, 160 GB of model memory in total. Qwen3.8-Flash-Next ran fully locally with Cline and Blender MCP. The first reply took roughly 3 minutes, and every reply after that was fast.

Why the first reply is so slow

• Loading the weights. 90 to 120 GB has to come off the disk. Even a fast NVMe drive at about 3.5 GB/s needs 30 seconds or more for that, and a SATA SSD needs several minutes. With memory mapping (mmap) Windows reads pages the first time they are touched, so part of this load happens during your first prompt.
• Filling both GPUs. The GPU-resident layers and buffers are copied to each RTX 5080 before the first token.
• Prompt processing. Cline sends a long system prompt plus the description of every MCP tool, which I estimate at 10,000 to 20,000 tokens before your own words. With most experts in system RAM, processing that prompt is much slower than generating tokens.
• Thinking. At the default xhigh reasoning effort the model can think for a long time before its first tool call.

After the first reply the weights stay in RAM and VRAM, and the server reuses the cached prompt prefix, so each new turn only processes the new tokens. With only 6B active parameters per token, generation then feels quick.

Tips to keep it fast

• Keep the model loaded. OLLAMA_KEEP_ALIVE=-1 in Ollama, “Keep model in memory” in LM Studio, or just leave llama serve running. Otherwise the 3-minute load comes back every time the model unloads.
• Warm it up. After starting the server, send one short message (for example ollama run ... "hi") before you open Cline.
• Leave mmap on (the default). It lets the OS cache the file and start quickly. Use --no-mmap only if you have clear RAM headroom, and avoid --mlock on a 128 GB machine, because locking 110+ GB can starve Windows and Blender.
• Split across both GPUs. Use --tensor-split 1,1 and tune --n-cpu-moe until each card has about 1.5 GB free, which leaves room for Blender’s own viewport.
• Use a Q3 quant on 128 GB of RAM. UD-Q3_K_XL (90 GB) leaves plenty of RAM for Blender, VS Code and Windows, while Q4 is tight.
• Store the GGUF on your fastest NVMe drive, and do not change the Cline system prompt or MCP server list mid-task, because that invalidates the cached prefix.

Smaller Models That Are Good at Tool Calling

Blender MCP needs a model that reliably emits well-formed tool calls and writes correct bpy Python. These current models do both and fit normal GPUs. All have the tools tag in Ollama:

Vision matters here: MCP for Blender can send viewport screenshots back to the model, and a vision model can check its own work. Avoid models under about 10B for multi-step animation; they lose track of object names and frame numbers. If you are unsure which quant to download, see our GGUF quantization guide.

Install the Blender Add-on

MCP for Blender (community, recommended)

1. Install the add-on file with uv:

   uvx mcp-for-blender install-addon

   This copies blender_mcp.py into Blender’s add-on folder. If you prefer manual install, download addon.py from github.com/ahujasid/mcp-for-blender and use Edit, Preferences, Add-ons, Install from Disk.

2. In Blender open Edit, Preferences, Add-ons, search for “MCP” and tick Interface: MCP for Blender.
3. In the 3D viewport press N, open the MCP for Blender tab and click Start MCP Server. The port field should read 9876.

There is also a one-line installer that sets up both the add-on and supported clients (irm https://www.mcp-for-blender.com/install.ps1 | iex on Windows), but doing it by hand shows you exactly what changed. To update later run uvx mcp-for-blender@latest update.

Blender Lab MCP (official, Blender 5.1+)

1. Download the extension mcp-1.0.3.zip from the Blender Lab MCP page and drag it into Blender twice: the first drop adds the Blender Lab extension repository, the second installs the add-on. Install from Disk also works.
2. In Edit, Preferences, Add-ons search “mcp” and expand MCP (maintainer Blender Lab). It should show Host localhost, Port 9876, Auto Start on and “Server is running”.
3. Get the server code:

   git clone https://projects.blender.org/lab/blender_mcp.git C:/blender_mcp

   The server lives in C:/blender_mcp/mcp and is started with uv --directory C:/blender_mcp/mcp run blender-mcp.

Enable Blender MCP in VS Code Cline

Step 1: Connect Cline to your local model

Open the Cline panel, click the settings (gear) icon and choose an API provider:

For the OpenAI Compatible provider, set the context window in Cline’s model settings to the same value you passed with -c (65536 above), and tick image support if you use a vision model. Recent Cline versions use the base URL exactly as typed, so include /v1.

Step 2: Add the Blender MCP server

In the Cline panel click the MCP Servers icon in the top toolbar, open the Configure tab and click Configure MCP Servers. That opens cline_mcp_settings.json (on Windows it is usually under %APPDATA%/Code/User/globalStorage/saoudrizwan.claude-dev/settings/). Paste this for MCP for Blender:

{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": ["mcp-for-blender"],
      "env": {
        "BLENDER_HOST": "localhost",
        "BLENDER_PORT": "9876"
      },
      "disabled": false,
      "autoApprove": ["get_scene_info"]
    }
  }
}

If VS Code cannot find uvx on Windows, replace "uvx" with the full path from where uvx (use forward slashes, e.g. C:/Users/you/.local/bin/uvx.exe), or use "command": "cmd", "args": ["/c", "uvx", "mcp-for-blender"].

For the official Blender Lab server use this entry instead:

{
  "mcpServers": {
    "blender-lab": {
      "command": "uv",
      "args": ["--directory", "C:/blender_mcp/mcp", "run", "blender-mcp"],
      "env": { "BLENDER_MCP_PORT": "9876" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Save the file. The server appears in the Installed list with a green dot, and expanding it shows its tools. Leave execute_blender_code off the autoApprove list at first: it runs arbitrary Python inside Blender, and approving each call shows you exactly what the model is about to do.

Step 3: Use it

Make sure Blender is open with its MCP server running, start a new Cline task in Act mode and ask something simple like “Use the blender tools to tell me what objects are in my scene.” Cline should call get_scene_info and list the default Cube, Camera and Light. If it does, everything is wired up.

Other Ways to Run It (Copilot, Continue, Kilo Code, CLI)

Cline is the most popular open-source agent for this, but the same Blender server works in any MCP client. These are the current options and their config format:

• VS Code Copilot Chat (agent mode). Add .vscode/mcp.json to your project:

  {
    "servers": {
      "blender": { "type": "stdio", "command": "uvx", "args": ["mcp-for-blender"] }
    }
  }

  Then select a local Ollama model in Copilot’s model picker (Manage Models, Ollama) and switch the chat to Agent mode.

• Continue (VS Code and JetBrains). MCP works in Agent mode only. In ~/.continue/config.yaml:

  models:
    - name: Qwen3.8 Flash Next
      provider: ollama
      model: qwen3.8-flash-next:125b-a6b-q4_K_M
      capabilities: [tool_use, image_input]
  mcpServers:
    - name: Blender
      command: uvx
      args: [mcp-for-blender]

• Kilo Code. A Cline/Roo fork with the same mcpServers JSON as Cline, so the block above works as is.
• Roo Code. The project was discontinued in April 2026 and its repository archived in May 2026. It still runs but gets no fixes, so move to Cline or Kilo Code.
• Cline CLI. Run cline mcp for a wizard or cline mcp add in scripts; the CLI reads ~/.cline/data/settings/cline_mcp_settings.json.
• OpenCode (terminal, Claude Code style). In opencode.json:

  {
    "$schema": "https://opencode.ai/config.json",
    "provider": {
      "ollama": {
        "npm": "@ai-sdk/openai-compatible",
        "name": "Ollama",
        "options": { "baseURL": "http://localhost:11434/v1" },
        "models": { "qwen3.8-flash-next:125b-a6b-q4_K_M": { "name": "Qwen3.8 Flash Next" } }
      }
    },
    "mcp": {
      "blender": { "type": "local", "command": ["uvx", "mcp-for-blender"], "enabled": true }
    }
  }

• llama.cpp’s own web UI. The official Blender Lab page uses the llama.cpp server’s built-in chat as its example client, which is handy if you want no editor at all.

Worked Example: Build a Bouncing Ball Animation From Prompts

Save a new .blend file first (for example bounce.blend), so relative output paths work and you can always reload. Then send these prompts to Cline one at a time and approve each tool call after reading it.

Prompt 1: Inspect the scene

Use the Blender MCP tools to list every object in the current scene with its type and location. Also tell me the Blender version.

Knowing the version matters: Blender 5 renamed and moved several Python APIs, and the model writes better code when it knows which version it is targeting.

Prompt 2: Build the set

Delete the default cube. Add a 20 x 20 m ground plane at the origin with a light grey material.
Add a UV sphere named "Ball" with radius 0.5 at x=-6, z=3, smooth shading and a glossy red material.

Prompt 3: Animate it

Animate "Ball" at 24 fps over frames 1 to 120. It starts in the air at x=-6, z=3 and bounces three times while moving to x=6.
Ground contacts at frames 20, 60 and 100 with z=0.5. Each bounce is lower than the last.
Make contacts sharp (vector handles) and tops smooth. Add squash (scale 1.2, 1.2, 0.75) on each contact frame and stretch (0.9, 0.9, 1.15) three frames before and after.

Prompt 4: Camera, light and render settings

Add a camera at (0, -14, 4) that always points at "Ball" using a Track To constraint, and make it the scene camera.
Add a sun light with strength 3. Set the render engine to EEVEE, resolution 1280x720, and output an H.264 MP4 to //renders/bounce_.
Then take a viewport screenshot and check the ball is in frame at frames 1, 60 and 120.

Press Space in Blender to play the animation, then render it with Render, Render Animation (Ctrl+F12). I recommend rendering yourself rather than through MCP, because a long render blocks Blender and the tool call can time out.

Reference script

This is the kind of Python a good model sends through execute_blender_code for prompts 2 to 4. It is my own reference version, written to work on Blender 4.x and 5.x. Paste it into Blender’s Scripting tab if you want to compare the model’s result or test your Blender setup without a model:

import bpy

scene = bpy.context.scene
prefs = bpy.context.preferences.edit

# Set: remove default cube, add ground and ball
cube = bpy.data.objects.get("Cube")
if cube:
    bpy.data.objects.remove(cube, do_unlink=True)

bpy.ops.mesh.primitive_plane_add(size=20, location=(0, 0, 0))
ground_mat = bpy.data.materials.new("GroundGrey")
ground_mat.use_nodes = True
ground_mat.node_tree.nodes["Principled BSDF"].inputs["Base Color"].default_value = (0.6, 0.6, 0.6, 1)
bpy.context.active_object.data.materials.append(ground_mat)

bpy.ops.mesh.primitive_uv_sphere_add(radius=0.5, location=(-6, 0, 3))
ball = bpy.context.active_object
ball.name = "Ball"
bpy.ops.object.shade_smooth()
mat = bpy.data.materials.new("BallRed")
mat.use_nodes = True
bsdf = mat.node_tree.nodes["Principled BSDF"]
bsdf.inputs["Base Color"].default_value = (0.8, 0.05, 0.05, 1)
bsdf.inputs["Roughness"].default_value = 0.2
ball.data.materials.append(mat)

# Timing
scene.render.fps = 24
scene.frame_start, scene.frame_end = 1, 120

def key(frame, loc, scale, handle):
    prefs.keyframe_new_handle_type = handle   # VECTOR = sharp, AUTO_CLAMPED = smooth
    ball.location = loc
    ball.scale = scale
    ball.keyframe_insert(data_path="location", frame=frame)
    ball.keyframe_insert(data_path="scale", frame=frame)

old_handle = prefs.keyframe_new_handle_type
normal, squash, stretch = (1, 1, 1), (1.2, 1.2, 0.75), (0.9, 0.9, 1.15)

key(1,   (-6, 0, 3.0), normal, 'AUTO_CLAMPED')
for contact, x, top_x, top_z in [(20, -4, -2, 2.2), (60, 0, 2, 1.4), (100, 4, None, None)]:
    key(contact - 3, (x - 0.3, 0, 0.9), stretch, 'AUTO_CLAMPED')
    key(contact,     (x, 0, 0.5 * 0.75), squash, 'VECTOR')   # squashed ball touches the ground
    key(contact + 3, (x + 0.3, 0, 0.9), stretch, 'AUTO_CLAMPED')
    if top_x is not None:
        key(contact + 20, (top_x, 0, top_z), normal, 'AUTO_CLAMPED')
key(120, (6, 0, 0.5), normal, 'AUTO_CLAMPED')
prefs.keyframe_new_handle_type = old_handle

# Camera and light
bpy.ops.object.camera_add(location=(0, -14, 4))
cam = bpy.context.active_object
track = cam.constraints.new(type='TRACK_TO')
track.target = ball
track.track_axis = 'TRACK_NEGATIVE_Z'
track.up_axis = 'UP_Y'
scene.camera = cam

bpy.ops.object.light_add(type='SUN', location=(4, -4, 8))
bpy.context.active_object.data.energy = 3

# Render settings (engine and video names changed between 4.x and 5.x)
for engine in ('BLENDER_EEVEE', 'BLENDER_EEVEE_NEXT'):
    try:
        scene.render.engine = engine
        break
    except TypeError:
        pass
scene.render.resolution_x, scene.render.resolution_y = 1280, 720
img = scene.render.image_settings
if hasattr(img, "media_type"):
    img.media_type = 'VIDEO'
img.file_format = 'FFMPEG'
scene.render.ffmpeg.format = 'MPEG4'
scene.render.ffmpeg.codec = 'H264'
scene.render.filepath = "//renders/bounce_"

Note the trick for sharp contacts: instead of editing F-curves (whose Python API changed with Blender 4.4’s layered actions), the script switches the “new keyframe handle type” preference between inserts, which works the same on every version.

Prompting Tips for Better Animations

• One step per prompt. Local models do much better with “build the set”, then “animate”, then “camera” than with one huge request.
• Give numbers. Frame numbers, positions in metres and fps remove guesswork. “Bounce three times” alone leads to random timing.
• Name every object and refer to it by name in later prompts.
• Ask the model to verify. “Take a viewport screenshot at frame 60 and check the ball touches the ground” works well with vision models.
• Save versions. Ask Cline to save the file as bounce_v2.blend before big changes, or use Ctrl+S yourself. There is no undo for a bad Python script that deletes objects.
• Use Plan mode first in Cline for bigger scenes (a walking robot, a camera fly-through), then switch to Act once the plan looks right.

Troubleshooting

Cline shows the server in red with “spawn uvx ENOENT”

VS Code cannot find uvx. Use the full path from where uvx (Windows) or which uvx (macOS/Linux), or the cmd /c form shown above. Then fully quit VS Code and reopen it; reloading the window is not always enough.

“Could not connect to Blender” or tool calls time out

Blender must be open with the server started (N panel, Start MCP Server; the official add-on auto-starts). Check that the port in Blender matches BLENDER_PORT or BLENDER_MCP_PORT, and that you are not running both add-ons on 9876 at the same time. A firewall prompt for Blender on first start must be allowed for localhost.

The server fails to start after an update

Clear the uv cache and refetch: uv cache clean mcp-for-blender blender-mcp then uvx --refresh mcp-for-blender. If you use conda or pyenv, pin a managed Python with "args": ["--python", "3.11", "mcp-for-blender"]. If an old config still says blender-mcp, it keeps working, but uvx mcp-for-blender setup switches it to the new name.

The model prints JSON or XML instead of calling tools

Either the context window is too small (Cline’s prompt is cut off, so the model never sees the tool format) or the server does not apply the tool template. Set OLLAMA_CONTEXT_LENGTH or -c to at least 32768, always pass --jinja to llama.cpp, and use one of the models from the table above.

The first message hangs and then fails with a timeout

That is the slow first load described in the hardware section. Update Cline to 4.1.25 or newer (it no longer gives up after 5 minutes of silence from Ollama or LM Studio), warm the model up before starting, and keep it loaded.

The model thinks for minutes before every action

Lower the reasoning effort: --chat-template-kwargs "{\"reasoning_effort\":\"low\"}" in llama.cpp, or pick a non-thinking mode in your client. For Blender work, medium is usually enough.

Out of memory, or Windows becomes sluggish

Drop to a smaller quant (UD-Q3_K_XL or UD-Q2_K_XL), raise --n-cpu-moe, cut the context to 32768 and use a q8_0 KV cache. Leave at least 8 GB of RAM and 1.5 GB of VRAM free for Blender itself.

Python errors like “enum not found” or “has no attribute fcurves”

The model is using an API from a different Blender version. Tell it your exact version, paste the error back into Cline, and ask it to fix the script. The official Blender Lab server’s API docs search helps a lot here on Blender 5.1+.

Blender freezes while rendering

Do not render long animations through an MCP call. Let the model set up the scene and render settings, then press Ctrl+F12 yourself.

Security warning

Both servers run model-written Python with no sandbox, and the community add-on’s socket has no authentication. Keep it bound to localhost, do not auto-approve execute_blender_code on important projects, and work on copies of valuable .blend files. Blender Lab itself suggests a VM or a system without sensitive data.

FAQ

Can Blender MCP work fully offline?

Yes. With Ollama, llama.cpp or LM Studio serving the model and the add-on on localhost, nothing needs the internet after the downloads. Asset features like Poly Haven or Sketchfab import do need a connection.

How much RAM do I need for Qwen3.8-Flash-Next?

About 79 GB for the smallest sensible quant (UD-Q2_K_XL) plus room for context, so plan for 96 GB or more of combined RAM and VRAM. 128 GB of RAM with one or two 16 GB GPUs is a comfortable setup for Q3.

What is the best local model for Blender MCP on a 16 GB GPU?

qwen3.6:35b-a3b or gemma4:26b with some layers in system RAM, or devstral-small-2:24b and gpt-oss:20b if you want everything on the GPU.

Is the official Blender MCP better than MCP for Blender?

Neither is strictly better. The official server needs Blender 5.1+ and is strong at documentation lookup and scene analysis. MCP for Blender works on older Blender, starts with one uvx command and adds screenshots and asset tools.

Does Blender MCP work with Cursor or Claude Desktop too?

Yes. Any MCP client works with the same command and args. This guide focuses on local models, which is why it uses Cline, Continue, Kilo Code and OpenCode.

Can it make character animation?

It can keyframe anything you can script: objects, cameras, shape keys, and bones on an existing rig. For rigging and Mixamo-style animation of generated characters, combine it with StableGen for Blender.

Final Thoughts

Local Blender automation is practical now. Install uv, add MCP for Blender with one uvx command, point Cline at Ollama, llama.cpp or LM Studio, and you can build and animate scenes from prompts without sending anything to the cloud. Qwen3.8-Flash-Next is the strongest local brain for it if you have around 128 GB of RAM: expect a slow first reply while it loads, then quick turns once it stays in memory. On a single 16 to 24 GB GPU, Qwen3.6 35B-A3B, Gemma 4 26B or Qwen3.8 27B get you most of the way. Start with small, numbered prompts like the bouncing ball above, and build up from there.

Related guides:

• StableGen 0.4 for Blender: AI Texturing and Auto-Rigging
• Ollama Commands Cheat Sheet
• GGUF Quantization Explained
• Best Local LLMs With Vision and Video Understanding
• Liquid AI LFM3: Run Locally With Ollama, llama.cpp and LM Studio

Sources

• Blender Lab: MCP Server and projects.blender.org/lab/blender_mcp
• MCP for Blender wiki and MCP for Blender installation docs
• Official vs community Blender MCP comparison and StraySpark Blender MCP comparison (2026)
• Blender MCP config for Codex, Claude Code and OpenCode
• Unsloth: Qwen3.8-Flash-Next how to run locally and unsloth/Qwen3.8-Flash-Next-GGUF
• Ollama qwen3.8-flash-next tags, qwen3.6, gemma4 and qwen3.8
• Qwen3.8-Flash-Next specs
• Cline MCP docs and Cline changelog (Sept to Oct 2026)
• Roo Code shutdown and alternatives
• Ollama tool-calling models list and local tool-calling model tests
• Test setup reported by the Freakyjolly team: 2x RTX 5080 16 GB, 128 GB RAM, Windows (November 2026)