DEV Community: Preecha

How to Run Qwen3.5 with OpenClaw for Free Using Ollama?

Preecha — Mon, 12 Oct 2026 02:03:11 +0000

You face high cloud bills when you run powerful AI agents every day. Qwen3.5 gives you frontier-level multimodal reasoning locally. You combine it with OpenClaw for persistent agent workflows and Ollama for simple local serving. The result is a complete AI agent that works 24/7 on your machine without subscriptions.

Try Apidog today

💡You test Ollama’s OpenAI-compatible endpoint and OpenClaw’s gateway directly inside Apidog. Visual requests, instant assertions, and saved test scenarios make every configuration change easy to verify.

Small choices matter. You pick the right model tag. You set the correct base URL. These decisions create big differences in speed and reliability. This guide shows you exact steps so you finish with a production-ready stack you control completely.

What Makes Qwen3.5 Perfect for Local Agent Work

Alibaba released Qwen3.5 in early 2026 as its first native vision-language model family. The 397B-A17B flagship uses a hybrid architecture. It combines Gated Delta Networks with sparse Mixture-of-Experts. Only 17 billion parameters activate per token. You get strong performance with far less memory.

Ollama hosts these practical tags you pull today:

qwen3.5:35b — fits in 24 GB VRAM, 256K context, full text and image support
qwen3.5:122b — needs 81 GB for deeper reasoning

You run qwen3.5 locally and keep your data private. The model scores 86.7 on TAU2-Bench and 85.0 on MMMU. You therefore trust it for agent tasks that mix text, screenshots, and tool calls.

How OpenClaw Turns Qwen3.5 Into a Real Agent

OpenClaw runs as your always-on agent runtime. You connect it to WhatsApp, Telegram, Slack, Discord, or Signal once. The agent listens continuously. When you send a message, OpenClaw routes it to qwen3.5, calls tools, controls your browser with Playwright, edits files, updates calendars, and answers proactively.

You store memory across sessions. The agent remembers your projects and preferences forever. You install community skills or let qwen3.5 write new ones on demand. OpenClaw therefore becomes your personal digital assistant that never sleeps.

Why Ollama Makes the Integration Simple

Ollama serves models locally and exposes an OpenAI-compatible endpoint on port 11434. You point OpenClaw at http://localhost:11434/v1 and set the model to qwen3.5:35b. Ollama handles quantization, GPU offload, and context management automatically.

You achieve fast token generation on consumer hardware. You keep the full 256K context window that qwen3.5 needs for long agent conversations. You avoid cloud costs and data leaks at the same time.

Prerequisites You Need to Meet

You prepare your machine before you start:

Use macOS 14 or later, Ubuntu 22.04/24.04, or Windows 11 with WSL2.
Ensure at least 24 GB VRAM for the 35B model or 32 GB unified memory on Apple Silicon.
Keep 30 GB free disk space.
Install Node.js 22 or higher and Ollama 0.17 or newer.

You verify your GPU later with one command. Hardware that meets these requirements gives you responsive performance. You fall back to smaller quantized models if you have less memory.

Install Ollama and Pull Qwen3.5

You start by installing Ollama:

macOS:

brew install ollama
brew services start ollama

Linux:

curl -fsSL https://ollama.com/install.sh | sh
systemctl enable --now ollama

You confirm the service runs with:

ollama list

Next, you pull the model:

ollama pull qwen3.5:35b

The download finishes in 10 to 30 minutes. You test basic inference:

ollama run qwen3.5:35b

You type a prompt inside the REPL. Qwen3.5 answers accurately. You exit with /bye.

You immediately check the OpenAI-compatible endpoint because OpenClaw needs it:

curl http://localhost:11434/v1/models

The response lists qwen3.5:35b. You know the bridge works.

Launch OpenClaw With Qwen3.5

You use one Ollama command to install and start everything:

ollama launch openclaw --model qwen3.5:35b

Ollama installs missing components, starts the gateway, and opens the TUI wizard. You connect your messaging channels, confirm the model provider, and save settings. The gateway runs on port 8080.

You test by messaging your bot on Telegram:

“List files in my Downloads folder.”

OpenClaw uses qwen3.5 and returns the result.

You can also configure manually. You edit ~/.openclaw/openclaw.json and set the Ollama provider base URL. You restart with:

openclaw start

Both methods give identical results.

Test the Full Stack With Apidog

You open Apidog and create a new project called “Qwen3.5 OpenClaw Local Stack.” You set the base URL to http://localhost:11434/v1.

You add a POST request to /chat/completions. You include these headers:

{
  "Content-Type": "application/json",
  "Authorization": "Bearer ollama"
}

You use this body:

{
  "model": "qwen3.5:35b",
  "messages": [
    {"role": "system", "content": "You are a helpful agent."},
    {"role": "user", "content": "Plan steps to organize my Downloads folder by file type."}
  ],
  "temperature": 0.7,
  "max_tokens": 2048
}

You send the request. Apidog shows streaming tokens in real time. You add a visual assertion for status code 200. You save the request as a test scenario. You run the scenario again after you change settings. You therefore catch problems immediately.

You create a second collection for OpenClaw’s gateway at http://localhost:8080/v1. You test end-to-end message routing. Apidog’s schema validation confirms tool-call formats match what OpenClaw expects.

Design and Document Your Endpoints in Apidog

You use Apidog’s visual designer to model the chat completions schema. You import the official OpenAI spec. You customize it for qwen3.5 parameters. You generate interactive documentation automatically. You share the docs with teammates through Apidog workspaces if you work together.

You also create mock responses inside Apidog. You simulate tool calls before you finish the full OpenClaw setup. You therefore develop faster and test edge cases safely.

Advanced Configuration for Better Performance

You create a custom Modelfile when you need lighter quantization:

FROM qwen3.5:35b
PARAMETER num_gpu 999
PARAMETER num_ctx 131072

You build it with:

ollama create qwen3.5:35b-q4 -f Modelfile

You update your OpenClaw config to use the new tag.

You enable vision by sending base64 images in chat messages. Qwen3.5 processes screenshots that OpenClaw captures during browser tasks. You therefore automate forms that require visual understanding.

You install extra skills:

openclaw skill install @community/calendar
openclaw skill install @community/github

Each skill registers JSON schemas. Qwen3.5 learns to call them automatically. You monitor usage inside the OpenClaw dashboard.

Real-World Workflows You Run Today

Code Reviews:

You message OpenClaw:

“Review the PR in my repo and suggest refactors.”

The agent clones the repository, analyzes code, and creates a patch.
Personal Task Automation:

You write:

“Check my inbox for flight confirmations and add them to calendar.”

OpenClaw parses emails and updates your calendar.
Research Assistants:

You send a PDF screenshot and ask for a summary plus follow-up questions. Qwen3.5 extracts text accurately. OpenClaw keeps context across days.
Multiple Agents:

You launch separate OpenClaw workspaces. One uses qwen3.5:35b for general work. Another uses a specialized coder model. The gateway routes messages correctly.

Optimize Speed and Memory Usage

Set OLLAMA_NUM_GPU=999 to use all GPU layers. Monitor with nvidia-smi. On Apple Silicon, enable flash attention.
Reduce context bloat with periodic summarization prompts that qwen3.5 runs automatically.
The 35B model reaches 45–60 tokens per second on a 4090-class GPU. Choose the variant that fits your hardware.
Use Apidog’s performance testing to measure latency across 100 requests. Adjust temperature and max_tokens until you reach your target response time.

Solve Common Problems Quickly

“Model not found”:

Run ollama list and correct the tag in your config.
High latency:

Check logs with journalctl -u ollama and increase GPU layers. Use Apidog to re-test the same request and confirm improvement.
Tool-call parsing fails:

Lock temperature at 0.7 inside Apidog test scenarios and re-run.
OpenClaw loses connection:

Run openclaw configure --section channels to refresh tokens.
Rate limits in Ollama:

Increase concurrency settings and test again in Apidog.

You use Apidog’s error inspection pane for every issue. The visual stack trace and response comparison speed up fixes dramatically.

Keep Your Setup Secure

Run OpenClaw under a dedicated user account.
Enable sandboxing for tool execution.
Never expose ports 11434 or 8080 publicly. Access them through SSH tunnels or Tailscale when you travel.
Review every skill source before installation.
Turn on memory encryption in OpenClaw settings.
Back up the ~/.openclaw folder regularly.

You therefore operate a system safer than most cloud services because your data never leaves your network.

Plan for Future Updates

Alibaba releases smaller Qwen3.5 variants regularly. Ollama adds them quickly. Pull updates with:

ollama pull qwen3.5:35b --force

OpenClaw’s skill library grows every week. Check GitHub notifications to stay current.
Repeat the Apidog testing process after each update. Keep your test collection and simply change the model tag. Maintain reliability without extra work.

The same OpenClaw setup is model-agnostic—swapping in DeepSeek produces a capable local AI assistant that runs entirely offline and requires no API subscription.

Conclusion

You now run qwen3.5 with OpenClaw for free using Ollama. You control the entire stack on your hardware. You get strong reasoning, vision support, persistent memory, and proactive automation.

You followed clear steps. You tested every layer with Apidog. You optimized performance and secured the environment. Small configuration choices produced a capable personal AI agent.

Open your terminal now. Run the launch command. Connect your messaging apps. Send your first task. You will see how powerful a fully local agent feels.

Download Apidog to follow along with future updates and keep testing your endpoints efficiently. You already have everything you need to build smarter workflows today.

Top 12 Tools for Testing MCP Servers

Preecha — Sun, 11 Oct 2026 14:02:10 +0000

In the rapidly expanding universe of Generative AI, the Model Context Protocol (MCP) has emerged as the critical standard for connecting Large Language Models (LLMs) to external data and tools. But building an MCP server is only half the battle; ensuring it responds accurately, securely, and efficiently to AI agents is where the real challenge lies.

Try Apidog today

To help you navigate this landscape, we have curated the ultimate list of tools for testing MCP servers. Whether you are debugging a local script or deploying a complex enterprise agent, these tools are essential for your stack.

1. Apidog MCP Client — The Ultimate Solution for Testing MCP Server

The Best All-in-One MCP Server Testing Platform

When it comes to tools for testing MCP servers, Apidog stands out as the premier choice for developers who demand efficiency and depth. While many tools offer basic debugging, Apidog provides a comprehensive ecosystem that streamlines the entire lifecycle of MCP development.

Apidog's built-in MCP Client allows you to debug and test MCP servers with a level of granularity that standard CLIs cannot match. It supports both STDIO (for local processes) and HTTP/SSE (for remote servers) transport layers, making it versatile for any stage of development.

Key Features:

Visual Debugging: Connect to your server and instantly visualize the directory tree of available Tools, Prompts, and Resources. No more guessing if your server is registering capabilities correctly.
One-Click Execution: Run server-side tools directly from the UI with custom parameters. Apidog validates your inputs against the schema automatically.
Transport Flexibility: Seamlessly switch between testing a local stdio server and a deployed http endpoint without changing tools.
Security & Auth: Built-in support for complex authentication flows, including OAuth 2.0, ensuring your MCP Server testing tools cover security requirements.

If you want to delve into professional-grade MCP development, Apidog is your starting point.

2. MCP Inspector

The Primary Tool for Manual Debugging

The MCP Inspector is the "Swiss Army knife" of MCP clients to test MCP Server implementations. Developed by the core MCP team, it runs in your browser and connects directly to your local server. It is invaluable for inspecting the raw JSON-RPC messages flowing between the client and server. If you need to verify that your server is strictly adhering to protocol specs, the Inspector is your go-to utility.

Best for: Real-time message inspection and schema validation.
Key Feature: Interactive "playground" to test tool calls and resource reads.

3. Claude Desktop

Real-World Host for End-to-End Testing

While synthetic tests are useful, nothing beats seeing how an actual AI agent interacts with your tool. Claude Desktop acts as a production-grade MCP Client to test MCP Server behavior in the wild. By configuring your local MCP server in Claude's settings, you can chat with the model and watch it "decide" to use your tools. This reveals subtle issues in your tool descriptions—if Claude is confused, your users will be too.

Best for: Testing "agentic" behavior and prompt effectiveness.
Insight: Use this to refine how you describe your tools to the LLM.

4. mcp-server-tester

AI-Driven CLI for Automated Test Generation

mcp-server-tester brings the power of AI to your testing pipeline. Instead of writing boilerplate test cases, this CLI tool analyzes your MCP server's capabilities and auto-generates test scenarios. It helps you indulge in a faster workflow by creating rapid feedback loops, ensuring that new changes don't break existing functionality.

5. FastMCP Client

Best for High-Speed In-Memory Unit Testing

Speed is critical in CI/CD pipelines. FastMCP Client is designed for unit testing where network latency is a bottleneck. By mocking the transport layer and testing your server logic in-memory, it allows you to run thousands of assertions in seconds. It is a vital MCP Server testing platform component for developers practicing TDD (Test Driven Development).

6. mcp-testing-kit

Node.js Utility for Structured Assertions

For teams that prefer code-first testing, the mcp-testing-kit offers a robust library of assertions specifically for MCP. It simplifies the process of validating complex JSON payloads and ensuring that your server's responses match the expected schema structure.

7. Promptfoo MCP Scanner

Security Red-Teaming Against Injection Attacks

