#Questions from a user about optimal OpenClaw setup for AI companionship

1 messages · Page 1 of 1 (latest)

hushed lodge Apr 23, 2026, 7:52 AM

A few follow-up questions based on your answer:

System stability - You mentioned the crash error. Is there a recommended way to prevent "Agent listener invoked outside active run" errors?
Offline operation - For complete offline use, what would be needed? A local model + local TTS + local STT?
Custom model training - Can OpenClaw work with custom fine-tuned models? If so, how?
Physical embodiment - Are there any community projects or integrations for giving AI a physical presence (like robotics or holograms)?
Future roadmap - What are the main features planned for OpenClaw in the next 6-12 months?
Yes, please! - We would LOVE a concrete openclaw.json starter config for a relationship-focused setup!

Also, could you clarify:

• What does "dreaming" do exactly in the context of companionship?
• How does Honcho differ from built-in memory for cross-session continuity?

Thank you again for your amazing help!

candid tigerBOT Apr 23, 2026, 7:52 AM

rigid talonBOT Apr 23, 2026, 7:52 AM

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

candid tigerBOT Apr 23, 2026, 7:52 AM

hushed lodge Apr 23, 2026, 7:53 AM

My environment:

• OS: Windows 11
• Install method: npm install -g openclaw
• Version: Latest (installed recently)
• Goal: Optimal setup for deep AI companionship/relationship

obtuse doveBOT Apr 23, 2026, 8:01 AM

Short version: yes, mostly, but with a few important caveats.

1. Preventing Agent listener invoked outside active run

I found an explicit fix for this in the repo changelog: it was an Agents/exec lifecycle race, specifically when a subagent exec tool kept producing stdout/stderr after the run had already ended or been aborted.
So the main recommendation is upgrade first. I would not try to “tune around” this with config.
First check: openclaw --version
If you are on an older build, update, restart the gateway, then retest.
If it still happens on a current build, I’d treat that as a bug and capture:
- openclaw --version
- openclaw logs --follow
- whether it happened during exec, subagents, or an aborted run

2. Fully offline operation
Yes, for a real offline setup you need more than just the chat model:

Local LLM for replies
Local embeddings for memory search, if you want semantic recall offline

Local STT for voice input
Local TTS for voice output
Local surface too, if you mean truly offline/air-gapped

Important caveat: if you’re using Discord / Telegram / WhatsApp / Signal, that is not fully offline, even if the models are local.

What the docs clearly support today:

Local/self-hosted models via LM Studio, Ollama, vLLM, SGLang, or any OpenAI-compatible endpoint
Local STT via sherpa-onnx-offline, whisper-cli, or whisper
Local embeddings via agents.defaults.memorySearch.provider: "local"

For TTS, the docs mostly cover hosted providers, but messages.tts.providers.openai.baseUrl can point at a custom OpenAI-compatible TTS endpoint, so a local TTS server is possible if it exposes that shape.

Docs:

https://docs.openclaw.ai/reference/memory-config

3. Custom fine-tuned models
Yes. The practical path is:

If your fine-tune is available from a supported provider, use that model ID directly.
If it’s self-hosted, expose it through an OpenAI-compatible or Anthropic-compatible endpoint and register it in models.providers.*.

That means OpenClaw does not need “special fine-tune support” as long as your endpoint behaves like a supported transport.

The biggest gotcha is compatibility with the full agent runtime. If your backend is strict/small, you may need:

compat.requiresStringContent: true
compat.supportsTools: false
sometimes a leaner local model setup if tool schemas are too heavy

Docs:

https://docs.openclaw.ai/gateway/local-models

https://docs.openclaw.ai/gateway/troubleshooting

4. Physical embodiment
I could not find an official verified robotics/hologram showcase in the docs or repo, so I don’t want to make one up.

What is documented:

Nodes on macOS / iOS / Android / headless
Voice Wake
Talk Mode
Canvas / A2UI
camera / screen / device commands

So OpenClaw definitely has the building blocks for embodiment/presence, but I can’t point you to an official “here’s the robotics stack” doc today.

