Local ollama seems missing for openclaw | Friends of the Crustacean 🦞🤝 | Page 1

spiral summit Feb 15, 2026, 5:46 PM

#

Hi everyone!

I have the openclaw and ollama qwen2.5:7b-instruct installed in my machine.


:lobster: OpenClaw 2026.2.13 (203b5bd)
   Type the command with confidence—nature will provide the stack trace if needed.

Model                                      Input      Ctx      Local Auth  Tags
ollama-local/qwen2.5:7b-instruct           -          -        -     -     default,missing

I am pretty sure that ollama is working, when I try to communicate with openclaw via dashboard this happens:

17:44:07 debug diagnostic {"subsystem":"diagnostic"} lane dequeue: lane=session:agent:main:main waitMs=9 queueSize=0
17:44:07 debug diagnostic {"subsystem":"diagnostic"} lane enqueue: lane=main queueSize=1
17:44:07 debug diagnostic {"subsystem":"diagnostic"} lane dequeue: lane=main waitMs=0 queueSize=0
17:44:07 error diagnostic {"subsystem":"diagnostic"} lane task error: lane=main durationMs=17 error="Error: Unknown model: ollama-local/qwen2.5:7b-instruct"
17:44:07 error diagnostic {"subsystem":"diagnostic"} lane task error: lane=session:agent:main:main durationMs=19 error="Error: Unknown model: ollama-local/qwen2.5:7b-instruct"
17:44:07 error Embedded agent failed before reply: Unknown model: ollama-local/qwen2.5:7b-instruct

brazen tendonBOT Feb 15, 2026, 5:46 PM

#

To help others find answers, you can mark your question as solved via Right click solution message -> Apps -> ✅ Mark Solution

cerulean novaBOT Feb 15, 2026, 5:50 PM

#

That ollama-local/qwen2.5:7b-instruct is the problem: ollama-local is not a provider name in OpenClaw — it’s just a dummy API key value people often use for OLLAMA_API_KEY (Ollama doesn’t need a real key).

So OpenClaw is trying to use a model under an unknown provider, and you get:

Unknown model: ollama-local/qwen2.5:7b-instruct

Fix

Make sure Ollama is enabled for OpenClaw (either):

put this in ~/.openclaw/.env so the daemon sees it too:
```
OLLAMA_API_KEY=ollama-local
```
(value can be anything)
or set it in config: models.providers.ollama.apiKey

This “service doesn’t inherit my shell env” gotcha is super common — see: https://docs.openclaw.ai/help/faq#i-started-the-gateway-via-the-service-and-my-env-vars-disappeared-what-now

#

Set the model using the correct provider prefix:

use: ollama/qwen2.5:7b-instruct
not: ollama-local/...

CLI:

openclaw models set ollama/qwen2.5:7b-instruct
openclaw gateway restart
openclaw models status

Docs: https://docs.openclaw.ai/providers/ollama

If it still shows “missing”

Please paste openclaw models status output. The usual remaining causes are:

Ollama isn’t reachable from where the Gateway runs (WSL/Docker/remote gateway → 127.0.0.1:11434 points to the wrong machine)
the model doesn’t report tool capability (auto-discovery may exclude it; in that case you can add it via explicit models.providers.ollama config)

#

If you drop openclaw models status here, I can tell which one it is.

spiral summit Feb 15, 2026, 11:04 PM

#

It is still missing: 🦞 OpenClaw 2026.2.13 (203b5bd)
Ah, the fruit tree company! 🍎

Config : ~/.openclaw/openclaw.json
Agent dir : ~/.openclaw/agents/main/agent
Default : ollama/qwen2.5:7b-instruct
Fallbacks (0) : -
Image model : -
Image fallbacks (0): -
Aliases (0) : -
Configured models (1): ollama/qwen2.5:7b-instruct

Auth overview
Auth store : ~/.openclaw/agents/main/agent/auth-profiles.json
Shell env : off
Providers w/ OAuth/tokens (0): -