Promptfoo has extended its reputation in LLM eval to MCP. The MCP Scanner acts as a red-teamer, bombarding your server with adversarial inputs designed to trick the agent or exploit vulnerabilities. It is crucial for identifying "prompt injection" risks where an attacker might manipulate the tool's output to hijack the conversation.

8. Invariant Labs MCP-Scan

Focuses on Preventing Tool Manipulation

Invariant Labs MCP-Scan takes a deep dive into the logic of your tools. It analyzes the flow of data to prevent unauthorized tool manipulation, ensuring that an agent cannot be coerced into performing actions outside its permission scope.

9. mcp-tef

Validating the Quality of Tool Descriptions

Security is also about clarity. mcp-tef validates that your tool descriptions are precise and unambiguous. Ambiguous descriptions are a security risk because they lead to unpredictable model behavior. This tool ensures your MCP Server testing tools stack includes semantic validation.

10. Postman

Standard for Testing HTTP/SSE Transport Layers

For MCP servers running over HTTP/SSE, Postman remains the gold standard. You can craft collections that simulate client requests, validate headers, and check SSE stream stability. It’s perfect for testing the "plumbing" of your server before you even connect an AI agent.

11. JMeter

Concurrency and Stress Testing

JMeter is the heavy lifter for load testing. If you expect your MCP server to handle concurrent requests from thousands of agents, JMeter can simulate that traffic. It helps you identify memory leaks and latency spikes that only appear under load.

12. Cursor

IDE Host to Test Agent Tool Selection

Cursor, the AI-first code editor, doubles as an excellent testing environment. By integrating your MCP server, you can see how an AI coding assistant interacts with your custom tools while you write code. It provides a unique "developer experience" lens on your server's performance.

Conclusion

The ecosystem of tools for testing MCP servers is maturing rapidly. While standard tools like the MCP Inspector and Postman provide essential debugging capabilities, adopting a dedicated platform like Apidog transforms the experience. Apidog not only simplifies connection and visualization but acts as a complete MCP Server testing platform that bridges the gap between manual debugging and automated reliability.

By combining Apidog with specialized security scanners like Promptfoo and performance beasts like JMeter, you can build MCP servers that are not just functional, but enterprise-ready. Don't let your AI agent fail because of a buggy tool—equip yourself with the right testing stack today.

10 OpenClaw Automation Tasks That Save Hours

Preecha — Sun, 11 Oct 2026 02:03:03 +0000

TL;DR

OpenClaw isn't just for answering questions—it's a powerful automation tool that can handle repetitive tasks, manage communications, and streamline your workflow. From sending scheduled emails to organizing files, this guide shows 10 practical automation tasks you can set up today to save hours every week.

Try Apidog today

Introduction

Every developer has tasks that repeat: checking emails, filing documents, sending status updates. These take minutes each but add up to hours weekly.

OpenClaw can handle many of these automatically. Combined with its skills system and platform integrations, you can set up powerful workflows that run themselves.

Here are 10 automation tasks you can implement today.

Understanding OpenClaw Automation

How Automation Works

OpenClaw automation works through:

Skills: Pre-built automation packages
Triggers: Schedule, events, or commands
Actions: What OpenClaw does automatically

Getting Started

Install automation skills from ClawHub:

npx clawhub skills install scheduler
npx clawhub skills install email-helper
npx clawhub skills install file-manager

Task 1: Daily Email Summaries

What It Does

Automatically fetch and summarize your unread emails each morning.

Setup

npx clawhub skills install gmail-summary

Configuration

# ~/.openclaw/skills/gmail-summary/config.yaml
schedule: "0 8 * * *"  # 8 AM daily
max_emails: 10
summary_style: "bullet"
channels:
  - telegram
  - discord

Example Output

📧 Your Morning Email Summary (Feb 25)

Unread: 15

🔴 Important:
• Meeting request: Q3 Planning (from John)
• Invoice #12345 (from Accounting)

📎 Other:
• Newsletter: TechCrunch Daily
• Order confirmation: Amazon

Action items: Review calendar for 2pm meeting

Use Cases

Morning briefing before work
Meeting preparation
Urgent item detection

Task 2: Meeting Scheduler

What It Does

Natural language meeting scheduling across calendars.

Setup

npx clawhub skills install calendar-helper

Usage

Me: Schedule a meeting with John tomorrow at 2pm

OpenClaw: I'll schedule it. Checking calendars...

✓ Available: 2:00-2:30pm
✓ Created: "Meeting with John" - Tomorrow 2:00pm
📧 Invitation sent to john@company.com

Features

Check multiple calendars
Find optimal times
Send invitations
Add video links
Set reminders

Task 3: File Organization

What It Does

Automatically organize downloads, documents, and project files.

Setup

openclaw skills install file-organizer

Configuration

# ~/.openclaw/skills/file-organizer/config.yaml
watch_folders:
  - ~/Downloads
  - ~/Desktop
rules:
  - pattern: "*.pdf"
    destination: ~/Documents/PDFs
  - pattern: "screenshot-*"
    destination: ~/Pictures/Screenshots
  - pattern: "*.{js,ts,py}"
    destination: ~/Code/temp
  - pattern: "report-*"
    destination: ~/Documents/Reports
run_on_schedule: "0 */4 * *"  # Every 4 hours

What Happens

Every 4 hours, OpenClaw:

Scans your configured folders
Matches files against rules
Moves files to appropriate destinations
Reports what was organized

Task 4: Git Workflow Automation

What It Does

Streamline common Git operations and enforce standards.

Available Automations

Automatic commit messages:

Me: Commit my changes

OpenClaw: Analyzing your changes...

Modified: 3 files
- src/index.js (feature additions)
- src/styles.css (layout updates)
- package.json (dependencies)

✓ Committed: a1b2c3d "Add user dashboard feature"

🤖 Suggestion: Consider adding tests for the new component

Branch management:

Me: Create a feature branch for user-auth

OpenClaw:
✓ Created: feature/user-auth
✓ Switched to new branch
✓ Based on: main

PR automation:

Me: Create a PR for this code

OpenClaw:
✓ Analyzing changes...
✓ Created PR #45: "Add user authentication"
📝 Description generated from commits
👀 Reviewers: @team-lead
🔗 Tests: Passing

Task 5: Code Snippet Manager

What It Does

Store, search, and retrieve code snippets using natural language.

Setup

npx clawhub skills install snippet-manager

Usage

Save a snippet:

Me: Save this as "React useEffect cleanup"

jsx
useEffect(() => {
const handler = () => console.log('cleanup');
return () => handler();
}, []);
OpenClaw: ✓ Saved! Tag: "react", "hooks"


**Find a snippet:**

jsx
Me: Find my React cleanup snippet

OpenClaw:📋 React useEffect cleanup (react, hooks)

useEffect(() => {
const handler = () => console.log('cleanup');
return () => handler();
}, []);
✓ Used 3 times recently


### Features

- Tag-based organization
- Search by description
- Syntax highlighting
- Usage tracking
- Import/export

## Task 6: Daily Standup Reporter

### What It Does

Generate and share daily standup reports automatically.

### Setup

bash
openclaw skills install standup-reporter


### Configuration

yaml

~/.openclaw/skills/standup-reporter/config.yaml

schedule: "0 9 * * 1-5" # 9 AM weekdays
track:

git_commits
jira_tickets
calendar_events output:
telegram
slack template: "standup"


### Example Output

plaintext
📊 Daily Standup - Feb 25

✅ Completed:
• PR #234: User dashboard feature
• Bug fix: Login timeout issue
• Code review: Auth refactor

📅 Today:
• Continue: API integration
• Meeting: 2pm with team
• Review: PR #238

🎯 Blockers:
• Waiting on: Design specs for settings page

⏱️ Time tracking: 6.5 hrs


## Task 7: Research Assistant

### What It Does

Automate information gathering and summarization.

### Setup

bash
npx clawhub skills install research-helper
npx clawhub skills install web-scraper


### Usage

plaintext
Me: Research the latest news on quantum computing

OpenClaw: 🔍 Searching...

✓ Found 15 articles

📰 Top Stories:

IBM announces new quantum processor
Google achieves quantum supremacy milestone
Investment in quantum startups hits record

📄 Summary:
Quantum computing continues rapid advancement...
[Full report saved to ~/Research/quantum-computing.md]

Would you like me to expand on any topic?


### Features

- Web search automation
- Content summarization
- Source collection
- Report generation
- Topic tracking

## Task 8: Monitoring & Alerts

### What It Does

Monitor systems, services, and send alerts proactively.

### Setup

bash
npx clawhub skills install system-monitor


### Configuration

yaml

~/.openclaw/skills/system-monitor/config.yaml

checks:

name: server_health type: http url: https://api.yoursite.com/health interval: 5 # minutes
name: disk_space type: shell command: "df -h / | tail -1 | awk '{print $5}'" threshold: "90%"
name: cron_health type: service service: cron alerts: telegram: enabled: true email: enabled: true to: you@example.com


### Alert Example

plaintext
🚨 Alert: High Disk Usage

Server: production-01
Metric: Disk / usage
Current: 92%
Threshold: 90%
Time: Feb 25 09:15 UTC

Action needed: Consider cleaning old logs or expanding storage


## Task 9: Content Repurposing

### What It Does

Automatically convert content across formats and platforms.

### Setup

bash
npx clawhub skills install content-repurpose


### Usage

plaintext
Me: Turn my blog post into a Twitter thread

OpenClaw: 📝 Converting...

✓ Created 8-tweet thread:

[1/8] 🚀 Just published a new guide on AI automation!
Here's what you'll learn 👇

[2/8] 1/ Task automation saves 5+ hours/week
The key is starting with repetitive tasks

...

[8/8] 🔗 Read the full guide: [link]

AI #Productivity #Automation


### Features

- Blog to social media
- Long-form to summaries
- Cross-platform formatting
- Image extraction
- Hashtag suggestions

## Task 10: Database Assistant

### What It Does

Query databases using natural language.

### Setup

bash
npx clawhub skills install database-helper


### Configuration

yaml

~/.openclaw/skills/database-helper/config.yaml

connections:
production:
type: postgresql
host: localhost
database: myapp
analytics:
type: mysql
host: analytics.internal
database: stats


### Usage

plaintext
Me: How many users signed up this week?

OpenClaw: 🔍 Querying database...

📊 Results:
This week: 1,247 new users
Last week: 982 new users
Change: +27%

📈 Trend: Upward trend continues (3rd week)




### Features

- Natural language queries
- Multiple database support
- Query history
- Export results
- Schema documentation

## Best Practices

### Starting Out

- Start simple: Begin with one automation
- Test thoroughly: Verify before relying on it
- Monitor initially: Check outputs regularly
- Iterate: Refine based on results

### Security

- Never include credentials in configs
- Use environment variables
- Restrict access to automation skills
- Review permissions regularly

### Maintenance

- Update skills regularly
- Review and adjust schedules
- Check for breaking changes
- Document custom automations

## Conclusion

OpenClaw transforms from a conversational AI into a powerful automation platform. These 10 tasks are just the beginning—almost any repetitive task can be automated.

Start with these:
- Daily email summary (high value, easy setup)
- Git workflow automation (if you code daily)
- File organization (runs in background)

Scale up as you go:
- Add more skills from ClawHub
- Create custom automations
- Connect multiple platforms

The time you invest in setup pays back quickly in saved hours.

## FAQ

### Do I need coding skills to use these automations?

No! Most automations work out of the box with configuration. Some customizations may require basic YAML knowledge.

### Can I create custom automations?

