{"slug": "running-openclaw-with-ollama", "title": "Running OpenClaw with Ollama", "summary": "OpenClaw, a personal AI assistant created by Peter Steinberger, bridges local Ollama models to messaging apps like Telegram, WhatsApp, and Slack, enabling private, hardware-based AI interactions. The project, which passed 60,000 GitHub stars, uses a three-layer architecture with a Gateway daemon to coordinate messaging, agent tasks, and model inference via Ollama. Setup requires configuring a 64k context window for multi-step agent tasks, with explicit context length settings needed due to Ollama's default VRAM-based limits.", "body_md": "# Running OpenClaw with Ollama\n\nThis article covers the full path from zero to a running private research assistant on Telegram, including configuring the context length correctly, connecting the channel, enabling web search, and deploying it headlessly in Docker.\n\n## # Introduction\n\nYou have successfully set up ** Ollama**, pulled a capable model, run a few queries in the terminal, and it worked. The responses were sharp. The latency was real. The whole thing ran on your own hardware with no API key and no cloud.\n\nThen you closed the terminal and walked away. The AI was gone. That is the gap ** OpenClaw** fills. It is a personal AI assistant that runs on your hardware and stays running, bridging your local Ollama models to the messaging apps you already use:\n\n**,**[WhatsApp](https://www.whatsapp.com/)\n\n**,**\n\n[Telegram](https://telegram.org/)**,**\n\n[Slack](https://slack.com/)**, iMessage.**\n\n[Discord](https://discord.com/)OpenClaw was created by Peter Steinberger, a macOS developer known for Apple tooling, and released in late 2025 under the name Clawdbot. The project passed 60,000 ** GitHub** stars within weeks. As of Ollama 0.17, the entire setup collapses to a single command.\n\nThis article covers the full path from zero to a running private research assistant on Telegram, including configuring the context length correctly, connecting the channel, enabling web search, and deploying it headlessly in ** Docker**.\n\n## # What OpenClaw Is and How It Works\n\nBefore running any commands, it helps to understand what is actually happening under the hood, because the architecture explains several decisions you will make during setup.\n\n[Everything flows through a single daemon called the Gateway](https://ollama.com/blog/openclaw). It stays running in the background, holds your messaging connections open, and coordinates the AI agent. When you send a message from WhatsApp or Telegram, here is the actual sequence: your text arrives through the messaging platform's protocol (WhatsApp uses ** Baileys**, Telegram uses the\n\n**), travels to the Gateway, which routes it to your model via Ollama's local API, and delivers the response back through the same channel. You see a reply in the messaging app. Nothing else happens on your device visibly.**\n\n[Bot API](https://core.telegram.org/bots/api)This three-layer design is what makes OpenClaw different from just running a chatbot in a terminal:\n\n- The messaging layer is the channel you send messages through: your phone, a desktop Telegram client, a Slack workspace. You do not need to be at the machine running Ollama. You just need to be connected to the messaging service.\n- The Gateway daemon is the coordination layer. It persists even when you are not actively using it, holds connections open, and manages multi-step agent tasks. This is what makes OpenClaw useful, rather than just interactive; tasks that take multiple tool calls can run in the background and deliver results when complete.\n- The model layer is Ollama. This can be a fully local model running on your GPU, or a cloud-backed model routed through Ollama's cloud service. The Gateway does not care which; it talks to Ollama's API either way.\n\nOne naming note worth covering upfront: OpenClaw was previously known as Moltbot and, before that, Clawdbot. It was renamed in early 2026. All old command aliases still work: `ollama launch clawdbot`\n\nstill functions, so nothing breaks if you have those stored in scripts or documentation.\n\n## # System Requirements and Prerequisites\n\nThe 64k context window requirement shapes everything else in your hardware and model selection decisions, so understand this before choosing a model.\n\nOllama defaults to [context lengths based on available VRAM](https://docs.ollama.com/context-length.md): under 24 GB gets 4k context, 24–48 GB gets 32k, and 48 GB or more gets 256k. The default for most consumer hardware is 4k, which is not enough for an agent doing multi-step tasks. You will need to set context explicitly, which the next section covers.\n\nHardware requirements:\n\nFeature |\nMinimum |\nRecommended |\n|---|---|---|\n| OS | macOS 12+, Linux, Windows (Windows Subsystem for Linux, WSL) | macOS 14+, Ubuntu 22.04+ |\n| RAM | 16 GB | 32 GB |\n| GPU VRAM (local model) | 25 GB (for or glm-4.7-flash)\n|\n48 GB+ |\n| GPU VRAM (cloud model) | None, runs on Ollama's cloud | GPU optional |\n| Disk | 5 GB (OpenClaw + deps) | 30 GB+ if pulling local models |\n\nSoftware prerequisites:\n\n- Ollama 0.17 or later is required; this is the version that introduced\n`ollama launch`\n\n. Check your version with`ollama --version`\n\nand download the latest from[ollama.com/download](https://ollama.com/download)if needed. 18 or later is required because OpenClaw installs via[Node.js](https://nodejs.org/). Ollama detects and prompts for this automatically, but it is worth having it installed before you start. Download from[npm](https://www.npmjs.com/)[nodejs.org](https://nodejs.org/)if needed.- An Ollama account is required for cloud models and for web search on local models. Create one at\n[ollama.com](https://ollama.com/)and sign in with:\n\n```\nollama signin\n```\n\nModel recommendations:\n\nModel |\nType |\nVRAM |\nBest for |\n|---|---|---|---|\n|\nCloud | None | Multimodal reasoning and sub-agents |\n|\nCloud | None | Reasoning, coding, vision |\n|\nCloud | None | Fast productivity tasks |\n|\nCloud | None | Reasoning and code generation |\n|\nLocal | ~25 GB | Coding tasks, full privacy |\n|\nLocal | ~16 GB | Reasoning locally |\n\nCloud models have full context length automatically and include web search support without any additional configuration. For most users starting out, `kimi-k2.5:cloud`\n\nis the right pick; it is free to start, handles agentic tasks well, and requires no VRAM.\n\n## # One-Command Installation with `ollama launch`\n\nWith Ollama 0.17+, you do not manually install OpenClaw, configure a Gateway, or manage npm packages. Ollama handles the entire bootstrap sequence.\n\nOpen a terminal and run:\n\n```\nollama launch openclaw\n```\n\nOr, to go directly to a specific model and skip the selector:\n\n```\nollama launch openclaw --model kimi-k2.5:cloud\n```\n\n[Ollama then handles five things automatically](https://ollama.com/blog/openclaw-tutorial), in this order:\n\n**Install check**: If OpenClaw is not already on your system, Ollama detects this and prompts you to install it via npm. Confirm, and it installs without you touching npm directly.**Security notice**: Before anything else runs, OpenClaw displays a security warning: the agent has the ability to read files and execute actions on your machine when tools are enabled. This is not boilerplate. An agent with file access that receives a malicious instruction can cause real damage. Read it. Run OpenClaw in an isolated environment if you are not certain about what it can reach. The[OpenClaw security documentation](https://docs.openclaw.ai/gateway/security)covers this in detail.**Model selector**: A list of recommended models appears. Select one, or press Enter to use the model you specified with`--model`\n\n. The selector shows both cloud and local models with context window notes.**Onboarding**: Ollama configures your provider, installs the Gateway daemon, sets the selected model as primary, and, if you chose a cloud model, enables OpenClaw's bundled Ollama web search automatically.**Gateway starts**: The Gateway launches in the background. The OpenClaw terminal user interface (TUI) opens, and you can start chatting immediately.\n\nIf you only want to change the configuration without starting the Gateway and TUI:\n\n```\n# Reconfigure without starting the agent\nollama launch openclaw --config\n```\n\nIf the Gateway is already running when you do this, it restarts automatically to pick up the new settings. No manual restart needed.\n\n## # Configuring Context Length for Agent Workloads\n\nThis is the step most tutorials skip, and it is the most common reason OpenClaw underperforms on real tasks.\n\nThe official docs state the minimum is 64k tokens, but understand what \"minimum\" means here. An agent doing a multi-step research task (**web search → read page → extract information → summarize → respond**) accumulates context across every step. At 64k, you have enough for a few turns with tool calls. For longer conversations or tasks with many tool invocations, you want more headroom. [Cloud models are set to their maximum context length automatically](https://docs.ollama.com/cloud.md) and do not need this configuration.\n\nFor local models, set context length before launching:\n\n```\n# Option 1: Environment variable (set it before starting Ollama)\nOLLAMA_CONTEXT_LENGTH=64000 ollama serve\n\n# For longer tasks on machines with enough VRAM, use more\nOLLAMA_CONTEXT_LENGTH=131072 ollama serve\n\n# Option 2: Through the Ollama app\n# Open Ollama settings → Context Length → move the slider to 64000 or higher\n```\n\nVerify that the context was actually applied and that your model is not being offloaded to the CPU:\n\n```\nollama ps\n```\n\nLook for output like this:\n\n```\nNAME                  ID              SIZE      PROCESSOR    CONTEXT    UNTIL\nqwen3-coder:latest    a4f2cc91b3e1    28.1 GB   100% GPU     65536      5 minutes from now\n```\n\nTwo things to check: `PROCESSOR`\n\nshould show `100% GPU`\n\n. If it shows a split like `40% GPU / 60% CPU`\n\n, the model is being offloaded, and performance will be significantly degraded. `CONTEXT`\n\nshould show `65536`\n\nor higher. If it shows `4096`\n\n, your environment variable did not take effect. Make sure you started `ollama serve`\n\nin the same shell session where you set the variable.\n\nIf you cannot fit the full 64k in VRAM, use a cloud model instead of compromising on context. The agent needs the context more than it needs local inference.\n\n## # Connecting a Messaging Channel\n\nOnce the Gateway is running, you connect your messaging platform with:\n\n```\nopenclaw configure --section channels\n```\n\nThis opens an interactive selector listing WhatsApp, Telegram, Slack, Discord, and iMessage. The setup steps differ per platform. Telegram is the cleanest starting point for developers. It requires no phone number linking and uses a proper bot token rather than emulating a personal account.\n\n#### // Setting Up Telegram\n\n**Step 1: Create a bot with BotFather**\n\nOpen Telegram and search for ** @BotFather**. Send\n\n`/newbot`\n\n, choose a name (this is the display name), then choose a username (must end in bot, e.g. `my_openclaw_bot`\n\n). BotFather returns a token that looks like:\n\n```\n1234567890:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n```\n\nCopy this token. You will not be shown it again. If you lose it, you can generate a new one with `/token`\n\n.\n\n**Step 2: Paste the token into OpenClaw**\n\nIn the `openclaw configure --section channels`\n\nmenu, select Telegram, then paste the bot token when prompted.\n\n**Step 3: Select \"Finished\" to save**\n\nAfter configuring, select Finished in the configurator. This is required. Exiting without selecting Finished discards your configuration.\n\n**Step 4: Find your bot on Telegram and start a conversation**\n\nSearch for your bot's username in Telegram. Send `/start`\n\n. The Gateway handles the first connection and the bot begins responding.\n\nFor WhatsApp, the process uses the Baileys protocol, which means you scan a QR code in the OpenClaw TUI to link your WhatsApp account. This works, but it links your actual WhatsApp account rather than creating a separate bot account. Be aware of that before proceeding.\n\nFor Slack and Discord, you will need to create an app in each platform's developer portal and supply the bot token and channel IDs. The OpenClaw configurator walks through the required fields for each.\n\n## # The Real-World Project: Private Research Assistant on Telegram\n\nHere is the full project this article has been building toward. A private Telegram bot that:\n\n- Answers questions using your local or cloud model\n- Searches the web for live information using Ollama's built-in web search\n- Fetches and summarizes documents and URLs you send it\n- Handles multi-step research tasks with no data leaving your machine (when using a local model)\n\nOnce your Telegram channel is connected and the Gateway is running, this is already functional without any additional code. OpenClaw handles the agent loop natively. The configuration choices you make are what shape the experience.\n\n#### // Enabling Web Search\n\nIf you launched with a cloud model, [Ollama installs the web search plugin automatically](https://ollama.com/blog/openclaw-tutorial). You can verify it is active by asking your bot a question that requires current information: \"What did Anthropic announce this week?\" A properly configured bot with web search will search and return a cited answer. Without web search, it will answer from training data or say it does not know.\n\nFor local models, web search requires `ollama signin`\n\nfirst, then:\n\n```\nopenclaw configure --section web\n```\n\nThis enables the bundled Ollama `web_search`\n\nprovider, which routes searches through Ollama's web search API using your account credentials.\n\n#### // What a Multi-Step Task Looks Like in the TUI\n\nSend this to your Telegram bot:\n\n```\nFind the three most-cited papers on transformer attention published in 2025 and give me a one-sentence summary of each.\n```\n\nIn the OpenClaw TUI on your machine, you will see the agent's tool call log as it works. Something like:\n\n```\n[tool] web_search: \"most cited transformer attention papers 2025\"\n[tool] web_fetch: https://arxiv.org/...\n[tool] web_fetch: https://paperswithcode.com/...\n[reasoning] Identified three papers: ...\n[response] Sending to Telegram...\n```\n\nThe task completes in Telegram as a formatted message with the three papers, their citation counts, and summaries, typically in 20–40 seconds depending on your model and connection speed.\n\nThat is the core of what makes this setup genuinely useful: multi-step agent tasks that would require a browser, multiple searches, and manual synthesis can be delegated from your phone with a single message and return a synthesized answer while you do something else.\n\n#### // The Python Script Approach: Calling the Web Search API Directly\n\nIf you want to build on top of this setup programmatically, for example, scheduling daily research summaries or piping results into a database, you can call Ollama's web search API directly from ** Python** using the same credentials OpenClaw uses:\n\n```\n# research_agent.py\n# A minimal research agent using Ollama's web search + chat API.\n# Prerequisites:\n#   pip install ollama\n#   ollama signin (run once in your terminal)\n#   ollama pull qwen3.5:cloud  (or any tool-capable model)\n#\n# How to run:\n#   python research_agent.py \"What are the latest developments in local LLMs?\"\n\nimport sys\nfrom ollama import chat, web_search, web_fetch\n\n# ── Tool registry ─────────────────────────────────────────────────────────────\n# Map tool names to actual callables so we can dispatch tool calls from the model.\nAVAILABLE_TOOLS = {\n    \"web_search\": web_search,\n    \"web_fetch\":  web_fetch,\n}\n\ndef run_research_agent(query: str, model: str = \"qwen3.5:cloud\") -> str:\n    \"\"\"\n    A multi-turn research agent that uses web search and page fetching\n    to answer questions with up-to-date information.\n\n    Args:\n        query: The research question to answer\n        model: Ollama model to use. Cloud models recommended for 64k+ context.\n\n    Returns:\n        The agent's final synthesized answer as a string.\n    \"\"\"\n    messages = [\n        {\n            \"role\": \"system\",\n            \"content\": (\n                \"You are a research assistant. When answering questions that require \"\n                \"current information, use the web_search tool to find relevant results, \"\n                \"then use web_fetch to read the most promising pages before responding. \"\n                \"Always cite your sources in the final answer.\"\n            ),\n        },\n        {\n            \"role\": \"user\",\n            \"content\": query,\n        },\n    ]\n\n    print(f\"Query: {query}\\nModel: {model}\\n{'─' * 60}\")\n\n    # ── Agentic loop ──────────────────────────────────────────────────────────\n    # The loop continues as long as the model is making tool calls.\n    # When the model stops calling tools and writes a final response, we break.\n\n    while True:\n        response = chat(\n            model=model,\n            messages=messages,\n            tools=[web_search, web_fetch],  # Pass the actual callables -- Ollama extracts the schema\n            think=True,                      # Enable chain-of-thought before tool decisions\n        )\n\n        # Show reasoning trace if present (think=True)\n        if response.message.thinking:\n            print(f\"[thinking] {response.message.thinking[:200]}...\")\n\n        # Append the model's response to message history\n        messages.append(response.message)\n\n        # If the model made tool calls, execute each one and inject results\n        if response.message.tool_calls:\n            for tool_call in response.message.tool_calls:\n                tool_name = tool_call.function.name\n                tool_fn   = AVAILABLE_TOOLS.get(tool_name)\n\n                if not tool_fn:\n                    # Tool not found -- tell the model so it can adjust\n                    print(f\"[tool] {tool_name}: NOT FOUND\")\n                    messages.append({\n                        \"role\":      \"tool\",\n                        \"content\":   f\"Tool '{tool_name}' is not available.\",\n                        \"tool_name\": tool_name,\n                    })\n                    continue\n\n                args   = tool_call.function.arguments\n                print(f\"[tool] {tool_name}({args})\")\n\n                result = tool_fn(**args)\n                result_str = str(result)\n                print(f\"[result] {result_str[:150]}...\")\n\n                # Truncate tool results to stay within context budget.\n                # At 64k context, ~8000 chars per result is a safe ceiling\n                # for multi-step tasks with several tool calls.\n                messages.append({\n                    \"role\":      \"tool\",\n                    \"content\":   result_str[:8000],\n                    \"tool_name\": tool_name,\n                })\n        else:\n            # No more tool calls -- the model has a final answer\n            final_answer = response.message.content\n            print(f\"\\n{'─' * 60}\\nAnswer:\\n{final_answer}\")\n            return final_answer\n\n# ── Entry point ───────────────────────────────────────────────────────────────\n\nif __name__ == \"__main__\":\n    query = sys.argv[1] if len(sys.argv) > 1 else \"What are the latest developments in local LLMs?\"\n    run_research_agent(query)\n```\n\nPrerequisites:\n\n```\npip install ollama\nollama signin\nollama pull qwen3.5:cloud\n```\n\nHow to run:\n\n```\npython research_agent.py \"What are the three most-cited papers on transformer attention published in 2025?\"\n```\n\nExpected output:\n\n```\nQuery: What are the three most-cited papers on transformer attention published in 2025?\nModel: qwen3.5:cloud\n────────────────────────────────────────────────────────────\n[thinking] The user wants specific papers from 2025. I need to search for recent publications...\n[tool] web_search({'query': 'most cited transformer attention papers 2025', 'max_results': 5})\n[result] results=[WebSearchResult(content='...'), ...]...\n[tool] web_fetch({'url': 'https://paperswithcode.com/...'})\n[result] title='Papers With Code - Transformer Attention...'...\n\n────────────────────────────────────────────────────────────\nAnswer:\nHere are three highly-cited transformer attention papers from 2025:\n\n1. **[Paper Title]** -- [Summary]. Cited 847 times as of June 2026.\n   Source: arxiv.org/...\n\n2. **[Paper Title]** -- [Summary]. Cited 623 times.\n   Source: paperswithcode.com/...\n\n3. **[Paper Title]** -- [Summary]. Cited 511 times.\n   Source: semanticscholar.org/...\n```\n\nThe tool call truncation at 8,000 characters per result is the most important practical detail in this script. Without it, a long web page fetched in a single tool call can consume 20k–40k tokens of your context budget in one step, leaving insufficient room for subsequent tool calls and the final synthesis. Truncate aggressively and rely on the model's ability to work with the most relevant portion.\n\n## # Non-Interactive and Headless Deployment\n\nFor production use, a machine that runs the agent 24/7, or a deployment in Docker, the interactive TUI is in the way. The `--yes`\n\nflag removes it entirely:\n\n```\nollama launch openclaw --model kimi-k2.5:cloud --yes\n```\n\nThe `--yes`\n\nflag auto-pulls the model, skips all interactive selectors, and starts the Gateway immediately. It requires `--model`\n\nto be specified explicitly. The flag has no way to guess a model without the selector.\n\nDockerfile for a headless OpenClaw server:\n\n```\n# Dockerfile\n# Runs Ollama + OpenClaw as a headless agent service.\n# Build: docker build -t openclaw-agent .\n# Run:   docker run -d --gpus all --env-file .env openclaw-agent\n#\n# Prerequisites for the build machine:\n#   - Docker with nvidia-container-toolkit (for GPU passthrough)\n#   - A .env file with OLLAMA_API_KEY and channel credentials\n\nFROM ubuntu:22.04\n\n# ── System dependencies ────────────────────────────────────────────────────────\n# Ubuntu 22.04's default apt repo ships Node.js 12.x, which does not meet\n# OpenClaw's Node.js 18+ requirement, so Node.js 18 is installed via NodeSource.\nRUN apt-get update && apt-get install -y curl \\\n    && curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \\\n    && apt-get install -y nodejs \\\n    && rm -rf /var/lib/apt/lists/*\n\n# ── Install Ollama ─────────────────────────────────────────────────────────────\nRUN curl -fsSL https://ollama.com/install.sh | sh\n\n# ── Install OpenClaw via npm ───────────────────────────────────────────────────\n# Install globally so the `openclaw` binary is in PATH\nRUN npm install -g openclaw\n\n# ── Set context length for agent workloads ─────────────────────────────────────\n# 64000 is the minimum. Increase if your GPU has VRAM headroom.\nENV OLLAMA_CONTEXT_LENGTH=64000\n\n# ── Startup script ─────────────────────────────────────────────────────────────\n# 1. Start the Ollama server in the background\n# 2. Wait for it to be ready\n# 3. Launch OpenClaw headlessly with the specified cloud model\nCOPY start.sh /start.sh\nRUN chmod +x /start.sh\n\nEXPOSE 11434\n\nCMD [\"/start.sh\"]\n\n# start.sh -- runs alongside the Dockerfile above\n\n#!/bin/bash\nset -e\n\n# Start the Ollama server in the background\nollama serve &\nOLLAMA_PID=$!\n\n# Wait until Ollama's API is responding (up to 30 seconds)\necho \"Waiting for Ollama to start...\"\nfor i in $(seq 1 30); do\n    if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then\n        echo \"Ollama ready.\"\n        break\n    fi\n    sleep 1\ndone\n\n# Launch OpenClaw headlessly -- --yes skips all interactive prompts\n# OLLAMA_MODEL should be set in your .env file or docker run -e flag\nollama launch openclaw \\\n    --model \"${OLLAMA_MODEL:-kimi-k2.5:cloud}\" \\\n    --yes\n\n# Keep the container alive and follow OpenClaw's logs\nwait $OLLAMA_PID\n```\n\nBuild and run:\n\n```\n# Create a .env file with your credentials\ncat > .env << EOF\nOLLAMA_MODEL=kimi-k2.5:cloud\nOLLAMA_API_KEY=your_ollama_api_key\nEOF\n\n# Build the image\ndocker build -t openclaw-agent .\n\n# Run with GPU passthrough (requires nvidia-container-toolkit)\ndocker run -d \\\n    --gpus all \\\n    --env-file .env \\\n    --name openclaw \\\n    openclaw-agent\n\n# Follow logs\ndocker logs -f openclaw\n```\n\nFor local models without GPU passthrough, remove `--gpus all`\n\nand ensure `OLLAMA_MODEL`\n\npoints to a cloud model. The GPU flag is only needed when running local models that require VRAM.\n\nStopping and restarting the Gateway:\n\n```\n# Stop the Gateway cleanly (use this instead of killing the process)\nopenclaw gateway stop\n\n# The Gateway restarts automatically when you run ollama launch again\nollama launch openclaw --model kimi-k2.5:cloud --yes\n```\n\n## # Stopping the Gateway and Common Troubleshooting\n\nStop the Gateway cleanly when you need to:\n\n```\nopenclaw gateway stop\n```\n\nUsing **Ctrl+C** in the TUI works for the interactive session but may leave the Gateway daemon running. Use `gateway stop`\n\nto ensure it terminates.\n\n**Common issues:**\n\n- If messages are not being processed, check that the Gateway is actually running:\n\n```\n# Check if the openclaw gateway process is alive\npgrep -la openclaw\n```\n\n- If the agent gives outdated answers despite web search being configured, verify your Ollama account is signed in:\n\n```\nollama signin\n```\n\n- If you see\n`context length exceeded`\n\nerrors in the TUI log, your context window is too small for the task. Increase`OLLAMA_CONTEXT_LENGTH`\n\nand restart`ollama serve`\n\nbefore relaunching OpenClaw. - If the model is being partially offloaded to CPU (visible in\n`ollama ps`\n\nas a split percentage), either reduce context length, switch to a smaller model, or move to a cloud model. CPU offloading works but will make multi-step tasks noticeably slow.\n\n## # Conclusion\n\nOpenClaw and Ollama together close the gap between \"AI that works in a terminal\" and \"AI that works wherever you are.\" The Gateway runs in the background. Your messaging app becomes the interface. A single command sets up the entire stack.\n\nThe practical value shows up quickly: multi-step research tasks you would normally spend 20 minutes doing manually complete in the background while you are doing something else, delivered as a formatted message to your phone. File tasks, calendar management, and inbox processing are all expanding rapidly, and OpenClaw's skill library is growing alongside them, as the community builds integrations on top of the Gateway architecture.\n\nFor users who care about where their data goes, the local model path is simple: a capable model, 25 GB of VRAM, and one context-length configuration deliver a fully private agent with no cloud dependency at all. For users who want the easiest possible start, a cloud model is one command away.\n\nEither path ends at the same place: an AI assistant that answers your messages, does your research, and runs on infrastructure you control.\n\n#### // Resources\n\n[OpenClaw official documentation](https://docs.openclaw.ai/)[Ollama integrations: OpenClaw](https://docs.ollama.com/integrations/openclaw)[Ollama blog: OpenClaw introduction](https://ollama.com/blog/openclaw)[Ollama blog: Simplest way to set up OpenClaw](https://ollama.com/blog/openclaw-tutorial)[Ollama context length documentation](https://docs.ollama.com/context-length.md)[Ollama web search documentation](https://docs.ollama.com/capabilities/web-search.md)[Ollama cloud models](https://docs.ollama.com/cloud.md)\n\nis a software engineer and technical writer passionate about leveraging cutting-edge technologies to craft compelling narratives, with a keen eye for detail and a knack for simplifying complex concepts. You can also find Shittu on\n\n[Shittu Olumide](https://www.linkedin.com/in/olumide-shittu/)", "url": "https://wpnews.pro/news/running-openclaw-with-ollama", "canonical_source": "https://www.kdnuggets.com/running-openclaw-with-ollama", "published_at": "2026-07-09 14:00:15+00:00", "updated_at": "2026-07-09 14:17:31.426532+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-tools", "ai-products", "developer-tools", "ai-infrastructure"], "entities": ["OpenClaw", "Ollama", "Peter Steinberger", "Telegram", "WhatsApp", "Slack", "GitHub", "Docker"], "alternates": {"html": "https://wpnews.pro/news/running-openclaw-with-ollama", "markdown": "https://wpnews.pro/news/running-openclaw-with-ollama.md", "text": "https://wpnews.pro/news/running-openclaw-with-ollama.txt", "jsonld": "https://wpnews.pro/news/running-openclaw-with-ollama.jsonld"}}