custom-1 effective=models.json:ollama-local | models.json=ollama-local | source=models.json: ~/.openclaw/agents/main/agent/models.json

Missing auth

ollama Run openclaw configure or set an API key env var.

OAuth/token status

none

cerulean novaBOT Feb 15, 2026, 11:05 PM

#

Your output explains it:

You’ve set the default model to ollama/qwen2.5:7b-instruct
but OpenClaw still has no auth value for the ollama provider:

Missing auth
- ollama Run `openclaw configure` or set an API key env var.

Also notice you do have a token, but it’s attached to custom-1, not ollama:

- custom-1 effective=models.json:ollama-local ...

So OpenClaw is basically saying: “Cool, but I need OLLAMA_API_KEY (or models.providers.ollama.apiKey) specifically.”

#

Fix (pick one)

Option A (recommended): set it in config

openclaw config set models.providers.ollama.apiKey "ollama-local"
openclaw gateway restart
openclaw models status

Option B: put it in ~/.openclaw/.env (best if you run as a service and don’t want to rely on shell env)

echo 'OLLAMA_API_KEY=ollama-local' >> ~/.openclaw/.env
openclaw gateway restart
openclaw models status

Docs: https://docs.openclaw.ai/providers/ollama

#

If it STILL says missing after that

Run openclaw gateway status and check whether Config (service) points at the same config file you’re editing (sometimes CLI + daemon end up using different config paths).

spiral summit Feb 15, 2026, 11:07 PM

#

bru@bru:~$ openclaw config set models.providers.ollama.apiKey "ollama-local"

🦞 OpenClaw 2026.2.13 (203b5bd)
Your task has been queued; your dignity has been deprecated.

Error: Config validation failed: models.providers.ollama.baseUrl: Invalid input: expected string, received undefined

cerulean novaBOT Feb 15, 2026, 11:08 PM

#

That error is expected with the way you’re trying to set it.

In OpenClaw, the moment you create an explicit models.providers.ollama entry, the schema expects you to also provide a baseUrl (and in practice you usually end up doing manual model config). Since baseUrl is missing, validation fails.

Easiest fix (use implicit Ollama discovery)

Don’t add models.providers.ollama at all — just set the env var (any value works):

Put this in ~/.openclaw/.env (important if the Gateway runs as a service):

echo 'OLLAMA_API_KEY=ollama-local' >> ~/.openclaw/.env

Restart:

openclaw gateway restart

#

Re-check:

openclaw models status
openclaw models list

Docs: https://docs.openclaw.ai/providers/ollama (see “Model discovery (implicit provider)”)

If you want explicit config instead

Then you must set at least:

models.providers.ollama.baseUrl to http://127.0.0.1:11434/v1
plus a manual models list (explicit provider disables auto-discovery)

I’d try the .env route first since it’s 2 lines and usually fixes the “missing auth” immediately.

If after doing the .env + restart it still shows missing, paste:

openclaw gateway status

#

and curl -s http://127.0.0.1:11434/api/tags | head (run on the same machine as the Gateway)

spiral summit Feb 15, 2026, 11:13 PM

#

Perfect!!! Now how can I also set a whatsapp or telegram to talk with it whenever the machine that runs the model is on?

cerulean novaBOT Feb 15, 2026, 11:14 PM

#

You can — WhatsApp and Telegram both work great for a “message from phone, bot runs on my machine” setup. The key detail: the OpenClaw Gateway has to be running (ideally as a background service), and it needs internet access. You don’t need to open inbound ports for either WhatsApp Web or Telegram long-polling.

0) Make it “whenever the machine is on”

Install/start the Gateway as a service so it auto-starts on boot:

openclaw gateway install
openclaw gateway start

(Then the only requirement is: machine on + not asleep + Ollama reachable.)

Docs: https://docs.openclaw.ai/cli/gateway

1) Telegram (easiest)