Yes! Use SKILL.md for simple automations or TypeScript skills for complex ones. See our [Custom Skills guide](https://apidog.com/custom-skills?utm_source=dev.to&utm_medium=wanda&utm_content=blog-sync).

### How much time can I save?

Typical savings: 2-5 hours per week for active users. The email summarizer alone saves 15-30 minutes daily.

### Are these automations safe?

Yes, but:
- Review skill permissions
- Don't store credentials in plain text
- Test before production use
- Monitor initially

### Can I run automations on a schedule?

Yes! OpenClaw supports cron-based scheduling. Set exact times or intervals for any automation.

How to Run OpenClaw with Ollama ?

Preecha — Sat, 10 Oct 2026 14:02:57 +0000

TL;DR

Ollama is the easiest way to run powerful AI models locally. Combined with OpenClaw, it creates a free, privacy-focused AI assistant that rivals paid alternatives. This guide walks you through setting up Ollama, choosing the right model, and integrating it with OpenClaw for your personal AI assistant.

Introduction

Running AI locally was once a hobbyist's pursuit, requiring complex setup and expensive hardware. Ollama changed that. With a simple install command and intuitive API, Ollama makes running AI models locally accessible to anyone.

Try Apidog today

When paired with OpenClaw, you get a powerful AI assistant that:

Costs nothing to run (after initial setup)
Keeps your data 100% private
Works offline once models are downloaded
Offers full customization control

This guide covers everything you need to get started.

Why Use Ollama with OpenClaw

Benefits of Local AI

Privacy: Your conversations never leave your machine
No API costs: Pay once for hardware, use unlimited
Offline access: Works without internet
Full control: Customize models and prompts
No rate limits: Use as much as you want

Why Ollama

Ollama stands out for several reasons:

Simple installation: One command gets you started
Model library: 100+ models available
Cross-platform: Works on macOS, Linux, Windows
API-first: Easy integration with OpenClaw
Active development: Regular updates and new models

Prerequisites

Before starting, ensure you have:

Hardware Requirements

Model SizeMinimum RAMRecommended RAM7B params8GB16GB14B params16GB32GB32B params32GB64GB70B params64GB128GB

Software Requirements

macOS 10.15+, Linux, or Windows 10+
Administrator/root access for installation
Internet connection for initial downloads
Command line familiarity

What You'll Need

A computer meeting RAM requirements
Internet for downloading models
Time for initial model downloads (varies by size and connection)

Installing Ollama

macOS Installation

The easiest method uses Homebrew:

brew install ollama

Or use the official installer script:

curl -fsSL https://ollama.ai/install.sh | sh

Linux Installation

# Using the install script (recommended)
curl -fsSL https://ollama.ai/install.sh | sh

# Or download the binary directly
sudo curl -L https://ollama.ai/download/ollama-linux-amd64 -o /usr/bin/ollama
sudo chmod +x /usr/bin/ollama

Windows Installation

Download the installer Run the installerFollow the on-screen instructions

Verifying Installation

ollama --version

You should see output like ollama version 0.15.0 or newer.

Starting Ollama Service

Ollama runs as a background service:

# Check if Ollama is running
ollama list

# Start Ollama if not running
ollama serve

Choosing the Right Model

Ollama supports 100+ models. Here's how to choose:

By Use Case

Use CaseRecommended ModelsGeneral conversationQwen3.5, Llama 3.2, MistralCoding assistanceQwen3.5-Coder, DeepSeek-CoderReasoning/mathDeepSeek-R1, Qwen3.5Smaller hardwarePhi3.5, Gemma2.2B

By Hardware

Available RAMRecommended8GB7B models (Qwen3.5, Llama3.2, Mistral)16GB8-14B models32GB14-32B models64GB+70B+ models

Popular Models in 2026

Qwen3.5 — Excellent all-around performance, strong reasoning, good for coding. The most popular choice for OpenClaw in 2026.

DeepSeek-R1 — Open-source reasoning model that rivals GPT-4 on math and logic tasks. Great for complex problem-solving.

Mistral — Lightweight but capable. Excellent for systems with limited RAM.

Installing Models

Pulling Models

# Install Qwen3.5 (recommended for most users)
ollama pull qwen2.5:7b

# Or the latest Qwen3
ollama pull qwen3:7b

# DeepSeek-R1 for reasoning tasks
ollama pull deepseek-r1:7b

# Llama 3.2
ollama pull llama3.2:7b

# Mistral
ollama pull mistral:7b

Model Tags

Models come in different sizes:

# Different parameter sizes
ollama pull qwen2.5:3b    # Smaller, faster
ollama pull qwen2.5:7b    # Balanced
ollama pull qwen2.5:14b   # More capable

Viewing Installed Models

ollama list

This shows all downloaded models and their sizes.

Running and Testing Models

Interactive Mode

# Chat with the model
ollama run qwen2.5:7b

Type your message and press Enter. Type /bye to exit.

API Mode

Ollama runs an API server on port 11434 by default:

# Generate endpoint
curl http://localhost:11434/api/generate -d {
  "model": "qwen2.5:7b",
  "prompt": "Hello, how are you?",
  "stream": false
}

Using the Python Library

from ollama import Client

client = Client()
response = client.chat(
    model='qwen2.5:7b',
    messages=[
        {'role': 'user', 'content': 'Hello!'}
    ]
)
print(response['message']['content'])

Testing with Apidog

Before connecting to OpenClaw, test your Ollama setup using Apidog:

Create a new request in Apidog
Set method to POST
Enter URL: http://localhost:11434/api/generate
Add header: Content-Type: application/json

Add body:

{
  "model": "qwen3-coder",
  "prompt": "What is 2 + 2?",
  "stream": false
}

This verifies your Ollama setup works before integrating with OpenClaw.

Integrating Ollama with OpenClaw

Now let's connect Ollama to OpenClaw.

Method 1: Quick Configuration

# Set OpenClaw to use Ollama with your model
openclaw models set ollama/qwen2.5:7b

Method 2: Environment Variables

# Configure Ollama endpoint
export OLLAMA_HOST=http://localhost:11434

# Set the default model
export OLLAMA_MODEL=qwen2.5:7b

Method 3: Configuration File

Create or edit ~/.openclaw/config.yaml:

models:
  default: ollama/qwen2.5:7b

ollama:
  host: http://localhost:11434
  model: qwen2.5:7b
  temperature: 0.7
  top_p: 0.9

Verifying Integration

# Check OpenClaw model status
openclaw models status

# Test with a message
openclaw chat "Hello!"

You should receive a response from your local model.

Configuration Options

Fine-tune your Ollama + OpenClaw setup:

Temperature

Controls creativity vs precision:

ollama:
  temperature: 0.7    # 0.0 = precise, 1.0 = creative

Top-P and Top-K

Control response diversity:

ollama:
  top_p: 0.9         # Nucleus sampling
  top_k: 40          # Token selection

Context Length

For longer conversations:

ollama:
  context_size: 4096  # Default is often 2048 or 4096

System Prompt

Customize model behavior:

ollama:
  system_prompt: |
    You are a helpful coding assistant.
    Provide clear, concise code examples.
    Explain concepts simply.

Switching Between Models

One advantage of Ollama is easy model switching:

# Switch to DeepSeek-R1 for reasoning
openclaw models set ollama/deepseek-r1:7b

# Switch to Qwen-Coder for coding tasks
openclaw models set ollama/qwen2.5-coder:7b

# Switch back to general model
openclaw models set ollama/qwen2.5:7b

Multiple Model Setup

Configure multiple models in config.yaml:

models:
  default: ollama/qwen2.5:7b
  coding: ollama/qwen2.5-coder:7b
  reasoning: ollama/deepseek-r1:7b

Then switch between them:

openclaw models set coding
openclaw models set reasoning

Troubleshooting

Model Won't Load

Problem: Out of memory errors

Solutions:

Use a smaller model (7B instead of 14B)
Close other applications to free RAM
Check available memory with free -h (Linux) or Activity Monitor (Mac)

Slow Responses

Problem: Responses take too long

Solutions:

Use a smaller model
Enable GPU acceleration (if available)
Reduce context size
Use SSD storage for model files

Connection Refused

Problem: OpenClaw can't connect to Ollama

Solutions:

# Verify Ollama is running
ollama serve

# Check the port
curl http://localhost:11434

Model Not Found

Problem: Model doesn't exist in Ollama

Solutions:

# Pull the model
ollama pull qwen2.5:7b

# Check available models
ollama list

Conclusion

You've now got a powerful, private AI assistant running locally. Ollama + OpenClaw delivers capabilities that would cost $20+/month with cloud alternatives—all running on hardware you control.

What you can do now:

Chat with your AI through multiple platforms
Switch between models based on tasks
Customize prompts for specialized behaviors
Run offline once models are downloaded

The only limit is your hardware.

Next steps:

Experiment with different models
Try Qwen3.5, DeepSeek-R1, and others
Customize your system prompts
Explore OpenClaw skills on ClawHub

Ready to build professional AI applications? Download Apidog free and test your AI integrations with a visual interface designed for developers.

FAQ

What's the best Ollama model for OpenClaw?

Qwen3.5 is currently the most popular—balanced performance with good reasoning and coding capabilities. DeepSeek-R1 excels at reasoning tasks if that's your priority.

Can I run multiple Ollama models at once?

Yes, but each model requires RAM. A typical setup runs one model at a time, switching as needed.

Do I need a GPU?

No, Ollama works on CPU. GPU acceleration makes it faster but isn't required. Smaller models (7B) work reasonably well on CPU.

How do I update models?

ollama pull model-name

Ollama updates automatically if a newer version is available.

Can I use my own fine-tuned models?

Yes, import custom models using Ollama's import functionality. Check the Ollama documentation for details.

OpenClaw Security & Privacy: Is Your Data Safe?

Preecha — Sat, 10 Oct 2026 02:02:23 +0000

TL;DR

OpenClaw runs entirely locally, your conversations, code, and data never leave your machine. Unlike cloud AI assistants that store everything on remote servers, OpenClaw gives you complete control over your data. This guide explains exactly how OpenClaw handles your information, its security features, and best practices for keeping your AI assistant secure.

Try Apidog today

Introduction

Every time you use ChatGPT or Claude, your conversations travel to their servers. They're stored, can be used for training, and may be accessed under certain legal circumstances.

OpenClaw is different. It runs on your machine, using your hardware and your electricity. But what does that actually mean for your security and privacy?

Let's look at exactly what happens with your data.

How OpenClaw Handles Data

The Local Architecture

When you use OpenClaw:

Your device runs everything
Your model processes your input
Your storage holds conversation history
Your network connects to Ollama (if using local models)

Nothing goes to external servers by default.

Data Flow

User Input → OpenClaw → Local Model (Ollama) → Response
                    ↓
            Local Storage Only
            (conversation history)

Compare to cloud AI:

User Input → OpenClaw → Cloud API → Cloud Server → Model → Response
                              ↓
                    Stored on Server
                    (potentially for training)

What Stays Local

With OpenClaw, these stay on your machine:

All conversations
Code you share
Files you process
Personal information
Business data
Credentials (if you use them)

Local vs Cloud: The Privacy Difference

What Cloud AI Providers See

When using ChatGPT, Claude, or similar:
| Data | Cloud AI |
|--------------------|-----------|
| Conversations | ✓ Stored |
| IP Address | ✓ Logged |
| Usage Patterns | ✓ Tracked |
| Device Info | ✓ Collected |
| Can Be Used for Training | ✓ (with opt-out) |
| May Be Subpoenaed | ✓ Possible |

What Stays Private with OpenClaw

Data	OpenClaw
Conversations	Private (local only)
IP Address	Not shared
Usage Patterns	Private
Device Info	Private
Training	Not applicable
Subpoenas	No external data

Real-World Scenarios

Scenario 1: Proprietary Code

Cloud AI: "Here's how to implement that feature" (your code was processed on their servers)

OpenClaw: "Here's how to implement that feature" (processed locally on your machine)

Scenario 2: Client Work Under NDA

Cloud AI: Potential breach of NDA data on third-party servers

OpenClaw: Safe data never leaves your environment

Scenario 3: Sensitive Conversations

Cloud AI: Stored, could be accessed legally

OpenClaw: Only exists on your encrypted hard drive

OpenClaw Security Features

Encryption

Enable encryption for stored conversations:

security:
  encrypt_history: true
  encryption_key: env:ENCRYPTION_KEY

Conversation history can be encrypted. Key stored in environment variables. Protects against physical access.

Access Control

Control who can access your OpenClaw:

security:
  allowed_users:
    - user_id_1
  require_auth: true
  rate_limit:
    max_requests_per_minute: 30

Network Security

When using Ollama locally:

Server only binds to localhost
Not accessible over network by default
Can configure for local network if needed

Skill Permissions

Skills can request specific permissions:

# skill.yaml
permissions:
  - network    # Can access internet
  - filesystem # Can read/write files
  - execute    # Can run commands

Review permissions before installing skills.

Potential Security Concerns

1. Local Model Security

Concern: Can malicious models steal data?

Mitigation:

Only use trusted model sources (Ollama library)
Verify model hashes when possible
Review model manifest

2. Skill Security

Concern: Could a malicious skill access my data?

Mitigation:

Review skill permissions before installing
Only install from trusted publishers
Check skill source code
Use sandbox mode

Enable skill sandbox:

security:
  skill_sandbox: true

3. Local Network Exposure

Concern: Could others access my OpenClaw?

Mitigation:

Ollama binds to localhost by default
Don't expose to network without authentication
Use firewall rules

4. Physical Access

Concern: Someone could access my data physically?

Mitigation:

Enable disk encryption (FileVault, LUKS)
Use strong login passwords
Enable encrypted conversation storage

5. Memory Attacks

Concern: Could model memory be extracted?

Mitigation:

Models run in RAM, cleared on restart
Don't input secrets into conversations
Use environment variables for API keys

Best Practices

For Personal Use

Enable disk encryption
- macOS: FileVault
- Linux: LUKS
- Windows: BitLocker
Use strong passwords
Keep software updated
Review skill permissions
Don't paste secrets in conversations

For Business Use

Network isolation
Audit logs

logging:
  enabled: true
  level: info
  file: /var/log/openclaw.log

Employee access controls
Incident response plan
Regular security reviews

For Sensitive Work

Air-gapped setup
Encrypted storage only
No cloud integrations
Secure credential management

Use environment variables for sensitive data:

export OPENCLAW_API_KEY="your-key-here"
export GITHUB_TOKEN="ghp_xxx"

Enterprise Considerations

Compliance

OpenClaw can help with compliance requirements:

Requirement	OpenClaw	Cloud AI
GDPR	Easier	Complex
HIPAA	Easier	Requires BAA
SOC 2	Easier	Audit needed
Data residency	✓ Full control	Limited

Deployment Options

Individual workstations

Simplest deployment
Full privacy
Consistent with BYOD

Centralized server

Easier management
Requires network security
Higher maintenance

Containerized

Docker/Kubernetes
Isolated environment
Consistent across deployments

Testing APIs Securely

