For years, AI assistants promised to make our work easier (summarize reports, process documents, extract key details) so we could focus on what really matters. But reality often fell short. Most assistants stumbled when faced with messy PDFs, scanned documents, or complex tables, leaving us with incomplete data and frustrating manual clean-up.
OpenClaw changed the game. It’s not just another chatbot, it’s an autonomous agent with the ability to interact with your system, execute tasks, and manage real workflows. Its document-handling skills are impressive, but even OpenClaw isn’t perfect: complex documents can still trip it up, and results aren’t always consistent.
By adding Kudra as a custom skill, we’re making OpenClaw’s document processing reliable, powerful, and automated. With OCR, table extraction, and AI-driven analysis, your assistant can now extract structured data, summarize key points, analyze research papers, and categorize documents without missing a beat.
In this article, I’ll show you how to install on windows and supercharge OpenClaw with Kudra and finally turn document management from a headache into a seamless, trustworthy workflow.
So What is OpenClaw?
OpenClaw is an open-source AI assistant that runs locally, handling tasks like email management, calendar scheduling, web browsing, and document processing via chat apps. It was developed using a “vibe-coding” methodology, where Peter Steinberger (founder) used AI agents to develop and deploy code quickly. Steinberger calls the assistant “Claude with capabilities” because it uses Anthropic’s Claude models as its core intelligence while gaining the power to interact with a computer’s mouse, keyboard, and filesystem.
This AI agent is an open-source assistant that has complete system access and operates locally or in the cloud:
| Feature | ChatGPT | OpenClaw |
|---|---|---|
| Platform | Web-based interface | Integrated into messaging apps |
| Memory behavior | Context resets after each session | Retains long-term context |
| Proactive messages | Does not initiate conversations | Can message you proactively |
| Executes actions | Cannot perform actions on your device | Can run tasks on your computer |
| Data storage | Data processed on OpenAI servers | Data stored locally on your device |
How to Install OpenClaw on Windows (Without Losing Your Mind)
Step 1: Prep Windows (Do This Before Docker)
Yes, Docker is required but do not install it yet.
If you skip this step, Docker will fail in confusing and pointless ways.
Open Command Prompt and run:
wsl --install
This installs WSL2, which OpenClaw depends on.
It takes about 2 minutes.

When it finishes, restart your machine.
Annoying but mandatory.
Step 2: Enable the One Windows Setting Everyone Misses
After restarting:
Search “Turn Windows features on or off”
Enable Windows Subsystem for Linux
Click OK

Before restarting again, do one more check:
Open Task Manager
Go to Performance
Make sure Virtualization is Enabled
If it’s disabled, you’ll need to enable it in your BIOS.
This is the #1 reason Docker fails to launch on Windows.

Now restart one more time.
Step 3: Install Docker Desktop
Search “Install Docker on Windows” and download Docker Desktop (x86-64).
Double-click the installer
Click OK through the prompts
Let it finish
Restart when prompted

Once back up:
Launch Docker
Accept the terms
Skip login — you don’t need an account
At this point, Docker should show Running.
Step 4: Clone OpenClaw
Search “OpenClaw GitHub”, open the repo, click Code, and copy the URL.
Open your terminal and run:
git clone
cd openclaw
Step 5: Run the Setup
cd to the openclaw folder, run:
./docker-setup.sh
This takes 3–4 minutes.

Stay at your keyboard, it will ask questions.
Choose Yes
Select Quickstart
Pick your AI provider
I recommend Google here, the free tier is generous.
Paste your Gemini API key
(You can generate one in Google AI Studio.)
Choose your model (e.g. Gemini 3 Flash Preview)
Skip skills and hooks for now.
Step 6: The Pairing Bug Everyone Hits (15-Second Fix)
When setup finishes, you’ll get a URL with a token.
👉 Copy the entire URL (token included)
👉 Paste it into your browser
You’ll see “Pairing Required.”
This is where most people get stuck.

Here’s the fix:
Go to
C:\Users\<your-username>\.openclaw\devicesOpen
pending.jsonChange:
"silent": false
to:
"silent": true
Save the file
Pro tip: Sometimes Windows doesn’t save it on the first try.
Double-check before refreshing.
Now refresh the browser.