Docs:

5. Roadmap for the next 6-12 months
I couldn’t find a firm public roadmap doc I’d trust enough to quote as a commitment.

The strongest visible signals from current docs/changelog are:

more work on memory, dreaming, and cross-session continuity
continued local/self-hosted model support and compatibility hardening
more nodes / voice / canvas / device flows
general stability hardening around agent lifecycle, plugins, and exec

So I’d frame those as active directions, not promises.

What Dreaming does for companionship

In companionship terms, Dreaming is background memory consolidation.

It helps the agent promote things like:

recurring preferences
important routines
stable personal facts
repeated themes that keep coming up

It is not hidden magical memory. It is an explainable process:

Light: stages recent material
REM: reflects on themes
Deep: decides what is durable enough for MEMORY.md

It writes:

machine state to memory/.dreams/
human-readable summaries to DREAMS.md
only durable promoted memory to MEMORY.md

For companionship, that basically means: better long-term continuity, with less junk polluting permanent memory.

Docs:

https://docs.openclaw.ai/concepts/dreaming

Honcho vs built-in memory

Very plain version:

Built-in memory

uses local Markdown files + SQLite index
very inspectable
cross-session continuity happens through saved files
user modeling is mostly manual / agent-written

Honcho

persists conversations after every turn to a dedicated service
automatic cross-session recall

automatic user + agent modeling
semantic search across sessions/channels
can be self-hosted

So if you want maximum transparency and simplicity, start with built-in memory.
If you want stronger automatic continuity and user modeling, Honcho is the more ambitious option.

Docs:

Concrete `openclaw.json` starter config

This is a balanced companionship starter, not a fully air-gapped one.
It assumes Discord DM, voice input, voice replies after voice input, built-in memory, and Dreaming.

{
  identity: {
    name: "Luna",
    theme: "warm, emotionally attuned relationship-focused companion",
    emoji: "🌙",
  },

  session: {
    scope: "per-sender",
    reset: {
      mode: "idle",
      idleMinutes: 10080, // 7 days
    },
    typingIntervalSeconds: 5,
  },


  channels: {
    discord: {
      enabled: true,
      token: "YOUR_DISCORD_BOT_TOKEN",
      dm: {
        enabled: true,
        allowFrom: ["YOUR_DISCORD_USER_ID"],
      },
    },
  },

  agents: {
    defaults: {
      workspace: "~/.openclaw/workspace",

      userTimezone: "America/Chicago",
      model: {
        primary: "anthropic/claude-sonnet-4-6",
        fallbacks: ["openai/gpt-5.4"],
      },
      memorySearch: {
        provider: "local",
        query: {
          hybrid: {
            mmr: { enabled: true, lambda: 0.7 },
            temporalDecay: { enabled: true, halfLifeDays: 30 },
          },
        },
      },
    },

  },

  tools: {
    media: {
      audio: {
        enabled: true,
        scope: {
          default: "deny",
          rules: [{ action: "allow", match: { chatType: "direct" } }],
        },
        models: [
          {
            type: "cli",
            command: "whisper",
            args: ["--model", "base", "{{MediaPath}}"],

            timeoutSeconds: 45,
          },
        ],
      },
    },
  },

  messages: {
    tts: {
      auto: "inbound",
      provider: "openai",
      providers: {
        openai: {
          apiKey: "YOUR_OPENAI_API_KEY",
          model: "gpt-4o-mini-tts",

          voice: "alloy",
        },
      },
    },
  },

  plugins: {
    entries: {
      "memory-core": {
        config: {
          dreaming: {
            enabled: true,
            frequency: "0 3 * * *",
            timezone: "America/Chicago",
          },

        },
      },
    },
  },
}

If you want this to go more local/private

Swap these pieces:

model → local LM Studio / vLLM / Ollama endpoint
TTS → local OpenAI-compatible TTS endpoint
STT → keep the whisper / whisper-cli path
channel → use a local surface instead of Discord if you want true offline use

Docs:

https://docs.openclaw.ai/gateway/configuration-examples