When building integrations with OpenClaw, you'll likely need to test APIs and webhooks. Apidog provides a secure, local-first approach to API testing that complements OpenClaw's privacy-focused architecture. Unlike cloud-based API tools that send your data to external servers, Apidog can test APIs locally without exposing sensitive data.

Key benefits of using Apidog with OpenClaw:

Test OpenClaw's API endpoints locally
Verify webhook integrations without data leakage
Debug API calls in an isolated environment
Maintain security compliance for sensitive projects

Cost of Security

With cloud AI, security is in someone else's hands. With OpenClaw:

You control everything
You manage security
Hardware costs apply
But no data breach liability

Conclusion

OpenClaw offers a fundamentally different privacy model than cloud AI. Your data stays on your machine, under your control, subject to your security measures.

The privacy advantage is real:

No data sent to external servers
Complete control over storage
No training data concerns
Much simpler compliance

But it's not automatic:

You must secure your machine
Review skill permissions
Use encryption
Follow best practices

For privacy-sensitive work - client projects, proprietary code, regulated industries - OpenClaw's local architecture provides meaningful advantages over cloud alternatives.

FAQ

Does OpenClaw send any data to external servers?

By default, no. Your conversations stay local. However:

If using cloud-based models (not recommended), data may be external
Some skills may have network permissions
Always review skill permissions

Can my conversations be accessed legally?

With cloud AI, yes providers can be subpoenaed. With OpenClaw:

No external data to subpoena
Only local law enforcement with physical access could request
Much harder to compel disclosure

Is OpenClaw safe for client work?

Yes, this is one of its strongest use cases. Your client's code and data never leave your machine. Just ensure:

Your machine is secure
Disk encryption is enabled
No cloud integrations are used

What about the ClawHavoc incident mentioned in other guides?

In early 2026, malicious skills were found on ClawHub. This highlights:

Always review skill permissions
Only install from trusted publishers
Check source code when possible
Use sandbox mode

Can I use OpenClaw for healthcare or legal work?

Yes! Local AI is ideal for sensitive professions. Just ensure:

Your machine meets security requirements
Client data stays local
Proper access controls are in place

What is KiloClaw? The Complete Guide to Your Hosted AI Assistant

Preecha — Fri, 09 Oct 2026 14:03:22 +0000

TL;DR

KiloClaw is a fully hosted version of OpenClaw—the open-source AI agent that became the fastest-growing AI project in history with 230,000+ GitHub stars. It lets you deploy a personal AI assistant in under 60 seconds with access to 500+ AI models, 50+ chat platforms, and enterprise features like auto-restart and team management. No servers, Docker, or configuration required.

Try Apidog today

Introduction

Between Claude's computer use, OpenAI's operators, and GitHub Copilot's agent mode, The AI agent landscape has exploded in 2026, with developers and businesses seeking personal assistants that can actually do things—not just chat and the market is heating up. But one project stood above the rest: OpenClaw, which went from zero to 230,000 GitHub stars in just 10 days, making it the fastest-growing open-source AI project ever.

Now, there's an easier way to use it.

KiloClaw brings the power of OpenClaw to a managed hosting platform, eliminating the headaches of server setup, Docker containers, and manual configuration. Whether you're a developer wanting to automate workflows or a team lead looking for a collaborative AI assistant, KiloClaw offers a compelling alternative to self-hosting.

💡If you're working with multiple AI APIs and need a unified testing platform, Apidog integrates seamlessly with KiloClaw for debugging and monitoring your AI assistant's API calls.

What is OpenClaw?

Before understanding KiloClaw, you need to understand OpenClaw—the open-source project that powers it.

The Origin Story

OpenClaw was created by Peter Steinberger, a developer best known for founding PSPDFKit. What started as a personal project called "Clawdbot" evolved through several name changes (Moltbot, due to trademark concerns with Anthropic) before settling on OpenClaw.

The project went viral in February 2026, gaining:

230,000+ GitHub stars in under two weeks
2 million+ visitors in a single week
Coverage from major tech publications

Peter Steinberger was subsequently hired by OpenAI on February 15, 2026, validating the project's significance in the AI agent space.

Core Capabilities

OpenClaw is your personal AI assistant that runs locally and connects to the tools you already use:

Capability	Description
Multi-Platform Integration	Works with WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Microsoft Teams, Matrix, and 50+ platforms
Shell Command Execution	Runs terminal commands, executes scripts, and automates system tasks
Browser Control	Navigates websites, fills forms, and extracts data
File Management	Reads, writes, and organizes files across your system
Persistent Memory	Stores conversation history and user preferences in Markdown files
Voice Interaction	Supports voice commands on macOS, iOS, and Android
100+ AgentSkills	Pre-built automation capabilities for common tasks

Model Flexibility

OpenClaw isn't tied to a single AI provider. It supports:

Anthropic's Claude (including Claude 3.5 Sonnet, Opus 4)
OpenAI's GPT (GPT-4o, GPT-4 Turbo)
Google's Gemini
Any model accessible via OpenAI-compatible APIs

This model-agnostic approach means you can switch between providers based on cost, capability, or specific task requirements.

Architecture Highlights

The OpenClaw architecture follows a gateway pattern:

A central control plane stays connected to messaging channels
An agent loop processes tasks one at a time for reliability
Plugins extend functionality with JSON-schema definitions
Tools and integrations are added as modular components

This design prioritizes reliability over parallelism—each task completes fully before the next begins.

What is KiloClaw?

KiloClaw is a fully managed hosting service for OpenClaw, launched by Kilo Code (a platform serving 1.5 million+ developers). It takes the powerful OpenClaw agent and handles all the infrastructure complexity for you.

The Value Proposition

Instead of spending 30-60 minutes configuring servers, Docker, and environment variables, you can deploy a production-ready OpenClaw instance in under 60 seconds.

Here's what KiloClaw handles automatically:

Server provisioning and maintenance
Docker container management
Security configuration
Auto-updates
Process monitoring and auto-restart
Unified billing

Why Choose Hosted Over Self-Hosted?

For many users, the self-hosted OpenClaw experience involves:

Technical Setup: Installing Docker, cloning the repository, configuring environment variables
Ongoing Maintenance: Updating the software, monitoring for crashes, managing backups
Security Hardening: Protecting exposed API keys, configuring network access, sandboxing
Platform Management: Setting up webhooks for each chat platform individually

KiloClaw eliminates all of this while adding enterprise features that would be difficult to implement yourself.

Key Features of KiloClaw

1. One-Click Deployment

The flagship feature: deploy your personal AI assistant in under 60 seconds. No SSH, no Docker, no config files. Just visit app.kilo.ai/claw and you're running.

2. 500+ AI Models via Kilo Gateway

Access an enormous selection of AI models through Kilo's unified gateway, including:

Claude models (3.5 Sonnet, Opus 4)
GPT models (4o, Turbo)
Gemini models
open-source models (Llama, Mistral, Qwen)
Specialty models for coding, reasoning, vision

3. 50+ Chat Platforms

Connect your AI assistant to virtually any communication platform:

Category	Platforms
Messaging	WhatsApp, Telegram, Signal, iMessage
Team Chat	Slack, Microsoft Teams, Discord
Social	Twitter/X, Facebook Messenger
Communication	Matrix, RingCentral, Zoom
Email	Gmail, Outlook (via plugins)

4. Scheduled Tasks & Cron Jobs

Automate workflows that run while you sleep:

Daily report generation
Periodic data synchronization
Scheduled notifications
Recurring API health checks

5. Auto-Restart on Crash

If your agent crashes, KiloClaw automatically restarts it. No 3 AM alerts, no manual intervention.

6. Bring Your Own Keys

Prefer to use your own API keys from Anthropic, OpenAI, or Google? KiloClaw supports bringing your existing keys while still using their infrastructure.

7. Unified Billing

Use your existing Kilo Gateway credits across all services. Zero markup on AI tokens—you pay exactly what the model providers charge.

8. Enterprise Features

For teams and organizations:

SSO (Single Sign-On): Integrate with your identity provider
Audit Logs: Track all agent activities for compliance
Team Management: Collaborate with shared configurations

KiloClaw vs Self-Hosted OpenClaw

Feature	KiloClaw (Hosted)	Self-Hosted OpenClaw
Setup Time	Under 60 seconds	30-60+ minutes
Updates	Automatic	Manual (git pull)
AI Models Available	500+ via Kilo Gateway	1 at a time
Bring Your Own Key	✓ Automatic	Manual configuration
Unified Billing	✓	✗
Team Management	✓	✗
SSO	✓ Enterprise	✗
Audit Logs	✓ Enterprise	✗
Auto-restart on Crash	✓	✗ Requires supervisor
Process Monitoring	Built-in	Manual setup
Security	Proxied, sandboxed	Self-configured

When to Choose KiloClaw

Quick deployment: You want to start in minutes, not hours
Team use: You need collaboration and access controls
Enterprise needs: You require SSO and audit compliance
Simplicity: You prefer managed infrastructure over self-hosting

When to Choose Self-Hosted OpenClaw

Full control: You need complete visibility into the stack
Cost optimization: You want to minimize compute costs at scale
Customization: You need to modify the core agent behavior
Privacy: You require data to stay entirely on your infrastructure

Use Cases and Real-World Applications

Personal Productivity

Email management: Automatically categorize, draft responses, and prioritize
Calendar scheduling: Coordinate meetings across time zones
Research automation: Gather and summarize information from multiple sources

Developer Workflows

Code review assistance: Analyze pull requests and suggest improvements
Documentation generation: Auto-generate API docs from code
CI/CD monitoring: Track build status and notify on failures

Business Operations

Customer support: Handle tier-1 inquiries across chat platforms
Data extraction: Pull reports from SaaS tools and compile summaries
Team notifications: Distribute updates across multiple channels

Data Analysis

Market research: Monitor competitors and summarize findings
Sentiment analysis: Track brand mentions across social platforms
Report automation: Generate weekly/monthly business reports

Getting Started with KiloClaw

Step 1: Visit the Dashboard

Navigate to the dashboard and sign in with your Kilo account (or create one).

Step 2: Choose Your Deployment

Select from options:

Quick Start: Deploy with default settings
Custom: Configure specific platforms and models
Import Config: Load your existing OpenClaw configuration

Step 3: Connect Platforms

Select which chat platforms to connect. Each platform requires different authentication:

Telegram: Bot token
Discord: Bot token and server permissions
Slack: OAuth app installation
WhatsApp: QR code pairing

Step 4: Select Your Model

Choose from:

Kilo Gateway models: Access 500+ models with pay-as-you-go pricing

Bring your own key: Use existing Anthropic/OpenAI/Gemini keys

Step 5: Configure Memory

Set up persistent memory options:

Conversation history storage
User preference retention
Context window management

Step 6: Deploy

Click deploy and your KiloClaw instance is live in under 60 seconds.

Pricing and Free Trial

Launch Offer

7 days of free compute for all new users—no credit card required. This gives you ample time to test the platform and evaluate its capabilities.

Ongoing Costs

After the free trial, KiloClaw uses your existing Kilo Gateway credits:

Cost Type	Description
Compute	Charged based on instance running time
AI Tokens	Zero markup—pay exact provider rates
Platform Connectors	Included in compute cost

Enterprise Pricing

For teams requiring SSO, audit logs, and advanced management:

Contact Kilo for custom pricing
Annual contracts available
Volume discounts for large deployments

Security Considerations

Benefits of Managed Hosting

KiloClaw addresses several security concerns that plague self-hosted AI agents:

API Key Protection: Keys are proxied through Kilo's infrastructure, never exposed in your local environment
Network Security: Traffic flows through secure channels with encryption
VM Isolation: Each instance runs in an isolated virtual machine
Sandboxing: Restricts agent actions to intended boundaries

Best Practices Regardless of Deployment

Whether using KiloClaw or self-hosted OpenClaw:

Least privilege: Grant minimum necessary permissions to each platform connector
Audit regularly: Review logs and activity for suspicious behavior
Limit capabilities: Disable platforms and tools you don't need
Monitor usage: Set up alerts for unusual activity patterns

Conclusion

KiloClaw represents a significant step forward in making powerful AI agents accessible to everyone. By taking the revolutionary OpenClaw project—the fastest-growing open-source AI in history—and wrapping it in a managed hosting experience, Kilo has lowered the barrier to entry dramatically.

Whether you're a developer wanting to automate your workflows, a team lead seeking collaborative AI assistance, or a business needing enterprise-grade AI agents, KiloClaw offers a compelling package: 500+ models, 50+ platforms, one-click deployment, and zero markup on AI tokens.

The 7-day free trial makes it risk-free to evaluate. If you've been curious about personal AI assistants but put off by the technical complexity of self-hosting, KiloClaw deserves your attention.

Ready to try KiloClaw? Use Apidog to test and debug the API calls your AI assistant makes. Apidog's unified interface lets you inspect requests, validate responses, and monitor performance—essential for production AI agent deployments.

FAQ

What is KiloClaw?

KiloClaw is a hosted version of OpenClaw that lets you deploy a personal AI assistant in under 60 seconds. It provides access to 500+ AI models and 50+ chat platforms without requiring server configuration or Docker knowledge.

How does KiloClaw differ from OpenClaw?

OpenClaw is the open-source project you self-host, while KiloClaw is a managed hosting service. KiloClaw handles all infrastructure, updates, security, and maintenance— you just click to deploy.