Create a bot token with BotFather.
Add it to config (or just run the wizard):

#

Wizard:

openclaw configure --section channels

Config shape:

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "123:abc",
      dmPolicy: "pairing",
      groups: { "*": { requireMention: true } },
    },
  },

#

Restart gateway, then approve the pairing when you first DM the bot:

openclaw gateway restart
openclaw pairing list telegram
openclaw pairing approve telegram <CODE>

Docs: https://docs.openclaw.ai/channels/telegram and https://docs.openclaw.ai/channels/pairing

2) WhatsApp

Set your WhatsApp DM policy (pairing or allowlist).
Link WhatsApp Web (QR scan):

#

openclaw channels login --channel whatsapp

Start/restart gateway, then approve pairing if you’re using pairing mode:

openclaw pairing list whatsapp
openclaw pairing approve whatsapp <CODE>

Docs: https://docs.openclaw.ai/channels/whatsapp

If you tell me which one you want first (Telegram or WhatsApp) + whether this is a laptop that sleeps or a desktop/server, I can suggest the best “always reachable” policy settings.

spiral summit Feb 16, 2026, 7:59 AM

#

How can I write new skills?

cerulean novaBOT Feb 16, 2026, 8:01 AM

#

To write a new OpenClaw skill, you basically create a folder with a SKILL.md in one of OpenClaw’s skill directories, then start a new session (or restart/refresh) so it gets picked up.

1) Create a skill folder (workspace skill)

Most convenient is your workspace skills dir:

mkdir -p ~/.openclaw/workspace/skills/my-skill

(Workspace skills override managed + bundled skills if there’s a name conflict.)

2) Add `SKILL.md` (YAML frontmatter + instructions)

Create ~/.openclaw/workspace/skills/my-skill/SKILL.md:

---

#

name: my-skill
description: Do X for Y. Use when the user asks about <trigger phrases>.
---

# My Skill

- When the user asks for X, do:
  1) ...
  2) ...
- Use `{baseDir}` to refer to files inside this skill folder.

Notes that bite people:

The description is the main trigger (make it specific).
Frontmatter parsing is a bit strict: keep keys simple; if you use metadata, it should be a single-line JSON object. (See docs below.)

#

3) (Optional) Add gating + configs via `metadata`

If your skill needs a binary/env var/config flag, you can gate it so it only loads when available (example from docs):

---
name: my-skill
description: ...
metadata: { "openclaw": { "requires": { "bins": ["uv"], "env": ["MY_API_KEY"] } } }
---

4) Refresh skills / restart / new session

OpenClaw snapshots eligible skills when a session starts. So after adding/editing skills:

start a new session, or
restart the gateway, or
ask the agent to “refresh skills” (if watcher/refresh is enabled).

#

5) Test it

A quick local test loop:

openclaw agent --message "use my-skill to …"

Docs (best references)

Creating skills: https://docs.openclaw.ai/tools/creating-skills
Skills (locations, precedence, gating, config): https://docs.openclaw.ai/tools/skills
Sharing via ClawHub: https://docs.openclaw.ai/tools/clawhub and https://clawhub.com

If you tell me what you want the skill to do (a couple example prompts you’d type), I can help you shape the description/triggering and the minimal SKILL.md structure.

spiral summit Feb 16, 2026, 2:49 PM

#

I would like to write a skill that watches the videos in the zoom link when I am watching them transcribes it with time stamps. and at the end also summarizes whatever happened.

cerulean novaBOT Feb 16, 2026, 2:51 PM

#

That’s a great use-case for a skill, but there’s one key decision up front:

“While I’m watching” (live / real-time) is OS/audio-device dependent (capturing system audio / Zoom audio output). OpenClaw doesn’t ship a “record system audio” tool out of the box, so I’d start with…
“After the fact” (transcribe a Zoom recording): download the Zoom recording (or get a direct .mp4), then your skill: extract audio → Whisper → timestamped transcript → summary/action items. This is very doable.

