DEV Community

Cover image for How to Run Qwen3.5 with OpenClaw for Free Using Ollama?
Preecha
Preecha

Posted on

How to Run Qwen3.5 with OpenClaw for Free Using Ollama?

#agents #ai #llm #tutorial

You face high cloud bills when you run powerful AI agents every day. Qwen3.5 gives you frontier-level multimodal reasoning locally. You combine it with OpenClaw for persistent agent workflows and Ollama for simple local serving. The result is a complete AI agent that works 24/7 on your machine without subscriptions.

Try Apidog today

💡You test Ollama’s OpenAI-compatible endpoint and OpenClaw’s gateway directly inside Apidog. Visual requests, instant assertions, and saved test scenarios make every configuration change easy to verify.

Small choices matter. You pick the right model tag. You set the correct base URL. These decisions create big differences in speed and reliability. This guide shows you exact steps so you finish with a production-ready stack you control completely.

What Makes Qwen3.5 Perfect for Local Agent Work

Alibaba released Qwen3.5 in early 2026 as its first native vision-language model family. The 397B-A17B flagship uses a hybrid architecture. It combines Gated Delta Networks with sparse Mixture-of-Experts. Only 17 billion parameters activate per token. You get strong performance with far less memory.

Qwen3.5 Benchmark

Ollama hosts these practical tags you pull today:

  • qwen3.5:35b — fits in 24 GB VRAM, 256K context, full text and image support
  • qwen3.5:122b — needs 81 GB for deeper reasoning

You run qwen3.5 locally and keep your data private. The model scores 86.7 on TAU2-Bench and 85.0 on MMMU. You therefore trust it for agent tasks that mix text, screenshots, and tool calls.

How OpenClaw Turns Qwen3.5 Into a Real Agent

OpenClaw runs as your always-on agent runtime. You connect it to WhatsApp, Telegram, Slack, Discord, or Signal once. The agent listens continuously. When you send a message, OpenClaw routes it to qwen3.5, calls tools, controls your browser with Playwright, edits files, updates calendars, and answers proactively.

Image

You store memory across sessions. The agent remembers your projects and preferences forever. You install community skills or let qwen3.5 write new ones on demand. OpenClaw therefore becomes your personal digital assistant that never sleeps.

Why Ollama Makes the Integration Simple

Ollama serves models locally and exposes an OpenAI-compatible endpoint on port 11434. You point OpenClaw at http://localhost:11434/v1 and set the model to qwen3.5:35b. Ollama handles quantization, GPU offload, and context management automatically.

You achieve fast token generation on consumer hardware. You keep the full 256K context window that qwen3.5 needs for long agent conversations. You avoid cloud costs and data leaks at the same time.

Prerequisites You Need to Meet

You prepare your machine before you start:

  • Use macOS 14 or later, Ubuntu 22.04/24.04, or Windows 11 with WSL2.
  • Ensure at least 24 GB VRAM for the 35B model or 32 GB unified memory on Apple Silicon.
  • Keep 30 GB free disk space.
  • Install Node.js 22 or higher and Ollama 0.17 or newer.

You verify your GPU later with one command. Hardware that meets these requirements gives you responsive performance. You fall back to smaller quantized models if you have less memory.

Install Ollama and Pull Qwen3.5

You start by installing Ollama:

macOS:

brew install ollama
brew services start ollama
Enter fullscreen mode Exit fullscreen mode

Linux:

curl -fsSL https://ollama.com/install.sh | sh
systemctl enable --now ollama
Enter fullscreen mode Exit fullscreen mode

You confirm the service runs with:

ollama list
Enter fullscreen mode Exit fullscreen mode

Next, you pull the model:

ollama pull qwen3.5:35b
Enter fullscreen mode Exit fullscreen mode

The download finishes in 10 to 30 minutes. You test basic inference:

ollama run qwen3.5:35b
Enter fullscreen mode Exit fullscreen mode

You type a prompt inside the REPL. Qwen3.5 answers accurately. You exit with /bye.

You immediately check the OpenAI-compatible endpoint because OpenClaw needs it:

curl http://localhost:11434/v1/models
Enter fullscreen mode Exit fullscreen mode

The response lists qwen3.5:35b. You know the bridge works.

Launch OpenClaw With Qwen3.5

You use one Ollama command to install and start everything:

ollama launch openclaw --model qwen3.5:35b
Enter fullscreen mode Exit fullscreen mode

Ollama installs missing components, starts the gateway, and opens the TUI wizard. You connect your messaging channels, confirm the model provider, and save settings. The gateway runs on port 8080.

You test by messaging your bot on Telegram:

“List files in my Downloads folder.”

OpenClaw uses qwen3.5 and returns the result.

You can also configure manually. You edit ~/.openclaw/openclaw.json and set the Ollama provider base URL. You restart with:

openclaw start
Enter fullscreen mode Exit fullscreen mode

Both methods give identical results.

Test the Full Stack With Apidog

You open Apidog and create a new project called “Qwen3.5 OpenClaw Local Stack.” You set the base URL to http://localhost:11434/v1.

Testing integration in Apidog

You add a POST request to /chat/completions. You include these headers:

{
  "Content-Type": "application/json",
  "Authorization": "Bearer ollama"
}
Enter fullscreen mode Exit fullscreen mode

You use this body:

{
  "model": "qwen3.5:35b",
  "messages": [
    {"role": "system", "content": "You are a helpful agent."},
    {"role": "user", "content": "Plan steps to organize my Downloads folder by file type."}
  ],
  "temperature": 0.7,
  "max_tokens": 2048
}
Enter fullscreen mode Exit fullscreen mode

You send the request. Apidog shows streaming tokens in real time. You add a visual assertion for status code 200. You save the request as a test scenario. You run the scenario again after you change settings. You therefore catch problems immediately.

You create a second collection for OpenClaw’s gateway at http://localhost:8080/v1. You test end-to-end message routing. Apidog’s schema validation confirms tool-call formats match what OpenClaw expects.

Design and Document Your Endpoints in Apidog

You use Apidog’s visual designer to model the chat completions schema. You import the official OpenAI spec. You customize it for qwen3.5 parameters. You generate interactive documentation automatically. You share the docs with teammates through Apidog workspaces if you work together.

Image

You also create mock responses inside Apidog. You simulate tool calls before you finish the full OpenClaw setup. You therefore develop faster and test edge cases safely.

Advanced Configuration for Better Performance

You create a custom Modelfile when you need lighter quantization:

FROM qwen3.5:35b
PARAMETER num_gpu 999
PARAMETER num_ctx 131072
Enter fullscreen mode Exit fullscreen mode

You build it with:

ollama create qwen3.5:35b-q4 -f Modelfile
Enter fullscreen mode Exit fullscreen mode

You update your OpenClaw config to use the new tag.

You enable vision by sending base64 images in chat messages. Qwen3.5 processes screenshots that OpenClaw captures during browser tasks. You therefore automate forms that require visual understanding.

You install extra skills:

openclaw skill install @community/calendar
openclaw skill install @community/github
Enter fullscreen mode Exit fullscreen mode

Each skill registers JSON schemas. Qwen3.5 learns to call them automatically. You monitor usage inside the OpenClaw dashboard.

Real-World Workflows You Run Today

  1. Code Reviews:

    You message OpenClaw:

    “Review the PR in my repo and suggest refactors.”

    The agent clones the repository, analyzes code, and creates a patch.

  2. Personal Task Automation:

    You write:

    “Check my inbox for flight confirmations and add them to calendar.”

    OpenClaw parses emails and updates your calendar.

  3. Research Assistants:

    You send a PDF screenshot and ask for a summary plus follow-up questions. Qwen3.5 extracts text accurately. OpenClaw keeps context across days.

  4. Multiple Agents:

    You launch separate OpenClaw workspaces. One uses qwen3.5:35b for general work. Another uses a specialized coder model. The gateway routes messages correctly.

Optimize Speed and Memory Usage

  • Set OLLAMA_NUM_GPU=999 to use all GPU layers. Monitor with nvidia-smi. On Apple Silicon, enable flash attention.
  • Reduce context bloat with periodic summarization prompts that qwen3.5 runs automatically.
  • The 35B model reaches 45–60 tokens per second on a 4090-class GPU. Choose the variant that fits your hardware.
  • Use Apidog’s performance testing to measure latency across 100 requests. Adjust temperature and max_tokens until you reach your target response time.

Solve Common Problems Quickly

  1. “Model not found”:

    Run ollama list and correct the tag in your config.

  2. High latency:

    Check logs with journalctl -u ollama and increase GPU layers. Use Apidog to re-test the same request and confirm improvement.

  3. Tool-call parsing fails:

    Lock temperature at 0.7 inside Apidog test scenarios and re-run.

  4. OpenClaw loses connection:

    Run openclaw configure --section channels to refresh tokens.

  5. Rate limits in Ollama:

    Increase concurrency settings and test again in Apidog.

You use Apidog’s error inspection pane for every issue. The visual stack trace and response comparison speed up fixes dramatically.

Keep Your Setup Secure

  • Run OpenClaw under a dedicated user account.
  • Enable sandboxing for tool execution.
  • Never expose ports 11434 or 8080 publicly. Access them through SSH tunnels or Tailscale when you travel.
  • Review every skill source before installation.
  • Turn on memory encryption in OpenClaw settings.
  • Back up the ~/.openclaw folder regularly.

You therefore operate a system safer than most cloud services because your data never leaves your network.

Plan for Future Updates

  • Alibaba releases smaller Qwen3.5 variants regularly. Ollama adds them quickly. Pull updates with: 
ollama pull qwen3.5:35b --force
Enter fullscreen mode Exit fullscreen mode
  • OpenClaw’s skill library grows every week. Check GitHub notifications to stay current.
  • Repeat the Apidog testing process after each update. Keep your test collection and simply change the model tag. Maintain reliability without extra work.

The same OpenClaw setup is model-agnostic—swapping in DeepSeek produces a capable local AI assistant that runs entirely offline and requires no API subscription.

Conclusion

You now run qwen3.5 with OpenClaw for free using Ollama. You control the entire stack on your hardware. You get strong reasoning, vision support, persistent memory, and proactive automation.

You followed clear steps. You tested every layer with Apidog. You optimized performance and secured the environment. Small configuration choices produced a capable personal AI agent.

Open your terminal now. Run the launch command. Connect your messaging apps. Send your first task. You will see how powerful a fully local agent feels.

Download Apidog to follow along with future updates and keep testing your endpoints efficiently. You already have everything you need to build smarter workflows today.

Apidog API Design specification

Top comments (1)

Collapse
 
suppdevbot profile image
DEV SUPPORTS • 
You need to verify your account.
Enter fullscreen mode Exit fullscreen mode

tr.ee/dev-to