Is KiloClaw free to use?

KiloClaw offers 7 days of free compute for new users. After that, you pay for compute time and AI tokens at Kilo Gateway rates with zero markup on token costs.

What chat platforms does KiloClaw support?

KiloClaw supports 50+ platforms including WhatsApp, Telegram, Discord, Slack, Signal, Microsoft Teams, Matrix, and more.

Can I use my own API keys with KiloClaw?

Yes. KiloClaw supports bringing your own keys from Anthropic, OpenAI, Google, or any OpenAI-compatible API while using Kilo's infrastructure.

Does KiloClaw support enterprise features?

Yes. Enterprise plans include SSO, audit logs, team management, and priority support.

How long does deployment take?

KiloClaw deploys in under 60 seconds with no configuration required.

Is KiloClaw secure?

KiloClaw provides security features including proxied API keys, VM isolation, network security, and sandboxing—addressing common concerns with self-hosted AI agents.

APIDOG February Updates: Enhanced MCP Debugging, Parallel Testing & Shared Data

Preecha — Fri, 09 Oct 2026 02:03:02 +0000

Building on January's foundation, February doubles down on the MCP and testing experience—delivering richer debugging insights, parallel execution for Test Suites, cross-scenario shared test data, a completely redesigned test report, and seamless Hoppscotch migration.

Try Apidog today

Hello Apidog Users,

January introduced the MCP Client and Test Suites. February is about making them production-ready.

We have refined the MCP debugging experience with richer content previews—Markdown rendering, image display, and direct Content field access. Test Suites now support parallel execution for dramatically faster regression runs. A new Shared Test Data system eliminates redundant data setup across scenarios. And the test report has been completely redesigned from the ground up with structured step display and failure filtering.

On top of that, we have shipped Hoppscotch Collection import, SSE debugging improvements, and a long list of quality-of-life fixes across eight releases this month.

Here is everything new this month👇

⭐ New Updates

🔥 Refined MCP Client Debugging Experience

When debugging MCP Servers with Apidog's built-in MCP Client, the response viewing experience has been comprehensively upgraded with more convenient content preview and verification capabilities.

1. Direct Content Field Viewing

When debugging an MCP Server in Apidog, you can now view the response Content field directly in the "Content" tab—no more digging through raw JSON to find what you need. The "Raw" tab still provides the full JSON-RPC payload for deep inspection, giving you the best of both worlds depending on your debugging context.

2. Markdown Rendering Preview

When an MCP response contains Markdown content, you can now toggle between raw Markdown and a rendered preview. This makes it easy to visually verify formatted documentation, README content, or any structured text returned by your MCP tools—without leaving the debugger.

{
  "content": "# Hello, World!",
  "type": "markdown"
}

3. Image Preview

Images in MCP responses are now rendered directly in the "Preview" tab, allowing developers to quickly verify image content and format without external tools. This is particularly useful when debugging MCP tools that return screenshots, charts, or generated visuals.

Together, these three improvements transform the MCP Client from a raw protocol inspector into a full-fidelity debugging environment—one where you can see exactly what your AI agents see.

🚀 Test Suites: Parallel Execution & Environment-Aware Scheduling

Building on January's Test Suite launch, we are adding two capabilities that make orchestration significantly more powerful.

Parallel Execution Mode

Test Suites now support a "Parallel" run mode, allowing multiple test cases and scenarios to execute concurrently. You can flexibly configure parallel execution rules to dramatically reduce overall test time—especially valuable for large-scale regression suites where sequential execution becomes a bottleneck.

Mode Comparison:

Mode	Behavior
Sequential	Scenarios run in order. Variables persist and propagate across scenario steps—ideal for dependent workflows.
Parallel	Multiple scenarios run concurrently for maximum speed. Note: concurrency isolates context between scenarios—cases that depend on upstream variables may need to be restructured.

Note: Actual speedup depends on the available hardware resources of the machine running the tests.

Scheduled Tasks Now Support Environment Selection

When creating scheduled tasks for Test Suites, you can now select the target environment, enabling precise control over automated execution across different environments (e.g., staging, production). This means you can schedule the same suite to run against multiple environments on different cadences—a critical capability for teams managing multi-stage deployment pipelines.

🆕 Shared Test Data: Cross-Scenario Reusability

A brand-new capability in this release: Shared Test Data. You can now create common test datasets that are reusable across multiple test scenarios, fundamentally changing how teams manage test data at scale.

Why This Matters:

Previously, each test scenario maintained its own isolated test data. If ten scenarios needed the same user credentials, payment details, or product catalog, you had to duplicate that data ten times—and maintain it in ten places.

Shared Test Data solves this by introducing a centralized data layer:

Create once, use everywhere: Define a dataset once and reference it from any test scenario in your project.
Single source of truth: Update the shared data in one place, and every scenario that references it picks up the change automatically.
Standardized testing: Ensures all scenarios test against consistent, validated data—eliminating subtle discrepancies caused by copy-paste drift.

This is especially powerful when combined with the new parallel execution mode, as shared data provides a stable foundation for concurrent test runs.

📊 Test Reports: Complete Redesign

The test report experience has been rebuilt from the ground up this month, delivered across two releases (v2.8.4 and v2.8.11).

Structured Step Display (v2.8.4)

The entire test report UI has been redesigned to support structured display of all test steps. Instead of a flat log, you now see a hierarchical view that mirrors the actual execution flow—making it immediately clear which scenario, case, and step produced each result. The test report list has also been optimized with structured display and filtering capabilities.

Failed Case Filtering (v2.8.11)

Building on the redesigned foundation, we have added a failed case filter and step-level detail inspection, helping you quickly zero in on failures and understand exactly what went wrong at each step.

The report intelligently adapts its display based on your viewing context:

Viewing all steps: Presented in a tree structure that clearly shows step hierarchy and execution context.
Filtering failed cases: Automatically switches to a flat list that aggregates all failed steps for rapid issue identification.

The combination of structured display and smart filtering means you can go from "the suite failed" to "here's the exact assertion that broke" in seconds rather than minutes.

🔗 Hoppscotch Collection Import

For teams migrating from Hoppscotch, Apidog now supports direct import of Hoppscotch Collections. Simply export your collections from Hoppscotch and import them into Apidog—your endpoints, parameters, headers, and request bodies are preserved, making the transition seamless.

This joins our existing import support for Postman, Swagger/OpenAPI, Insomnia, and other formats, reinforcing Apidog's position as a universal API platform that meets you where you are.

⚡️ Optimizations

Beyond the headline features, we have shipped a series of quality-of-life improvements:

Protected Branch UI: Redesigned the protected branch interaction for a cleaner, more intuitive workflow.
Preset Common Fields UX: Improved the interface for applying preset common fields to endpoints, reducing friction in schema reuse.
crypto Global Object in Scripts: Pre and post processor scripts now support the crypto global object, enabling cryptographic operations (hashing, HMAC, encryption) directly in your test scripts without external dependencies.
SSE Debugging: When debugging SSE (Server-Sent Events) endpoints, Apidog now correctly handles \r\n line breaks, ensuring accurate event stream parsing.
Project Invitation Flow: Optimized the process of inviting collaborators to join a project, making team onboarding smoother.
Test Report List: The test report list view now supports structured display and filtering, making it easier to navigate large test histories.

🐞 Bug Fixes

We resolved a total of 17 bugs across eight releases this month. Here are the highlights:

Testing & Automation:

Fixed an issue where the loop count displayed as 0 in test reports when using {{variable}} as the iteration count in automated tests.
Fixed an issue where response validation could not be configured when batch-running test data from the test case page.
Fixed an issue where custom request endpoints would occasionally not include auth during automated test scenario execution if the endpoint did not switch to auth.

Data Import & Export:

Fixed an issue where RAML files could not be imported into Apidog.
Fixed an issue where Hoppscotch Collections failed to import in certain cases.
Fixed an issue where generating SQL code from a schema did not use the schema name as the table name, resulting in all table names being tableName.

Endpoint & Debugging:

Fixed an issue where the response content of Socket endpoints was not formatted.
Fixed an issue where the header parameter input field would lose focus after typing the first character when the field name was in English.
Fixed an issue where directly saving a quick request under a subfolder would incorrectly move it to the root folder (v2.8.9).
Fixed an issue where renaming a quick request would occasionally not be saved.

Platform & Governance:

Fixed a 500 error that occurred in certain cases when configuring custom roles at the organization level.
Fixed an issue where deleted branches did not release SEO custom URL slug bindings from endpoints.
Fixed URL validation in published documentation navigation configuration.

🌟 Looking Ahead

February's eight releases reflect our commitment to shipping fast and iterating on feedback. As we move into March, we are continuing to deepen the MCP debugging experience, expand Test Suite orchestration capabilities, and invest in the AI-native workflows that will define the next generation of API development.

We are also actively working on deeper Git integrations and text-mode editing to align with git-first development habits—stay tuned.

💬 Join the Conversation

Connect with fellow API engineers and the Apidog team:

Join our Discord community for real-time discussions.
Participate in our Slack community for technical deep dives.
Follow us on X (Twitter) for the latest updates.

P.S. Explore the complete details of all these updates in the Apidog Changelog! 🚀

Happy API Building!

Best Regards,

The Apidog Team

Scale with Test Suites: High-performance organization for automated API testing

Preecha — Thu, 08 Oct 2026 14:01:46 +0000

Hey, Apidog users! 👋 Over the past year, we've built a comprehensive automated testing platform around Test Scenarios—reusable workflow sequences that chain multiple API requests into complete business flows. Test Scenarios solve the "how to test" problem, but we've heard consistent feedback from teams about a different challenge: "how to organize what to test."

Try Apidog today

Teams tell us they have hundreds of test cases organized by business modules, but when it's time for release regression, they only want to run their P0 cases—not everything. Currently, they have to manually search and select each one. Others maintain both positive and negative test cases but want smoke tests to only cover positive flows. And when new cases are added, they're often forgotten in regression lists.

Today, we're introducing Test Suites: a new resource type that lets you organize and execute tests by rules rather than by individual selection. Here's how to implement these capabilities in your workflow:

Dynamic Test Routing

Problem: Need to run all P0 cases in the payment module without manual selection.

Solution:

Create a new Test Suite in the Automated Testing module
Select "Dynamic Mode"
Set conditions: Directory = "Payment" AND Priority = P0
Run the suite—all matching cases execute automatically

// Example: CLI command to trigger suite
apidoq run-suite --suite-id payment_p0 --env production

Key benefits:

New test cases matching your conditions auto-include
Avoid maintaining static regression lists
Works with AI-generated tests

Implementation options:

Mode	Configuration	Best For
Static	Manual case selection	Smoke tests (5-15 stable cases)
Dynamic	Rule-based inclusion	Module regression (changing case counts)

Parallel Execution

Problem: Hour-long serial test runs delay releases.

Solution:

Open suite configuration
Toggle "Parallel Execution" on
System auto-optimizes concurrency
Typical results: 60m → 30m runs

Pro tip: Group dependent steps within a single Test Scenario using sequential requests.

Structured Test Reports

Actionable steps:

Run any test suite
View grouped results by:
- Module
- Priority
- Tags
Failed cases surface automatically
Expand groups for details

# Sample CI/CD integration
apidoq run-suite --suite-id smoke_test --report-format junit > results.xml

Configuration Management

Default behavior: Each scenario uses its saved config
Environment override: Set one env for all scenarios
Full override: Advanced settings for custom configs

Practical Use Cases

Scenario	Implementation
Smoke tests	Static suite with 5-15 critical cases
Module regression	Dynamic suite filtered by directory + priority
Production monitoring	Scheduled suite with health check tag

Current Limitations:

No suite nesting (but dynamic mode covers most needs)
No auto-retry (avoids masking real failures)

Get Started Now

Navigate to Automated Testing → Test Suites
Click "New Test Suite"
Configure using the workflow above
Integrate with CI/CD:

# GitHub Actions example
- name: Run Regression Suite
  run: apidoq run-suite --suite-id full_regression

Join our community for advanced techniques:

See the Apidog Changelog for latest updates!

How to Use KiloClaw (OpenClaw alternative) ?

Preecha — Wed, 07 Oct 2026 02:04:54 +0000

TL;DR

This guide walks you through deploying and using KiloClaw in 6 simple steps: sign up at app.kilo.ai/claw, choose your deployment type, connect chat platforms (Telegram, Discord, Slack, etc.), select your AI model, configure memory settings, and start using your AI assistant. The entire process takes under 60 seconds, and new users get 7 days of free compute.

Introduction

You've heard about KiloClaw, the hosted version of OpenClaw that's taken the AI agent world by storm. With 230,000+ GitHub stars and the ability to connect to 50+ platforms, it's never been easier to deploy a personal AI assistant.

In this tutorial, we'll walk through the entire process of setting up KiloClaw from scratch. By the end, you'll have a fully functional AI assistant connected to your preferred chat platforms, ready to help with automation, research, and productivity tasks.

💡As you build AI agent workflows, Apidog is invaluable for testing and debugging the API calls your assistant makes. Save time debugging with Apidog's unified request inspector.

Try Apidog today

Prerequisites