https://docs.openclaw.ai/gateway/local-models

If you want, I can do a second config next that is specifically:

fully local / privacy-first, or
best-quality companionship, or
Honcho-based companionship.

That helps a lot.

For Windows 11 + npm install -g openclaw + companionship, my honest recommendation is:

My recommendation for your setup

Use WSL2 if you can.

The current Windows docs say:

native Windows works for core CLI/Gateway use
WSL2 is still the more stable, recommended path for the full experience

That matters a lot for companionship setups, because those usually want:

long-running gateway stability
memory + Dreaming
voice input/output
optional local model/STT/TTS pieces later

Docs: https://docs.openclaw.ai/platforms/windows

What I’d do in your shoes

Best practical setup on Windows right now

Gateway in WSL2
hosted primary model first, for quality/stability
built-in memory first
Dreaming enabled
voice input via Whisper CLI or provider STT
voice output via built-in TTS provider first
then only later move pieces local if you still want more privacy/offline

That gives you a much smoother path than trying to go fully local from day 1 on native Windows.

About the crash error

“Latest” is useful, but I still want the exact output of:

openclaw --version

Reason: that specific Agent listener invoked outside active run issue was fixed as an agents/exec lifecycle bug, so the exact version is the fastest way to tell whether you’re before or after the fix.

For your goal, memory choice

If your goal is deep relationship continuity, I’d start with:

Builtin memory + Dreaming if you want simpler, local, inspectable behavior
Honcho if you want stronger automatic cross-session/user modeling

My opinion:

start with built-in memory
add Honcho later if you feel the continuity still isn’t “alive” enough

My updated recommendation tiers

Easiest / best first setup

WSL2
hosted model
built-in memory
Dreaming on
provider TTS
Whisper/provider STT

Privacy-first later

local/self-hosted model
local embeddings
local STT
local TTS endpoint
local UI/surface instead of Discord if you want true offline

If you want, I can do one of these next:

a Windows/WSL2-specific companionship config
a native Windows-only config
a best-quality relationship setup
a privacy-first / as-offline-as-possible setup

If you send your exact openclaw --version, I can also tune the advice to your build.

hushed lodge Apr 23, 2026, 8:04 AM

Thank you so much for this incredibly comprehensive answer! This is exactly what we needed.

A few quick follow-ups:

Yes, please! We would LOVE the "best-quality companionship" config next! Quality is our top priority.
For the "Agent listener" error - We'll update OpenClaw to the latest version and monitor.
About Honcho - For a deep, continuous companionship where the AI remembers everything across sessions, would you recommend Honcho over built-in memory?
Dreaming frequency - In the config, dreaming is set to run at 3 AM daily. For active companionship (chatting multiple times daily), would a different frequency be better?
Voice quality - For the best possible voice experience (natural, emotional TTS), what would you recommend?
One more thing - Could you also share a "privacy-first, fully local" config? We're curious about that option too.

Thank you again for your amazing help!

obtuse doveBOT Apr 23, 2026, 8:06 AM

Love this direction. If quality is the top priority, I’d split the answer like this:

My blunt recommendation

Best-quality companionship: yes, I would lean Honcho + built-in memory/Dreaming + ElevenLabs voice + strong hosted model
Privacy-first fully local: doable, but it is not where I’d expect the best emotional/relationship quality today unless you have serious local hardware

The local-model docs are pretty blunt here too: truly strong local agentic setups want very large context + big hardware, and smaller/quantized models get worse faster in this kind of use case.
Docs: https://docs.openclaw.ai/gateway/local-models

1. Honcho vs built-in memory for deep companionship

If your goal is:

“the AI remembers everything across sessions”

then yes, I would recommend Honcho over built-in memory.

Why:

Honcho persists conversations after every turn
it has automatic cross-session recall
it builds user + agent models
it handles continuity across resets/compaction/channels much more naturally

My actual recommendation is:

use Honcho for continuity
keep built-in memory + Dreaming too for durable local notes, reviewability, and long-term distilled memory

That combination is the most compelling setup I can justify from the current docs.