You now have OpenClaw running locally on Windows, powered by Docker, using a free LLM, with system-level tools and no cloud lock-in.
Build Document Workflows For OpenClaw
5 Things to Know About Clawdbot
It is an open-source project: There’s no major corporation that controls the codebase and can monitor you or surprise us with sudden subscription fees. It can also operate locally, so you don’t need to subscribe to any paid services to experiment with it.
Clawdbot can control your computer: This means the AI agent can access your emails, examine your notes, manage your documents and files, and even interact with your browser and perform actions. This presents a significant amount of risk, so be mindful of this.
The app is interfaced through popular messaging services like WhatsApp, Telegram, Discord, or iMessage: This means you can instruct the AI agent to develop a project on your desktop through Telegram. No need to launch your laptop and navigate through Claude Code to generate the app yourself, Clawdbot will handle it for you.
It has a persistent and unlimited memory: One of the most impressive features about Clawdbot is its capability to retain all your instructions and the context of your past conversations with it. The responses are more tailored and context-aware.
Clawdbot will evolve and become even more capable in the coming months: There is tremendous excitement around this technology, and it is receiving significant attention from the AI community. The fact that it’s open source means it will gain more features rapidly.
Supercharging Clawdbot with Document Intelligence

OpenClaw already comes with solid document-handling capabilities, but like any AI assistant, it can struggle with complex PDFs, scanned documents, and messy tables. The result? Inconsistent extractions, missing key details, and unreliable summaries.
Kudra is a document intelligence platform that combines OCR, table extraction, and vision-language models to extract structured data from PDFs and scanned documents. By adding Kudra as a custom tool to your Clawdbot setup, your agent can:
Reliably extract structured data from any PDF or scanned document
Summarize key points and terms automatically
Analyze research papers and pull out methodologies and findings
Organize documents through smart, automatic categorization
With this upgrade, OpenClaw won’t just handle documents, it’ll master them, turning messy files into clean, actionable data you can trust.
Let’s create a custom Kudra skill for OpenClaw.
Creating the Kudra Document Skill
First, create the skill directory:
mkdir -p ~/.openclaw/skills/kudra-extract
cd ~/.openclaw/skills/kudra-extract
Create a SKILL.md file:
---
name: kudra-extract
description: Extract structured data from PDFs and complex documents using Kudra's vision-based extraction
metadata:
openclaw:
requires:
bins: ["python3", "pip"]
env: ["KUDRA_TOKEN", "KUDRA_PROJECT_RUN_ID"]
---
# Kudra Document Extraction
Use this skill when the user needs to extract structured data from PDFs, especially documents with tables and complex structures.
## When to Use
- User asks to "process document" or "extract data from PDF"
- User wants to analyze documents with complex tables
- User needs structured data from scanned documents
- User asks to "organize receipts" or "analyze contracts"
## How It Works
This skill uses Kudra's API to:
1. Extract text with OCR (handles scanned documents)
2. Preserve table structure using vision models
3. Generate metadata and semantic tags
4. Return structured JSON output
## Setup
Install the Kudra client (if not already installed):
```bash
pip3 install kudra-cloud-client --break-system-packages
```
Ensure environment variables are set:
- `KUDRA_TOKEN`: Your Kudra API token
- `KUDRA_PROJECT_RUN_ID`: Your project run ID
## Usage Examples
**Extract invoice data:**
```bash
python3 ~/.openclaw/skills/kudra-extract/extract.py /path/to/invoice.pdf
```
**Process folder of documents:**
```bash
python3 ~/.openclaw/skills/kudra-extract/extract.py /path/to/folder
```
## Instructions for Agent
When the user asks to process documents:
1. Use the `bash` tool to call the extraction script
2. Pass the file path or directory as an argument
3. Parse the returned JSON to extract relevant information
4. Present results in a clear, organized format
The script returns structured JSON with:
- Extracted text
- Tables (with preserved row/column structure)
- Metadata (semantic tags, summaries)
- Confidence scores
Now create the extraction script (extract.py):
#!/usr/bin/env python3
import os
import sys
import json
from pathlib import Path
from kudra_cloud_client import KudraCloudClient
KUDRA_TOKEN = os.getenv("KUDRA_TOKEN")
KUDRA_PROJECT_RUN_ID = os.getenv("KUDRA_PROJECT_RUN_ID")
if not KUDRA_TOKEN or not KUDRA_PROJECT_RUN_ID:
print(json.dumps({"error": "Missing KUDRA_TOKEN or KUDRA_PROJECT_RUN_ID environment variables"}))
sys.exit(1)
def extract_documents(path: str):
"""Extract structured data from document(s)"""
# Determine if path is file or directory
if os.path.isfile(path):
file_dir = str(Path(path).parent)
elif os.path.isdir(path):
file_dir = path
else:
return {"error": f"Path not found: {path}"}
# Initialize Kudra client
kudra_client = KudraCloudClient(token=KUDRA_TOKEN)
try:
# Process documents
results = kudra_client.analyze_documents(
files_dir=file_dir,
project_run_id=KUDRA_PROJECT_RUN_ID
)
if not results:
return {"error": "No results returned from Kudra"}
# Format output
output = []
for result in results:
doc_data = {
"filename": result.get('file', 'Unknown'),
"text_length": len(result.get('text', '')),
"tables_found": len(result.get('extracted_tables', [])),
"has_metadata": bool(result.get('open_ai_result'))
}
# Include first table as sample
if result.get('extracted_tables'):
table = result['extracted_tables'][0]
doc_data['sample_table'] = {
"rows": len(table.get('data', [])),
"preview": str(table.get('data', [])[:2])
}
output.append(doc_data)
return {"success": True, "documents": output, "full_results": results}
except Exception as e:
return {"error": str(e)}
if __name__ == "__main__":
if len(sys.argv) < 2:
print(json.dumps({"error": "Usage: extract.py "}))
sys.exit(1)
path = sys.argv[1]
result = extract_documents(path)
print(json.dumps(result, indent=2))
We can create as many tools as wee need … these skills ols can do diffrent things depending on what Kudra templates you use or what workflows you make for your documents.
Make the script executable:
chmod +x ~/.openclaw/skills/kudra-extract/extract.py
Enable the Skill
Add your Kudra credentials to OpenClaw’s environment. Edit ~/.openclaw/openclaw.json:
{
"skills": {
"entries": {
"kudra-extract": {
"enabled": true,
"env": {
"KUDRA_TOKEN": "your_kudra_token_here",
"KUDRA_PROJECT_RUN_ID": "your_project_run_id_here"
}
}
}
}
}
Restart OpenClaw to load the new skill:
openclaw restart
Verify the tools are loaded:
openclaw skills list
You should see kudra-extract in the skills list. Now your OpenClaw agent can process complex documents intelligently!
To use the skill Message your agent via Telegram or WhatsApp:
- “Process all documents in my downloads folder”
- “Extract data from this contract PDF”
- “Analyze the research paper I just uploaded”
OpenClaw will automatically use the Kudra skill when appropriate, extracting structured data with preserved table structure, OCR for scanned documents, and semantic metadata. (This is a more reliable way to trust it with pdfs since regualr agents suck at handeling complex documents)
Testing the Integration
Let’s test the Kudra integration with a sample document.