Before you begin, ensure you have:
| Requirement | Description |
|--------------------------|---------------------------------------------------|
| Kilo Account | Sign up at app.kilo.ai (free) |
| Chat Platform Account | At least one of: Telegram, Discord, Slack, etc. |
| AI API Key (optional) | Anthropic, OpenAI, or Google key if bringing your own |
| Web Browser | Chrome, Firefox, Safari, or Edge |

That's it. No server, no Docker, no command line required.

Step 1: Create Your KiloClaw Account

Navigate to KiloClaw

Open your browser and visit https://app.kilo.ai/claw

You'll see the KiloClaw landing page with the option to sign in or create an account.

Sign Up Process

Click "Get Started" or "Sign Up"
Choose your sign-up method:
- Email + password
- Google account
- GitHub account

Complete the verification (email or OAuth)

Account Setup

After signing up, you'll land on the Kilo dashboard. If you're new to Kilo:

Enter your name or display name
(Optional) Add a profile photo
Accept terms of service

You're now ready to create your first KiloClaw instance.

Step 2: Choose Your Deployment Type

KiloClaw offers three deployment options to match your experience level:

Option A: Quick Start (Recommended for Beginners)

The fastest path to a running assistant:

✓ Pre-configured defaults

✓ All popular platforms enabled

✓ Default model selected

✓ Standard memory settings

Time to deploy: ~30 seconds

Option B: Custom Deployment

For users who know what they want:

Platform Selection: Choose specific platforms to connect
Model Selection: Pick your preferred AI model(s)
Memory Configuration: Set conversation history limits
Capability Tuning: Enable/disable specific AgentSkills

Time to deploy: ~60 seconds

Option C: Import Configuration

For existing OpenClaw users:

Export your config from self-hosted OpenClaw
Upload the configuration file
KiloClaw maps settings to hosted environment

Time to deploy: ~45 seconds

Recommendation: Start with Quick Start to see KiloClaw in action, then customize later.

Step 3: Connect Chat Platforms

This is where KiloClaw shines, connecting your AI assistant to the platforms you already use.

Supported Platforms

Platform	Authentication	Setup Time
Telegram	Bot token	2 min
Discord	Bot token + server invite	3 min
Slack	OAuth installation	3 min
WhatsApp	QR code pairing	2 min
Microsoft Teams	OAuth + admin consent	5 min
Signal	Phone number + verification	2 min
Matrix	Access token	3 min

Platform Setup Walkthrough

Telegram (Most Popular)

In KiloClaw dashboard, click "Add Platform" → "Telegram"
Open Telegram and message @botfather
Create a new bot: /newbot
Copy the bot token
Paste token into KiloClaw
Click "Connect"
Start chatting with your bot!

Telegram bot token format: 1234567890:ABCdefGHIjklMNOpqrsTUVwxyz

Discord

Go to Discord Developer Portal
Create a new application
Add a bot to your application
Copy the bot token
In KiloClaw, paste token and specify server
Set required permissions:
- Read messages
- Send messages
- Manage messages (optional)
Generate invite link and add bot to server

Slack

Create a Slack app at api.slack.com
Enable Bot Token Scopes:
- chat:write
- channels:read
- im:write
Install app to your workspace
Copy Bot User OAuth Token
Paste into KiloClaw

Connecting Multiple Platforms

KiloClaw supports connecting to multiple platforms simultaneously. Your AI assistant will be accessible across all connected channels:

Example setup:

├── Telegram: @MyAIAssistant

├── Discord: #ai-assistant in MyServer

├── Slack: @ai-assistant in workspace

└── WhatsApp: +1-555-AI-HELP

All platforms share the same memory and context, magic!

Step 4: Select Your AI Model

KiloClaw gives you flexibility in choosing how your assistant thinks.

Option A: Kilo Gateway Models

Access 500+ models through Kilo's unified gateway:
| Model Category | Examples | Best For |
|----------------|--------------------------------------|----------------------------|
| Reasoning | Claude 4 Opus, GPT-4.5 | Complex problem-solving |
| Balanced | Claude 3.5 Sonnet, GPT-4o | General tasks |
| Fast | GPT-4o-mini, Claude 3 Haiku | Quick responses |
| Coding | Claude 4.5 Code, Codex | Development tasks |
| Vision | Claude 4 Vision, GPT-4V | Image understanding |

Pricing: Pay-per-token at Kilo Gateway rates (no markup)

Option B: Bring Your Own Key

Use existing API keys:

Click "Bring Your Own Key"
Select provider: Anthropic, OpenAI, or Google
Paste your API key
Choose model(s) from that provider
Save

Your API key is securely stored and proxied through Kilo's infrastructure; it never touches your local environment.

Model Selection Tips

Start with Claude 3.5 Sonnet: Excellent balance of capability and cost
Switch per-task: Create different configurations for different use cases
Use fast models for simple tasks: Save Opus/GPT-4 for complex reasoning

Step 5: Configure Memory and Preferences

One of KiloClaw's most powerful features is persistent memory; your assistant remembers context across sessions.

Memory Settings

Setting	Description	Default
Conversation History	How many messages to retain	100
User Preferences	Remember user settings	Enabled
Context Window	How much context per request	Provider limit
Memory Format	Markdown files for persistence	Enabled

Custom Instructions

Set system prompts that define your assistant's behavior:

You are a helpful AI assistant specialized in:

Software development and code review

Research and fact-finding

Drafting emails and documents

Be concise, accurate, and proactive. When unsure, ask clarifying questions.

Privacy Controls

Configure what your assistant can access:

Read access: Which platforms can it read from?
Write access: Which platforms can it respond on?
Tool access: Which capabilities are enabled?
Data retention: How long is history kept?

Step 6: Deploy and Start Using

Launch Your Instance

With all settings configured:

Click "Deploy KiloClaw"
Wait for provisioning (~30 seconds)
See "Instance Running" status
Start chatting!

First Conversation

Send a message on any connected platform:

You: Hello! What can you help me with?

KiloClaw: Hi! I'm your personal AI assistant. I can help with:

Research and information gathering

Drafting emails, documents, and code

Scheduling and reminders

Automation across your connected apps

And much more!

What would you like help with today?

Using Your KiloClaw AI Assistant

Now that it's running, here are the ways you can interact:

Basic Commands

Command	Description
`help`	Show available commands
`status`	Display current configuration
`memory`	Show what the assistant remembers about you
`reset`	Clear conversation history

Task Examples

Research Task

You: Can you research the latest developments in AI agents and summarize the key trends?

KiloClaw: [Conducts web research, synthesizes findings, presents summary]

Code Assistance

You: Write a Python function to fetch data from a REST API with error handling.

KiloClaw: [Provides well-commented code with proper error handling]

Automation

You: Remind me to review pull requests every day at 9 AM.

KiloClaw: [Sets up scheduled reminder task]

Voice Interaction

If enabled, talk to your assistant:

macOS: Native integration via system microphone
iOS/Android: Mobile app integration
Phone: Twilio integration for voice calls

Advanced Configuration

AgentSkills (100+ Pre-built Capabilities)

KiloClaw includes pre-configured skills for common tasks:
| Category | Skills |
|---------------|---------------------------------------|
| Development | Code review, debugging, documentation |
| Productivity | Calendar, email, note-taking |
| Research | Web search, data extraction |
| Automation | Scheduled tasks, webhooks |
| Communication | Drafting, translation, summarization |

Enable/disable skills in dashboard settings.

Custom Tools

For advanced users, add custom capabilities:

Create tool definition in JSON schema format
Implement tool logic (Python, JavaScript)
Register tool in KiloClaw dashboard
Start using in conversations

Webhooks

Connect KiloClaw to external services:

{
  "trigger": "new_lead_form",
  "action": "notify_slack",
  "payload": "{{form_data}}"
}

Scheduling Automated Tasks

KiloClaw supports cron-style scheduling for recurring tasks.

Setting Up a Scheduled Task

Go to "Automation" → "Scheduled Tasks"
Click "Add Task"
Configure:

Field            | Example  
Name             | Daily Standup Summary  
Schedule         | 0 9 * * 1-5 (Weekdays 9 AM)  
Action           | Run defined workflow  
Notification     | Post to Slack #standup

Common Scheduled Automations

Daily briefings: Summarize calendar, emails, tasks
Weekly reports: Compile analytics and metrics
Monitoring: Check API health, alert on failures
Data sync: Pull/push data between services

Cron Expression Reference

┌───────────── minute (0-59)
│ ┌───────────── hour (0-23)
│ │ ┌───────────── day of month (1-31)
│ │ │ ┌───────────── month (1-12)
│ │ │ │ ┌───────────── day of week (0-6)
│ │ │ │ │
* * * * *

Managing Your Instance

Dashboard Controls

From the KiloClaw dashboard:
| Action | Description |
|-------------|----------------------------------------|
| Start/Stop | Pause or resume your instance |
| Restart | Force restart (fixes most issues) |
| View Logs | See activity and error logs |
| Update | Apply latest KiloClaw version |
| Delete

KiloClaw vs OpenClaw: What's the Difference?

Preecha — Tue, 06 Oct 2026 14:01:43 +0000

TL;DR

KiloClaw is the hosted version of OpenClaw, you get the same powerful AI agent capabilities but with zero infrastructure management. KiloClaw deploys in under 60 seconds with 500+ AI models and 50+ platform integrations. OpenClaw is free and self-hosted, giving you full control but requiring Docker, server setup, and manual maintenance. Choose KiloClaw for simplicity and team features; choose OpenClaw for maximum control and cost optimization at scale.

Introduction

If you've been following the AI agent space in 2026, you've likely heard of OpenClaw, the open-source project that became the fastest-growing AI project in history, amassing 230,000+ GitHub stars in under two weeks. Created by Peter Steinberger (now at OpenAI), OpenClaw lets you run a personal AI assistant that connects to the tools and platforms you use daily.

But here's the catch: OpenClaw is designed to be self-hosted. That means you need Docker, a server, and some technical know-how to get it running. That's where KiloClaw comes in.

Try Apidog today

What is OpenClaw?

OpenClaw is an open-source AI agent that went viral in February 2026. It started as a personal project called "Clawdbot" and evolved through several name changes (Moltbot, due to trademark concerns with Anthropic) before settling on OpenClaw.

Key Capabilities

OpenClaw functions as your personal AI assistant that runs locally and connects to the tools you already use:

Capability	Description
Multi-Platform Integration	Works with WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Microsoft Teams, Matrix, and 50+ platforms
Shell Command Execution	Runs terminal commands, executes scripts, and automates system tasks
Browser Control	Navigates websites, fills forms, and extracts data
File Management	Reads, writes, and organizes files across your system
Persistent Memory	Stores conversation history and user preferences in Markdown files
Voice Interaction	Supports voice commands on macOS, iOS, and Android
100+ Agent Skills	Pre-built automation capabilities for common tasks

Model Support

OpenClaw supports multiple AI providers:

Anthropic's Claude (including Claude 3.5 Sonnet, Opus 4)
OpenAI's GPT (GPT-4o, GPT-4 Turbo)
Google's Gemini
Any model accessible via OpenAI-compatible APIs

The Trade-off

OpenClaw is free to use, but you're responsible for:

Server infrastructure (local machine or cloud VPS)
Docker installation and configuration
Ongoing maintenance and updates
Security hardening
Process monitoring (to restart if it crashes)

# Example OpenClaw docker-compose.yml setup
version: '3'
services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:latest
    environment:
      OPENAI_API_KEY: your-key-here
      CLAUDE_API_KEY: your-key-here
      PLATFORM_TOKENS: whatsapp=your-token,slack=your-token
    volumes:
      - ./config:/config
    ports:
      - "3000:3000"

What is KiloClaw?

Core Value Proposition

Instead of spending 30-60 minutes configuring servers, Docker, and environment variables, you can deploy a production-ready OpenClaw instance in under 60 seconds.

Here's what KiloClaw handles automatically:

Server provisioning and maintenance
Docker container management
Security configuration
Auto-updates
Process monitoring and auto-restart
Unified billing through Kilo Gateway

Additional Features

KiloClaw includes several enhancements over the base OpenClaw:

500+ AI Models via Kilo Gateway: Access an enormous selection including Claude, GPT, Gemini, and open-source models
Enterprise Features: SSO, audit logs, team management
Scheduled Tasks: Automate workflows with cron jobs
Bring Your Own Keys: Use existing Anthropic/OpenAI/Gemini keys

Feature-by-Feature Comparison

Feature	KiloClaw (Hosted)	OpenClaw (Self-Hosted)
Setup Time	Under 60 seconds	30-60+ minutes
AI Models Available	500+ via Kilo Gateway	1 at a time (manual switch)
Platform Integrations	50+ pre-configured	50+ (manual setup each)
Auto-Restart on Crash	✓ Built-in	✗ Requires supervisor/supervisord
Updates	Automatic	Manual (git pull + rebuild)
Process Monitoring	Built-in	Manual setup
Team Management	✓	✗
SSO	✓ Enterprise	✗
Audit Logs	✓ Enterprise	✗
Scheduled Tasks	✓ Built-in	✗ Requires separate setup
Bring Your Own Keys	✓ Automatic	Manual configuration
Unified Billing	✓ Via Kilo Gateway	✗
Cost	Compute + token costs	Free (you pay for infrastructure)

Pricing Comparison

KiloClaw Pricing

Tier	Features	Cost
Free Trial	7 days of compute	Free (no credit card)
Standard	Pay-as-you-go compute + AI tokens	Usage-based
Enterprise	SSO, audit logs, team management	Custom pricing