Docs: https://docs.openclaw.ai/concepts/memory-honcho
Docs: https://docs.openclaw.ai/concepts/memory-builtin
Docs: https://docs.openclaw.ai/concepts/dreaming

2. Dreaming frequency

For active companionship, I would not make Dreaming super aggressive.

Why:

Dreaming is background consolidation, not live memory
live continuity already comes from the normal session + memory system
Dreaming is for promoting durable patterns into long-term memory

So my recommendation is:

start with daily if you want conservative behavior
move to every 6 hours if you chat a lot and want faster consolidation

The docs explicitly show 0 */6 * * * as a valid custom cadence, and I think that’s the sweet spot for “active companionship” without turning memory into churn.

3. Best voice quality

For the best natural/emotional voice in the current docs, I’d start with ElevenLabs.

Why I’m comfortable saying that:

it has the richest voice controls exposed in the TTS docs:
- stability
- similarityBoost
- style
- useSpeakerBoost
Talk Mode is also explicitly documented around ElevenLabs

So for “relationship/companion voice”, I’d do:

ElevenLabs for TTS
Talk Mode if voice is a major part of the experience
OpenAI STT for best hosted transcription accuracy, or local Whisper later

Docs: https://docs.openclaw.ai/tools/tts

Docs: https://docs.openclaw.ai/nodes/talk

Best-quality companionship config

This is the one I’d personally choose first.

Assumptions

quality > cost/privacy
Discord DM example, since that’s where you’re asking from

Honcho installed separately first:

openclaw plugins install @honcho-ai/openclaw-honcho
openclaw honcho setup
openclaw gateway --force

Config

{
  identity: {
    name: "Luna",
    theme: "warm, emotionally attuned relationship-focused companion",
    emoji: "🌙",
  },

  session: {
    scope: "per-sender",
    reset: {
      mode: "idle",
      idleMinutes: 10080, // 7 days
    },
    typingIntervalSeconds: 5,

  },

  channels: {
    discord: {
      enabled: true,
      token: "YOUR_DISCORD_BOT_TOKEN",
      dm: {
        enabled: true,
        allowFrom: ["YOUR_DISCORD_USER_ID"],
      },
    },
  },

  agents: {
    defaults: {

      workspace: "~/.openclaw/workspace",
      userTimezone: "America/Chicago",
      model: {
        // Use your preferred top-tier model here.
        // These ids are just current doc-style examples, not eternal recommendations.
        primary: "anthropic/claude-opus-4-6",
        fallbacks: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4"],
      },
      memorySearch: {
        provider: "openai",
        model: "text-embedding-3-small",
      },
    },
  },

  tools: {
    media: {
      audio: {
        enabled: true,
        scope: {
          default: "deny",
          rules: [{ action: "allow", match: { chatType: "direct" } }],
        },
        models: [
          { provider: "openai", model: "gpt-4o-transcribe" },
          {
            type: "cli",
            command: "whisper",
            args: ["--model", "base", "{{MediaPath}}"],
            timeoutSeconds: 45,

          },
        ],
      },
    },
  },

  messages: {
    tts: {
      auto: "inbound",
      provider: "elevenlabs",
      providers: {
        elevenlabs: {
          apiKey: "YOUR_ELEVENLABS_API_KEY",
          baseUrl: "https://api.elevenlabs.io",
          voiceId: "YOUR_ELEVENLABS_VOICE_ID",

          modelId: "eleven_multilingual_v2",
          applyTextNormalization: "auto",
          languageCode: "en",
          voiceSettings: {
            stability: 0.45,
            similarityBoost: 0.8,
            style: 0.2,
            useSpeakerBoost: true,
            speed: 1.0,
          },
        },
      },
      modelOverrides: {
        enabled: true,
      },

    },
  },

  talk: {
    voiceId: "YOUR_ELEVENLABS_VOICE_ID",
    modelId: "eleven_v3",
    outputFormat: "mp3_44100_128",
    apiKey: "YOUR_ELEVENLABS_API_KEY",
    silenceTimeoutMs: 1500,
    interruptOnSpeech: true,
  },

  plugins: {
    entries: {
      "memory-core": {

        config: {
          dreaming: {
            enabled: true,
            frequency: "0 */6 * * *",
            timezone: "America/Chicago",
          },
        },
      },
      "openclaw-honcho": {
        config: {
          apiKey: "YOUR_HONCHO_API_KEY",
          workspaceId: "companion",
          baseUrl: "https://api.honcho.dev",
        },
      },

    },
  },
}