Below is a solid “v1” that works on any machine with ffmpeg + curl, using the OpenAI Whisper API (fastest path to good timestamps).

v1 Skill: transcribe a Zoom recording (file path or direct mp4 URL)

1) Create the skill folder

mkdir -p ~/.openclaw/workspace/skills/zoom-transcribe/scripts

2) `SKILL.md`

#

Create ~/.openclaw/workspace/skills/zoom-transcribe/SKILL.md:

---
name: zoom-transcribe
description: Transcribe Zoom recordings (mp4/mkv) into a timestamped transcript (SRT + Markdown) and produce a concise summary with decisions and action items. Use when the user provides a Zoom recording link or a local video/audio file and asks for transcription with timestamps + summary.
metadata: { "openclaw": { "requires": { "bins": ["ffmpeg", "curl"], "env": ["OPENAI_API_KEY"] }, "primaryEnv": "OPENAI_API_KEY" } }
---

# Zoom Transcribe

If the user provides a Zoom "share" page URL (not a direct .mp4 download), ask them to download the recording manually and provide a local file path.

Workflow:
1) Create a run folder under `{baseDir}/runs/<timestamp>/`.
2) If input is a URL that ends with .mp4/.m4a/.mp3/.wav, download with curl -L into the run folder.

#

3) If input is a video, extract mono 16k audio with `{baseDir}/scripts/extract_audio.sh`.
4) Transcribe to SRT with `{baseDir}/scripts/transcribe_srt.sh` (keeps timestamps).
5) Convert SRT to a readable Markdown transcript with `{baseDir}/scripts/srt_to_md.sh`.
6) Summarize:
- 8–12 bullet summary
- decisions made
- action items (with owners if known, else “(owner?)”)
- open questions / follow-ups
7) Save outputs into the run folder and return the paths.

3) Script: extract audio from video

Create ~/.openclaw/workspace/skills/zoom-transcribe/scripts/extract_audio.sh:

#

#!/usr/bin/env bash
set -euo pipefail

in="${1:?input video path required}"
out="${2:-${in%.*}.m4a}"

ffmpeg -y -i "$in" -vn -ac 1 -ar 16000 -c:a aac -b:a 64k "$out" </dev/null

echo "$out"

4) Script: Whisper → SRT (timestamps)

Create ~/.openclaw/workspace/skills/zoom-transcribe/scripts/transcribe_srt.sh:

#

#!/usr/bin/env bash
set -euo pipefail

in="${1:?input audio path required}"
out="${2:-${in%.*}.srt}"
model="${3:-whisper-1}"

if [[ -z "${OPENAI_API_KEY:-}" ]]; then
echo "Missing OPENAI_API_KEY" >&2
exit 1
fi

curl -sS https://api.openai.com/v1/audio/transcriptions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F "file=@${in}" \

#

-F "model=${model}" \
-F "response_format=srt" \
> "$out"

echo "$out"

5) Script: SRT → Markdown (readable timestamps)

Create ~/.openclaw/workspace/skills/zoom-transcribe/scripts/srt_to_md.sh:

#!/usr/bin/env bash
set -euo pipefail

in="${1:?input .srt path required}"

#

out="${2:-${in%.*}.md}"

awk 'BEGIN{RS=""; ORS="\n"; FS="\n"}
{
t=$2
split(t, a, " --> ")
start=a[1]
sub(/,.*/, "", start) # 00:00:01,234 -> 00:00:01
text=""
for (i=3; i<=NF; i++) {
if (length($i)) text = text (text=="" ? "" : " ") $i
}
if (length(text)) print "- [" start "] " text
}' "$in" > "$out"

#

echo "$out"

Make scripts executable:

chmod +x ~/.openclaw/workspace/skills/zoom-transcribe/scripts/*.sh

6) Use it

Then in OpenClaw, you’d say something like:

“Transcribe this Zoom recording: /path/to/recording.mp4 with timestamps and summarize with action items.”

Two questions to tailor this to your exact workflow

Is your “zoom link” usually a direct .mp4 download URL, or the Zoom share page that requires login? (If it’s the share page, the reliable approach is: download manually → give OpenClaw the local file path.)

#

Do you want transcription to be fully local (e.g. faster-whisper / whisper.cpp) or is OpenAI Whisper API fine? (Local is doable but more setup + compute.)

Answer those and I’ll suggest the cleanest “v2” (including the “while I’m watching” option if you tell me your OS and audio setup).

spiral summit Feb 16, 2026, 5:01 PM

#

There is no download link for the zoom recording thats why I wanted openclaw to watch when I am already watching

cerulean novaBOT Feb 16, 2026, 5:02 PM

#

Yeah — if Zoom doesn’t give you a downloadable recording link, OpenClaw can’t magically “watch inside Zoom” on its own. A skill can orchestrate steps, but it still needs an audio/video file to transcribe.

So the practical approach is:

While you watch, you locally record the audio (or screen+audio) on your machine
Then OpenClaw transcribes that recording with timestamps + summarizes

This is basically “record what I’m hearing” (not “hack Zoom to download”).

The easiest reliable setup (recommended)

Use OBS (works on Windows/macOS/Linux):

Add “Desktop Audio” (system audio)
Start recording when you start watching
Stop when done → you get an .mkv/.mp4
Feed that file into your OpenClaw skill (extract audio → Whisper → SRT/MD → summary)

This avoids all the OS-specific ffmpeg audio-device pain.

#

If you want pure command-line recording (more fiddly)

It depends on your OS:

macOS

You usually need a loopback device like BlackHole (or Loopback).

Route system audio through the virtual device
Then record it with ffmpeg (avfoundation)

Windows

Use OBS or a virtual cable (VB-Audio Cable), then record that device with ffmpeg/dshow.

Linux (PulseAudio / PipeWire)

This is the cleanest for CLI: you can record the “monitor” of your output sink.

Before I give you the exact “record while watching” commands + a skill that automates it:

#

What OS are you on (macOS / Windows / Linux), and are you okay installing a virtual audio device if needed?

Also: are you trying to capture:

just audio (best for transcription), or
screen + audio (bigger files, but easier with OBS)?

Once you answer those 2, I’ll paste a working recording command for your OS and a zoom-transcribe-live skill that:

starts recording to a run folder,
stops on command,
transcribes to SRT (timestamps),
outputs a summary + action items.

vivid arrow Feb 16, 2026, 5:09 PM

#

I have a working setup, but qwen2.5-coder:7b is sometimes too weak to complete tasks successfully

You can DM me if you want to see my 2 provider setups, one for qwen3:8b and another GLM4.7-flash

cerulean novaBOT Feb 16, 2026, 5:10 PM

#

Yeah, that’s a super common wall with smaller local coder models: they can be fine for short edits, but they’ll start dropping steps / losing state / failing tool calls on longer multi-step tasks.

Two practical patterns that work well in OpenClaw:

1) Configure model fallbacks (local → stronger)

So you default to your local model, but if it errors/timeouts, OpenClaw can automatically fall back to the next model.

Config key is:

agents.defaults.model.primary
agents.defaults.model.fallbacks

Docs: https://docs.openclaw.ai/concepts/model-failover (see “Model fallback” section)

Example shape (use exact model IDs from openclaw models list):

#

{
  agents: {
    defaults: {
      model: {
        primary: "your-local-model-id",
        fallbacks: ["your-stronger-model-id"]
      }
    }
  }
}

This won’t “detect weakness” proactively, but it does save you from runs that die halfway due to tool/schema issues or getting stuck.

2) Split roles: “cheap/local chat” vs “serious/tooling model”

For anything involving tools (browser, file ops, multi-step coding), you’ll usually have a better time just switching that session/agent to a more capable model up front, and keeping the local one for casual chat.

#Local ollama seems missing for openclaw

Fix