AI token costs have zero markup - you pay exactly what the model providers charge.

OpenClaw Costs

Item	Cost
Software	Free (open-source)
Server/Cloud	$5-50/month (VPS or cloud VM)
AI API Keys	Pay directly to Anthropic/OpenAI/Google
Electricity (local)	Minimal

Setup and Deployment

KiloClaw Deployment (60 seconds)

Visit app.kilo.ai/claw
Choose deployment type (Quick Start or Custom)
Select chat platforms to connect
Choose AI model (Kilo Gateway or bring your own key)
Click Deploy

OpenClaw Deployment (30-60 minutes)

Install Docker on your machine or VPS
Clone the repository:

   git clone https://github.com/openclaw/openclaw.git

Configure environment variables
Generate platform tokens
Build and run:

   docker-compose up -d

When to Choose Which

Choose KiloClaw If:

You need deployment in under 60 seconds
You want auto-updates and monitoring
You need team features or enterprise SSO

Choose OpenClaw If:

You require full control over your infrastructure
Data must stay entirely on-premises
You're cost-optimizing at scale

Migration Path

From KiloClaw to OpenClaw:

Export your configuration
Set up Docker environment
Import configuration into OpenClaw

From OpenClaw to KiloClaw:

Document your current config
Create KiloClaw account
Replicate settings in dashboard

FAQ

Can I use both KiloClaw and OpenClaw together?

Yes, many users run OpenClaw for critical workflows and KiloClaw for convenience.

How do I debug API calls?

Use tools like Apidog to inspect requests and responses.

What if I need custom integrations?

OpenClaw allows direct code modifications, while KiloClaw supports webhooks and custom actions.

Conclusion

Key decision factors:

Time vs Control: KiloClaw saves hours, OpenClaw gives full control
Team Needs: KiloClaw offers team features out of the box
Cost Structure: OpenClaw is cheaper at scale, KiloClaw has lower startup cost

For most developers, starting with KiloClaw's free trial provides the fastest way to test AI agent capabilities.

What is Nano Banana 2?

Preecha — Tue, 06 Oct 2026 02:04:08 +0000

TL;DR

Google Nano Banana 2 (officially Gemini 3.1 Flash Image) is Google's latest AI image generation model launched on February 26, 2026. It delivers Pro-quality images at Flash speeds, with improved text rendering, subject consistency for up to 5 characters, and resolution options from 512px to 4K. Available through the Gemini app, Gemini API, AI Studio, and Vertex AI, with free tier limitations and Pro/Ultra subscribers getting Nano Banana Pro access. All images include SynthID watermarks for content verification.

Introduction

Google launched Nano Banana 2, the successor to the viral AI image generator that captured developer attention in 2025. This latest model promises Pro-quality output at Flash speeds, directly challenging OpenAI's DALL-E, ByteDance's Seedance, and Adobe's Firefly.

For developers and businesses, the question isn't just "what's new", it's "how can I integrate this into my workflow?" Understanding Nano Banana 2's capabilities, API access, and limitations is essential for anyone building applications that generate images programmatically.

Whether you're building a marketing platform, creating automated content tools, or integrating AI image generation into your product, this guide covers everything you need to know about Google's latest AI image model.

Try Apidog today

💡When integrating AI image generation APIs like Gemini's Nano Banana 2, using a robust API testing tool like Apidog helps you debug requests, manage environment variables, and automate image generation workflows efficiently.

What is Nano Banana 2?

Nano Banana 2 is Google's newest AI image generation model, officially named Gemini 3.1 Flash Image. It represents a significant upgrade to the original Nano Banana model that launched in August 2025 and quickly became one of the most discussed AI image generators in the developer community.

The "Nano Banana" naming originated from Google's internal codename system and became the public moniker that stuck, much to the amusement of the tech community. The name itself went viral on social media, with developers sharing banana-themed AI-generated images as a sort of inside joke.

Why the Name Matters

The Nano Banana branding has become synonymous with accessible, high-quality AI image generation. By retaining the name for the successor model, Google signals continuity while emphasizing that this is an evolution of a proven product rather than an entirely new direction.

The Technology Behind Nano Banana 2

Built on the Gemini 3.1 architecture, Nano Banana 2 leverages advanced world knowledge pulled from Google's massive data repositories. This means the model understands real-world objects, contexts, and relationships better than many competing image generators, resulting in more accurate, contextually appropriate outputs.

The model integrates seamlessly with other Gemini capabilities, allowing for multi-modal workflows where you can combine text generation, image understanding, and image creation in a single pipeline.

Key Features and Capabilities

Nano Banana 2 brings several significant improvements over its predecessor. Let's break down the key capabilities:

1. Speed and Performance

The "Flash" in Gemini 3.1 Flash Image isn't just marketing, generation speeds are noticeably faster than the original Nano Banana. This makes it practical for real-time applications where users expect instant results, such as:

Live content customization
Interactive design tools
E-commerce product visualization
Social media content creation

2. Advanced World Knowledge

Unlike standalone image generators, Nano Banana 2 taps into Gemini's vast knowledge base. This enables:

Accurate object rendering: The model understands how real-world objects look, function, and relate to each other
Current events knowledge: Can incorporate recent events, products, and cultural references when appropriate
Geographic accuracy: Buildings, landmarks, and locations are rendered correctly

3. Improved Text Rendering

One of the biggest weaknesses of AI image generators has been text rendering, creating readable text within images. Nano Banana 2 significantly improves this capability, making it viable for:

Marketing mockups and advertisements
Greeting cards and invitations
Infographics with labels
Product designs with typography
Social media graphics

4. Subject Consistency

For workflows requiring multiple images of the same character or object, Nano Banana 2 offers impressive consistency:

Character consistency: Maintains resemblance for up to 5 characters in a single workflow
Object fidelity: Preserves fidelity of up to 14 objects across multiple generations
Style consistency: Keeps visual style uniform across image sequences

This is particularly valuable for:

Comic and storyboard creation
Product catalog generation
Brand asset development
Character design iteration

5. Resolution and Aspect Ratios

Nano Banana 2 supports a wide range of output options:

Resolution	Use Case
512px	Thumbnails, previews, social posts
1024px	Web content, presentations
2048px	Print-ready, high-quality digital
4K	Large format, professional use

Aspect ratios include standard options (1:1, 4:3, 16:9, 9:16) plus custom configurations.

6. Content Authentication

All images generated with Nano Banana 2 include:

SynthID watermarks: Google's invisible watermarking technology for AI-generated content
C2PA Content Credentials: Industry-standard provenance metadata

This addresses growing concerns about AI-generated content authenticity and positions Nano Banana 2 for use cases where provenance matters, such as news, journalism, and regulated industries.

Nano Banana 2 vs Original Nano Banana

If you're already using the original Nano Banana, here's what's new in version 2:

Feature	Original Nano Banana	Nano Banana 2
Generation Speed	Fast	2x faster
Text Rendering	Basic	Significantly improved
Character Consistency	2 characters	5 characters
Object Fidelity	6 objects	14 objects
Max Resolution	2048px	4K
World Knowledge	Static training data	Real-time Gemini integration
Content Authentication	SynthID only	SynthID + C2PA

The improvements are substantial enough that if you're on the original model, upgrading to Nano Banana 2 is strongly recommended for most use cases.

How to Access Nano Banana 2

Google has made Nano Banana 2 available through multiple channels, giving developers flexibility in how they integrate it:

1. Gemini App (Consumer)

The easiest way to try Nano Banana 2 is through the Gemini mobile and web apps. Simply update to the latest version and look for the image generation feature.

Access: Free (with limitations)

Best for: Quick experiments, casual use, learning the model capabilities

2. Google Search

Nano Banana 2 is integrated directly into Google Search through:

AI Mode: Conversational image generation within search
Google Lens: Image generation from visual input

Access: Available to all Google users

Best for: Quick queries, visual research

3. Google AI Studio

For developers wanting to experiment with the API before building integrations:

Web-based playground
Easy API key generation
Usage tracking and limits
Prompt experimentation tools

Access: Free tier unavailable, requires Google account

Best for: Prototyping, learning, small projects

4. Gemini API (Programmatic)

The primary integration pathway for applications:

REST API access
Streaming responses
Full parameter control
Production usage

Access: API key required, usage-based pricing

Best for: Application integration, production systems

5. Vertex AI (Enterprise)

For enterprise customers needing advanced features:

Custom model fine-tuning (future)
Advanced security and compliance
Dedicated infrastructure
Comprehensive analytics

Access: Google Cloud customers

Best for: Enterprise applications, regulated industries

6. Google Antigravity

A newer platform for accessing Google's AI capabilities:

Simplified access
Competitive pricing
Developer-focused features

Access: API key required

Best for: Developers seeking alternatives to Vertex

7. Google Flow

Google's video editing tool now uses Nano Banana 2 as the default image model, enabling:

AI-powered video generation
Storyboarding
Asset creation for video projects

Access: Included with Google subscription

Best for: Video content creators

Integrating Nano Banana 2 API with Apidog

For developers building applications that use Nano Banana 2, proper API testing and management is crucial. Here's how to integrate and test the Gemini image generation API using Apidog:

Prerequisites

Before you begin, you'll need:

A Google Cloud account
API key from Google AI Studio or Gemini API
Apidog installed (or use the web version)

Step 1: Set Up Your Apidog Workspace

Create a new workspace for your image generation project:

# Open Apidog and create a new workspace
# Name: "Nano Banana 2 Integration"
# Description: "Gemini image generation API testing"

Step 2: Configure Environment Variables

Store your API key securely using Apidog's environment variables:

Environment: Development
Variable: GEMINI_API_KEY
Value: your_api_key_here

Pro Tip: Never hardcode API keys in your requests. Use Apidog's environment variables to keep your credentials secure.

Step 3: Create Your First Image Generation Request

Here's how to structure a basic image generation request in Apidog:

Endpoint: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:predict

Method: POST

Headers:

Authorization: Bearer {{GEMINI_API_KEY}}
Content-Type: application/json

Request Body:

{
  "prompt": "A modern minimalist office workspace with a banana-shaped desk lamp, 4k quality, natural lighting",
  "number_of_images": 1,
  "aspect_ratio": "16:9",
  "resolution": "1024x1024",
  "negative_prompt": "blurry, low quality, distorted",
  "safety_filter_level": "block_medium_and_above"
}

Step 4: Test the Request

Click "Send" in Apidog to test your request. You should receive a response containing:

{
  "predictions": [
    {
      "image": {
        "mimeType": "image/png",
        "data": "base64_encoded_image_data..."
      },
      "generated_image_id": "img_abc123",
      "metadata": {
        "prompt": "A modern minimalist office workspace...",
        "seed": 12345,
        "finish_reason": "SUCCESS"
      }
    }
  ],
  "metadata": {
    "model_version": "gemini-3.1-flash-image-v2",
    "processing_time_ms": 1250,
    "content_authenticity": {
      "synthID": "enabled",
      "c2pa": "enabled"
    }
  }
}

Step 5: Build Automated Test Suites

Create automated tests in Apidog to ensure your image generation pipeline works reliably:

// Apidog test script
pm.test("Successful image generation", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.predictions).to.have.property('image');
    pm.expect(jsonData.predictions[0].metadata.finish_reason).to.eql('SUCCESS');
});

pm.test("Content authenticity verified", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.content_authenticity.synthID).to.eql('enabled');
});

pm.test("Response time under 3 seconds", function() {
    pm.expect(pm.response.responseTime).to.be.below(3000);
});

Advanced: Character Consistency Workflow

For projects requiring consistent characters across multiple images, here's how to structure your workflow:

// Step 1: Generate base character
var baseRequest = {
    "prompt": "A friendly robot character, cute style, front view, white and blue color scheme",
    "seed": 12345  // Note the seed for reproducibility
};

// Step 2: Generate variations using same seed
var variationRequest = {
    "prompt": "Same robot character, sitting pose, simple background",
    "seed": 12345  // Same seed maintains consistency
};

// Step 3: Verify character matches
pm.test("Character consistency maintained", function() {
    var baseResponse = pm.globals.get("base_character_response");
    var variationResponse = pm.response.json();
    // Compare object metadata to verify consistency
});

Advanced: Error Handling

Handle common API errors gracefully:

// Test for rate limiting
pm.test("Handle rate limiting", function() {
    if (pm.response.code === 429) {
        var jsonData = pm.response.json();
        console.log("Rate limited. Retry after: " + jsonData.retryDelay);
    }
});

// Test for content policy violations
pm.test("Content policy handling", function() {
    if (pm.response.code === 400) {
        var jsonData = pm.response.json();
        pm.expect(jsonData.error.details[0].reason).to.include('SAFETY');
    }
});

Pricing and Access Tiers

Understanding Nano Banana 2's pricing structure is essential for budgeting your AI image generation projects:

Free Tier

Limitations:

Limited generations per day (exact number varies)
Lower priority during peak times
No access to advanced features
Basic resolution options only

Best for: Learning, experimentation, low-volume use

Google AI Pro ($19.99/month)

Includes:

Substantial generation quota
Priority processing
Access to Nano Banana Pro (higher fidelity)
Higher resolution options
Commercial usage rights

Best for: Freelancers, small teams, production applications

