Build Your First Local AI Agent with OpenClaw and Ollama

A chatbot answers questions. An AI agent goes further: it can use tools, remember what it did in previous sessions, break a complex goal into subtasks, and execute each one — autonomously, step by step — until the job is done.

The practical difference is significant. A chatbot can tell you how to summarize a folder of documents. An agent can actually do it — read each file, draft the summaries, write them to disk, and report back. No copy-pasting required.

OpenClaw is one of the most widely used open-source agent frameworks, and it runs entirely with local models via Ollama — no OpenAI API key, no monthly bill, no data leaving your machine. This guide walks you from zero to a working file-processing agent in about 20 minutes.

Prerequisites

• ✓
  Ollama installed and running

  The agent communicates with your model over the Ollama REST API at localhost:11434.

  Install guide →
• ✓
  A model with solid tool-calling support

  Tool-calling requires a model large enough to reliably follow JSON schemas. Qwen3 14B is the minimum recommended — Qwen3 32B or Llama 3.3 70B if you have the VRAM.

• ✓
  Node.js 18+ or Python 3.10+

  OpenClaw ships packages for both runtimes. The examples below use the Node.js CLI, but every concept maps 1:1 to the Python SDK.

Install OpenClaw

OpenClaw is distributed as both an npm package (for the CLI and Node.js SDK) and a pip package (for the Python SDK). Install whichever matches your preferred runtime:

# Install OpenClaw CLI globally via npm
npm install -g openclaw

# Verify installation
openclaw --version
openclaw 0.9.4

# Alternative: Python package
pip install openclaw

Once installed, run openclaw init inside your project directory. This creates an openclaw.config.json file and a tools/ directory where your custom tool definitions live.

Connect OpenClaw to your local Ollama

Open openclaw.config.json and point it at your local Ollama endpoint. The key fields are provider, endpoint, and model:

{
  "model": "qwen3:14b",
  "endpoint": "http://localhost:11434",
  "provider": "ollama",
  "temperature": 0.3,
  "context_window": 8192,
  "memory": {
    "enabled": true,
    "store": "./agent_memory.db"
  }
}

Setting temperature to 0.3 keeps the agent's reasoning deterministic and focused — higher values make it more creative but less reliable when filling in tool call parameters. For agents, lower is almost always better.

Give your agent a tool

Tools are the bridge between the language model's reasoning and the real world. A tool is essentially a function description — the agent sees the name, description, and expected parameters, and decides when and how to call it. OpenClaw uses the same JSON Schema format as the OpenAI function-calling spec, so most existing tool definitions are portable.

Here's a simple read_file tool definition you can drop into tools/read_file.json:

// Tool definition — JSON Schema format (used by OpenClaw and most agent frameworks)
{
  "name": "read_file",
  "description": "Read the contents of a file at the given path",
  "parameters": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "Absolute or relative path to the file"
      }
    },
    "required": ["path"]
  }
}

OpenClaw bundles a standard library of common tools — read_file, write_file, list_dir, run_shell, and http_get — that you can enable by name in config. Custom tools (your own Python or JS functions) are loaded from the tools/ directory and work identically.

Run your first task

With the config in place and at least one tool enabled, you're ready to run your first agent task. Pass a natural-language goal to openclaw run:

# Launch the agent with a natural-language task
openclaw run --task "Summarize every .md file in ./docs and write a one-paragraph overview for each"

━━━ Agent starting ━━━
Model : qwen3:14b @ localhost:11434
Tools : read_file, list_dir, write_file (3 enabled)

[Thought]  I need to find all .md files inside ./docs first.
[Action]   list_dir(path="./docs")
[Obs]      README.md  setup.md  api-reference.md  changelog.md

[Thought]  Four files found. I'll read each one and draft a summary.
[Action]   read_file(path="./docs/README.md")
[Obs]      <file content, 420 words>

[Thought]  Good. Writing summary for README.md now.
[Action]   write_file(path="./summaries/README.summary.md", content="...")
[Obs]      File written successfully.

[...3 more files processed...]

[Final Answer]
Done. Summaries written to ./summaries/ (4 files).
Total tokens used: 6,241 | Time: 48 s

The output shows the agent's full reasoning loop: a Thought (what it plans to do), an Action (the tool call with arguments), an Observation (the tool's return value), and ultimately a Final Answer. This ReAct (Reason + Act) pattern is the standard control loop for most agent frameworks.

Token count and wall-clock time are shown at the end. For a 14B model on a mid-range GPU, expect roughly 1–3 minutes per 5,000 tokens of context. Larger models are slower but make fewer mistakes in multi-step tasks.

Troubleshooting

# Switch to a larger model that handles tool-calling reliably
openclaw config set model qwen3:14b

# Or edit openclaw.config.json directly
"model": "qwen3:14b"   # minimum recommended for tool-calling

# Start the Ollama server (required before running any agent)
ollama serve

# Verify it's listening on 11434
curl http://localhost:11434
Ollama is running