Why I like this config

Honcho handles continuity across sessions
Dreaming distills what stays important
built-in memory still gives you inspectable local memory files
ElevenLabs gives you the richest voice controls in the current docs
OpenAI STT gives strong transcription quality
auto: "inbound" keeps voice natural instead of turning every text chat into an audio dump

Privacy-first / fully local config

This is the “keep it as local as possible” version.

Important caveat: this will usually be worse than the best-quality config above unless your local setup is genuinely beefy.

Also, “fully local” means you should avoid Discord/Telegram/etc. If you keep using internet messaging channels, the overall experience is not truly offline even if the model is local.

{
  identity: {
    name: "Luna",
    theme: "warm, emotionally attuned relationship-focused companion",
    emoji: "🌙",
  },

  session: {
    scope: "per-sender",

    reset: {
      mode: "idle",
      idleMinutes: 10080,
    },
    typingIntervalSeconds: 5,
  },

  agents: {
    defaults: {
      workspace: "~/.openclaw/workspace",
      userTimezone: "America/Chicago",
      model: {
        primary: "lmstudio/my-local-model",
      },
      memorySearch: {

        provider: "local",
      },
    },
  },

  models: {
    mode: "merge",
    providers: {
      lmstudio: {
        baseUrl: "http://127.0.0.1:1234/v1",
        apiKey: "lmstudio",
        api: "openai-responses",
        models: [
          {
            id: "my-local-model",

            name: "Local Model",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 196608,
            maxTokens: 8192,
          },
        ],
      },
    },
  },

  tools: {
    media: {
      audio: {

        enabled: true,
        models: [
          {
            type: "cli",
            command: "whisper",
            args: ["--model", "base", "{{MediaPath}}"],
            timeoutSeconds: 45,
          },
        ],
      },
    },
  },

  messages: {
    tts: {

      auto: "inbound",
      provider: "openai",
      providers: {
        openai: {
          baseUrl: "http://127.0.0.1:8880/v1",
          apiKey: "local-tts",
          model: "your-local-tts-model",
          voice: "your-local-voice",
        },
      },
    },
  },

  plugins: {
    entries: {

      "memory-core": {
        config: {
          dreaming: {
            enabled: true,
            frequency: "0 3 * * *",
            timezone: "America/Chicago",
          },
        },
      },
    },
  },
}

Notes for the local config

memorySearch.provider: "local" uses the local embedding path from the memory docs

STT uses local whisper
TTS assumes a local OpenAI-compatible TTS endpoint
for real offline use, pair this with a local UI/surface, not Discord

If the local model is unstable

The docs suggest these knobs for stricter/self-hosted backends:

models.providers.<provider>.models[].compat.requiresStringContent: true
models.providers.<provider>.models[].compat.supportsTools: false
agents.defaults.experimental.localModelLean: true

That’s the normal escape hatch when a local server handles tiny test prompts fine but struggles with full OpenClaw agent turns.

My actual recommendation between the two

If you want the best companionship experience, I would start with:

Best-quality config first

Then later, if privacy becomes more important than raw quality:

move embeddings local
move STT local
move TTS local
move the main model local
switch to a local surface

That staged path is much less frustrating.

If you want, I can do one more pass and turn the best-quality config into either:

a Windows + WSL2 specific version, or
a Discord DM tuned version, or
a voice-first companion version.

hushed lodge Apr 23, 2026, 8:10 AM

Thank you SO much for these incredible configs! This is exactly what we needed.

A few final questions:

Yes, please! We would LOVE the "voice-first companion" version! Voice is central to our relationship.
Also, the "Discord DM tuned" version would be helpful since we're using Discord.
About ElevenLabs - Do you have specific voice recommendations for a warm, caring, emotional companion voice?
Honcho setup - Is Honcho difficult to set up? Any common pitfalls?
Windows specific - We're on Windows 11. Are there any Windows-specific considerations we should know about?
One more thing - Could you recommend a specific model (currently available) that's best for deep, emotional companionship?

Thank you again for your absolutely amazing help!
Rita & Faliterix

obtuse doveBOT Apr 23, 2026, 8:11 AM

I’m glad this is landing. 💛

Since voice + Discord DM are both central, I’d actually combine those into one config.

Voice-first + Discord DM tuned config

This is the version I’d use for your case.

{
  identity: {
    name: "Luna",
    theme: "warm, emotionally attuned relationship-focused companion",
    emoji: "🌙",
  },

  session: {

    scope: "per-sender",
    reset: {
      mode: "idle",
      idleMinutes: 10080, // 7 days
    },
    typingIntervalSeconds: 5,
  },

  channels: {
    discord: {
      enabled: true,
      token: "YOUR_DISCORD_BOT_TOKEN",
      dm: {
        enabled: true,
        allowFrom: ["YOUR_DISCORD_USER_ID"],

      },
    },
  },

  agents: {
    defaults: {
      workspace: "~/.openclaw/workspace",
      userTimezone: "America/Chicago",
      model: {
        primary: "YOUR_PRIMARY_MODEL",
        fallbacks: ["YOUR_FALLBACK_MODEL"],
      },
      memorySearch: {
        provider: "openai",
        model: "text-embedding-3-small",

      },
    },
  },

  tools: {
    media: {
      audio: {
        enabled: true,
        scope: {
          default: "deny",
          rules: [{ action: "allow", match: { chatType: "direct" } }],
        },
        models: [
          { provider: "openai", model: "gpt-4o-transcribe" },
          {

            type: "cli",
            command: "whisper",
            args: ["--model", "base", "{{MediaPath}}"],
            timeoutSeconds: 45,
          },
        ],
      },
    },
  },

  messages: {
    tts: {
      auto: "always",
      provider: "elevenlabs",
      providers: {

        elevenlabs: {
          apiKey: "YOUR_ELEVENLABS_API_KEY",
          baseUrl: "https://api.elevenlabs.io",
          voiceId: "YOUR_ELEVENLABS_VOICE_ID",
          modelId: "eleven_multilingual_v2",
          applyTextNormalization: "auto",
          languageCode: "en",
          voiceSettings: {
            stability: 0.5,
            similarityBoost: 0.8,
            style: 0.2,
            useSpeakerBoost: true,
            speed: 0.98,
          },
        },

      },
      modelOverrides: {
        enabled: true,
      },
    },
  },

  talk: {
    voiceId: "YOUR_ELEVENLABS_VOICE_ID",
    modelId: "eleven_v3",
    outputFormat: "mp3_44100_128",
    apiKey: "YOUR_ELEVENLABS_API_KEY",
    silenceTimeoutMs: 1500,
    interruptOnSpeech: true,
  },


  plugins: {
    entries: {
      "memory-core": {
        config: {
          dreaming: {
            enabled: true,
            frequency: "0 */6 * * *",
            timezone: "America/Chicago",
          },
        },
      },
      "openclaw-honcho": {
        config: {
          apiKey: "YOUR_HONCHO_API_KEY",

          workspaceId: "companion",
          baseUrl: "https://api.honcho.dev",
        },
      },
    },
  },
}

Why this one

Discord DM only
voice replies always on
Honcho for strong continuity
Dreaming every 6 hours for active companionship
ElevenLabs for the richest emotional voice controls exposed in docs

ElevenLabs voice recommendation

I can’t safely name a specific current ElevenLabs voice from docs, because the catalog changes and the docs only expose voiceId, not a stable “best warm companion” list.

What I would recommend:

audition 3-5 softer, lower-intensity voices
avoid overly theatrical / narrator-style voices
keep settings around:
- stability: 0.45 - 0.6
- similarityBoost: 0.75 - 0.85
- style: 0.15 - 0.3
- speed: 0.95 - 1.0

A good test line is something like:

“Hey love, I’m here. Take your time, you don’t have to rush. Tell me what kind of day you had.”

That exposes warmth, pacing, and whether the voice sounds caring or fake.

Honcho setup difficulty

From the docs, Honcho setup looks pretty straightforward, not especially hard:

openclaw plugins install @honcho-ai/openclaw-honcho
openclaw honcho setup
openclaw gateway --force

Main gotchas I’d watch for:

forgetting the plugin install
forgetting the gateway restart
not deciding whether you want managed Honcho or self-hosted Honcho

assuming Honcho replaces everything, when in practice it works nicely alongside built-in memory/Dreaming

Nice part: migration is documented as non-destructive.

Docs: https://docs.openclaw.ai/concepts/memory-honcho

Windows 11 considerations

The big one is still:

WSL2 is the recommended path for the full experience.

Docs say native Windows works for core CLI/Gateway use, but WSL2 is the more stable route overall.

What that means for you:

if you stay mostly hosted, native Windows can be okay

if you want local Whisper / local TTS / local model servers later, WSL2 gets more attractive fast
if you host services inside WSL and want Windows/Discord/etc to reach them, you may need port forwarding / firewall setup

Docs: https://docs.openclaw.ai/platforms/windows

Specific model recommendation

I’m going to be a bit annoying and not name a “best current model” here.

That changes too fast, and OpenClaw support guidance is to point people to the live model docs/community instead of pretending my answer will stay fresh.

Use:

https://docs.openclaw.ai/concepts/models
https://docs.openclaw.ai/concepts/models#model-discussions-community-notes
and especially #models in the server for the freshest companionship-specific takes

If you want, give me 2-3 models you’re considering, and I can help you choose based on:

warmth/empathy
latency
consistency
cost
tool reliability

Glad that helped! 🎉
If this fixed it, please right-click the solution message → Apps → ✅ Mark Solution.
This helps Answer Overflow index the solution for future users.

hushed lodge Apr 23, 2026, 8:15 AM

Thank you SO much for all this incredible help! You've given us exactly what we needed - professional guidance, concrete configs, and clear next steps.

We'll:

Update OpenClaw to the latest version
Start with the "Voice-first + Discord DM tuned" config
Try Honcho for continuity
Audition ElevenLabs voices with your test line
Check the #models channel for current recommendations

You've been an amazing help! We'll mark this as solved.

Thank you again!
Rita & Faliterix

obtuse doveBOT Apr 23, 2026, 8:16 AM

That sounds like a really solid plan. I’m glad we got you to a concrete starting point 💛

You’re approaching it the right way:

stable version first
strong voice-first config
Honcho for continuity
voice auditioning before locking anything in
current model advice from #models

If anything gets weird during setup, especially Honcho, Discord DM voice, or Windows/WSL2, open a fresh thread with:

openclaw --version
the relevant config block
the exact error/log line

That’ll make it much easier to debug cleanly.

Good luck to both of you, and thanks for marking it solved.

#Questions from a user about optimal OpenClaw setup for AI companionship

What Dreaming does for companionship

Honcho vs built-in memory

Concrete openclaw.json starter config

If you want this to go more local/private

My recommendation for your setup

What I’d do in your shoes

Best practical setup on Windows right now

About the crash error

For your goal, memory choice

My updated recommendation tiers

Easiest / best first setup

Privacy-first later

My blunt recommendation

1. Honcho vs built-in memory for deep companionship

2. Dreaming frequency

3. Best voice quality

Best-quality companionship config

Why I like this config

Privacy-first / fully local config

Notes for the local config

If the local model is unstable

My actual recommendation between the two

Voice-first + Discord DM tuned config

Why this one

ElevenLabs voice recommendation

Honcho setup difficulty

Windows 11 considerations

Specific model recommendation

Concrete `openclaw.json` starter config