Google AI Ultra ($49.99/month)

Includes:

Generous or unlimited generations
Highest priority processing
Access to all model variants
4K resolution
API access with higher rate limits
Enterprise support

Best for: Teams, agencies, high-volume applications

API-Based Pricing

For programmatic access beyond subscription tiers:

Pay-per-generation pricing available
Volume discounts for enterprise
Vertex AI offers custom pricing

Pro Tip: When building production applications, monitor your API usage carefully. Apidog's analytics features can help track generation counts and identify optimization opportunities.

Real-World Use Cases

Nano Banana 2's capabilities open up numerous practical applications:

1. E-Commerce Product Visualization

Generate product images from descriptions or CAD files:

Create multiple product variations instantly
Generate lifestyle images showing products in use
Produce seasonal and promotional imagery

2. Marketing Content Creation

Streamline marketing workflows:

Generate ad creative variations at scale
Create social media content from text descriptions
Produce A/B testing variants quickly

3. Game and Entertainment Assets

Game developers can leverage:

Character design iteration
Environment concept art
Asset variation generation
Storyboard creation

4. Publishing and Journalism

News organizations can:

Generate illustrative images for articles
Create data visualizations
Produce historical reconstructions (with appropriate disclaimers)

5. Design Prototyping

UX/UI designers benefit from:

Rapid wireframe visualization
Mood board generation
Layout concept exploration
Icon and illustration creation

Conclusion

Google Nano Banana 2 represents a significant step forward in accessible AI image generation. With its combination of speed, quality, and integration options, it's become a compelling choice for developers and businesses looking to add image generation capabilities to their applications.

Key takeaways:

Faster generation with Pro-quality output makes real-time applications viable
Improved text rendering opens up new use cases previously unsuitable for AI image generation
Subject consistency enables multi-image workflows for storytelling and branding
Multiple access channels from consumer apps to enterprise APIs suit various integration needs
Content authentication addresses authenticity concerns for regulated industries

For developers integrating Nano Banana 2, using a tool like Apidog for API testing and management ensures reliable, maintainable integrations. The ability to create test suites, manage environment variables, and automate workflows is essential for production deployments.

As AI image generation continues to evolve, staying current with model updates and best practices will help you build applications that leverage these capabilities effectively.

How to Use Google Nano Banana 2 API

Preecha — Mon, 05 Oct 2026 14:04:18 +0000

Building applications with AI image generation feels like magic—until you hit the wall of complex API documentation, authentication headaches, and debugging nightmares. You've seen what Nano Banana 2 can do: stunning images generated from text prompts, Pro-quality output at Flash speeds, and features like subject consistency that make multi-image workflows possible. But actually integrating it into your codebase? That's where most developers get stuck.

Try Apidog today

You've probably tried wading through Google's documentation, piecing together authentication flows, and manually testing requests in a CLI. Maybe you've already burned through API quota debugging malformed requests or wondered why your images come back blurry every time. The truth is, integrating any new API, especially one as powerful as Nano Banana 2 requires more than just reading the docs. You need a workflow that lets you test quickly, iterate on prompts, and manage your API calls efficiently.

In this guide, we'll walk through everything you need to integrate Nano Banana 2 into your applications, from setting up your Google Cloud project to writing production-ready code in Python and JavaScript. But here's what makes this guide different: we'll show you how to test and debug every step using Apidog, so you're not just copying code, you're building a workflow you can maintain and scale.

Prerequisites

Before you start, make sure you have:

A Google Cloud account (or sign up at cloud.google.com)
Basic understanding of REST APIs
Python 3.8+ or Node.js 18+ installed
An API client like Apidog for testing

This guide assumes you're familiar with making HTTP requests and handling JSON data. If you're new to APIs, check out our API Testing Guide for fundamentals.

Setting Up Your Google Cloud Project

To use the Nano Banana 2 API, you need a Google Cloud project with the Generative Language API enabled.

Step 1: Create a New Project

Go to the Google Cloud Console k- Click "Select a project" → "New Project"
Enter a project name (e.g., "nano-banana-image-gen")
Click "Create"
Wait for the project to be created

Step 2: Configure API Access

Go to "APIs & Services" → "Credentials"
Click "Create Credentials" → "API Key"
Copy your API key (you'll need it later)

Pro Tip: It's best practice to restrict your API key in production. Limit it to the Generative Language API and your specific domains or IP addresses.

Getting Your API Key

There are two ways to get API access:

Option 1: Google Cloud Console (Recommended for Production)

Follow the steps above—the API key you created is your access credential.

Option 2: Google AI Studio (Recommended for Development)

Go to Google AI Studio
Sign in with your Google account
Click "Get API Key" in the navigation
Click "Create API Key" (or select an existing project)
Copy your API key

The AI Studio key is great for development and testing. For production, use the Google Cloud Console key for better management and security.

Your First API Request

Let's make a simple image generation request to verify everything works.

Using cURL

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:predict?key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cute banana character wearing sunglasses, fun cartoon style",
    "number_of_images": 1
  }'

Understanding the Response

{
  "predictions": [
    {
      "image": {
        "mimeType": "image/png",
        "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
      },
      "generatedImageId": "img_abc123xyz",
      "metadata": {
        "prompt": "A cute banana character wearing sunglasses, fun cartoon style",
        "seed": 12345,
        "finishReason": "SUCCESS"
      }
    }
  ],
  "metadata": {
    "modelVersion": "gemini-3.1-flash-image-preview",
    "processingTimeMs": 1250,
    "contentAuthenticity": {
      "synthID": "enabled",
      "c2pa": "enabled"
    }
  }
}

The data field contains a base64-encoded PNG image. You'll need to decode it to save or display the image.

Python Integration

Here's how to integrate Nano Banana 2 into your Python applications:

Installing the Client Library

pip install google-generativeai

Basic Image Generation

import google.generativeai as genai
import base64
import os

# Configure the API with your key
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

# Create the model
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Generate an image
response = model.generate_images(
    prompt="A modern minimalist office with natural lighting, indoor plants, standing desk, 4k quality",
    number_of_images=1
)

# Save the image
if response.generated_images:
    image_data = response.generated_images[0].image_bytes
    with open("output_image.png", "wb") as f:
        f.write(image_data)
    print("Image saved to output_image.png")

Advanced Image Generation with Parameters

import google.generativeai as genai
from PIL import Image
import io

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Generate with advanced parameters
response = model.generate_images(
    prompt="A futuristic cityscape at night with neon lights, flying cars, cyberpunk aesthetic",
    number_of_images=1,
    aspect_ratio="16:9",
    negative_prompt="blurry, low quality, distorted, ugly",
    safety_filter_level="block_medium_and_above"
)

# Process the response
for idx, generated_image in enumerate(response.generated_images):
    # Convert to PIL Image
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Save with custom name
    image.save(f"generated_image_{idx}.png")

    # Access metadata
    print(f"Image {idx}: {generated_image.finish_reason}")
    print(f"Seed: {generated_image.seed}")

Batch Image Generation

import google.generativeai as genai
import os

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Generate multiple images at once
prompts = [
    "A red sports car on a mountain road",
    "A cozy coffee shop interior",
    "A minimalist bedroom design",
    "A tropical beach sunset"
]

# Generate all images
for idx, prompt in enumerate(prompts):
    response = model.generate_images(
        prompt=prompt,
        number_of_images=1,
        aspect_ratio="16:9"
    )

    if response.generated_images:
        image_data = response.generated_images[0].image_bytes
        with open(f"image_{idx + 1}.png", "wb") as f:
            f.write(image_data)
        print(f"Generated: image_{idx + 1}.png")

Character Consistency Example

import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Base character description
base_character = "A friendly cartoon robot with round body, blue eyes, antenna on head, white and light blue color scheme"

# Generate base character (note the seed for consistency)
response1 = model.generate_images(
    prompt=base_character + ", front view, standing pose",
    number_of_images=1,
    seed=42  # Important: note this seed
)

base_seed = response1.generated_images[0].seed
print(f"Base character seed: {base_seed}")

# Generate variations using the same seed
poses = [
    "sitting pose",
    "waving hand",
    "holding a ball",
    "walking"
]

for pose in poses:
    response = model.generate_images(
        prompt=f"{base_character}, {pose}, same character as seed {base_seed}",
        number_of_images=1,
        seed=base_seed  # Same seed maintains consistency
    )

    if response.generated_images:
        filename = f"robot_{pose.replace(' ', '_')}.png"
        with open(filename, "wb") as f:
            f.write(response.generated_images[0].image_bytes)
        print(f"Generated: {filename}")

JavaScript/Node.js Integration

Installing the Client Library

npm install @google/generative-ai

Basic Image Generation

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const path = require("path");

// Initialize with API key
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateImage() {
  // Get the model
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  // Generate image
  const result = await model.generateImages({
    prompt: "A beautiful sunset over the ocean with palm trees silhouette",
    numberOfImages: 1,
  });

  // Process the response
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

    // Save to file
    fs.writeFileSync("sunset.png", Buffer.from(imageData, "base64"));
    console.log("Image saved to sunset.png");

    // Log metadata
    console.log("Seed:", result.generatedImages[0].seed);
    console.log("Finish Reason:", result.generatedImages[0].finishReason);
  }
}

generateImage().catch(console.error);

Handling Base64 Responses

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateAndProcessImage() {
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  const result = await model.generateImages({
    prompt: "Professional headshot of a person in business attire, studio lighting",
    numberOfImages: 1,
    aspectRatio: "1:1",
    resolution: "1024x1024"
  });

  const generatedImage = result.generatedImages[0];

  // Decode base64
  const imageBuffer = Buffer.from(generatedImage.imageBytes, "base64");

  // Save with metadata in filename
  const filename = `portrait_${generatedImage.seed}.png`;
  fs.writeFileSync(filename, imageBuffer);

  return {
    filename,
    seed: generatedImage.seed,
    finishReason: generatedImage.finishReason
  };
}

generateAndProcessImage()
  .then(info => console.log("Generated:", info))
  .catch(err => console.error("Error:", err));

Express.js REST API Example

const express = require("express");
const { GoogleGenerativeAI } = require("@google/generative-ai");
const multer = require("multer");
const fs = require("fs");

const app = express();
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

app.use(express.json());

// Image generation endpoint
app.post("/api/generate", async (req, res) => {
  try {
    const { prompt, aspect_ratio, negative_prompt, number_of_images } = req.body;

    const model = genAI.getGenerativeModel({
      model: "gemini-2.0-flash-exp-image-generation",
    });

    const result = await model.generateImages({
      prompt,
      numberOfImages: number_of_images || 1,
      aspectRatio: aspect_ratio || "1:1",
      negativePrompt: negative_prompt
    });

    // Convert images to base64 for response
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Base64 encoded
    }));

    res.json({
      success: true,
      images,
      metadata: {
        modelVersion: result.response?.metadata?.modelVersion,
        processingTimeMs: result.response?.metadata?.processingTimeMs
      }
    });
  } catch (error) {
    console.error("Generation error:", error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Batch generation endpoint
app.post("/api/generate/batch", async (req, res) => {
  try {
    const { prompts } = req.body;
    const model = genAI.getGenerativeModel({
      model: "gemini-3.1-flash-image-preview",
    });

    const results = [];

    for (const prompt of prompts) {
      const result = await model.generateImages({
        prompt,
        numberOfImages: 1
      });

      results.push({
        prompt,
        seed: result.generatedImages[0]?.seed,
        success: !!result.generatedImages[0]
      });
    }

    res.json({ success: true, results });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

Advanced Parameters

Nano Banana 2 supports various parameters to fine-tune your image generation:

Parameter Reference

Parameter	Type	Description	Example
`prompt`	string	Text description of desired image	`"A cat sitting on a mat"`
`number_of_images`	integer	Number of images to generate (1-4)	`2`
`aspect_ratio`	string	Image aspect ratio	`"16:9", "1:1", "4:3"`
`resolution`	string	Output resolution	`"1024x1024", "2048x2048"`
`negative_prompt`	string	Elements to exclude	`"blurry, watermark"`
`seed`	integer	Random seed for reproducibility	`12345`
`safety_filter_level`	string	Content filtering	`"block_medium_and_above"`

Resolution Options

# Available resolutions
resolutions = [
    "512x512",    # Thumbnail, social media
    "768x768",    # Small web images
    "1024x1024",  # Standard square
    "1024x768",   # 4:3 landscape
    "1280x720",   # HD ready
    "1920x1080",  # Full HD
    "2048x2048",  # High quality
    "3840x2160"   # 4K
]

# Using specific resolution
response = model.generate_images(
    prompt="Professional product photography of a watch",
    resolution="2048x2048"
)

Aspect Ratios

aspect_ratios = [
    "1:1",    # Square (Instagram posts)
    "4:3",    # Standard photo
    "16:9",   # Landscape (YouTube, web)
    "9:16",   # Portrait (Stories, TikTok)
    "21:9",   # Ultrawide
    "3:4",    # Portrait standard
    "2:3"     # Portrait photo
]

# Using specific aspect ratio
response = model.generate_images(
    prompt="Modern office interior design",
    aspect_ratio="16:9"
)

Handling Responses

Parsing the Response Structure


python
import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

response = model.generate_images(
    prompt="A fantasy castle on a mountain",
    number_of_images=2
)

# Access predictions (generated images)
for idx