In the conversation before adding the skill the bot made a mistake repeated a drug (Velotef) and added max 1g for some reason after the skill as you can see it did not make mistakes. This is the kind of reliability we are talking about :

Cool Things You Can Do with Clawdbot + Kudra
Since Clawdbot is an “always-on” AI assistant, it functions as a system-level agent that can execute real-world tasks through your favorite messaging apps like WhatsApp or Telegram. With Kudra integration, you can create custom workflows that automate a wide range of document and data tasks:
PDF-to-CSV conversion: Tell Clawdbot via Telegram or Slack to convert PDFs in a folder into structured CSVs. Kudra extracts tables, line items, or any structured content, saving you hours of manual work.
Email attachment processing: Have Clawdbot monitor your email inbox and automatically process incoming PDF attachments. It can extract relevant entities like names, dates, amounts, or any custom data, then push structured outputs to Notion, Google Sheets, or Slack.
Entity extraction and data enrichment: Configure workflows inside Kudra to detect key entities—like customer names, addresses, contract clauses, or research data—from any document. Clawdbot can then organize, tag, or summarize this information wherever you need it.
Research and knowledge management: Automatically process academic papers or reports, extract abstracts, tables, or methodologies, and generate structured summaries or citations directly in your note-taking apps.
Custom automation: Almost any repetitive document or data task can be automated—simply define the workflow in Kudra, and Clawdbot executes it in the background while you focus on what matters.
With this setup, the power of AI meets full automation, turning your PDFs, emails, and documents into instantly usable, structured data, without lifting a finger.
Build Document Workflows For OpenClaw
Final Thoughts
OpenClaw is the AI assistant we were promised years ago. It is what Siri or even Claude Code should have evolved into.
I’ve seen some articles and videos suggesting people should purchase and stack Apple Mac Minis for running this. But I don’t think that’s necessary. The paid remote servers, like Hetzner VPS, are only 5to 50 per month, which should be affordable enough instead of dedicating your local machine.
But beyond the hardware, there is a significant and inherent security risk in deploying this app. Be extremely careful when installing it.
If you are simply experimenting with the tool, then use the following setup:
Use a remote server instead of installing it on your local machine: You can also create a sandboxed environment and install Clawdbot there. Or just use an old laptop or purchase a spare machine to experiment with the AI tool.
There will be numerous upgrades and new features coming to this app now that it is gaining significant attention. Let’s all stay tuned for what’s next.
And with Kudra integration, you’re not just getting system automation, you’re getting intelligent document understanding. Your agent can now read, comprehend, and act on document content, not just move files around.
The combination of Clawdbot’s system control and Kudra’s document intelligence creates something genuinely transformative. This is what intelligent automation should be.
