PicoClaw the software is free: the repository is MIT-licensed and picoclaw.io's own FAQ says "The software is free. You only pay for the LLM API usage" — so "PicoClaw pricing" means your model API bill, plus whatever the device cost. Sipeed advertises no PicoClaw subscription and no hosted tier. The number worth budgeting is tokens per agent turn, and the setting most likely to surprise you is PicoClaw's tool-iteration ceiling: 50 when the field is absent, 20 in the shipped example config.
Two disambiguations first, because the results page mixes them. The official domain is picoclaw.io — it is the homepage field of github.com/sipeed/picoclaw. The look-alike pico-claw.com states in its own footer that it "is not officially affiliated with Sipeed or PicoClaw", and the monthly package price on it belongs to that site's own managed-hosting module, not to PicoClaw. A second look-alike, picoclaw.net, is not the official domain either. It headlines "95% AI-Generated Code" and "3 Supported Architectures" — x86_64, ARM64 and RISC-V — where the FAQ on picoclaw.io lists six. And PicoClaw is not a fork of OpenClaw; it is an independent Go implementation that benchmarks itself against OpenClaw and NanoBot.
PicoClaw pricing, line by line
| Line item | What it costs | Where that comes from |
|---|---|---|
| The PicoClaw binary, all platforms and features | $0, MIT | Repository metadata (spdx_id: MIT, archived: false) and the official FAQ |
| A hosted PicoClaw service from Sipeed | None advertised | No such product on picoclaw.io or in the repository |
| Model API tokens | Your provider's per-token rate | Your provider's own billing |
| Hardware, if you buy a board for it | Sipeed's README states $9.9 for a LicheeRV-Nano, $30~50 for a NanoKVM and $100 for a NanoKVM-Pro | PicoClaw README — these are Sipeed's own figures for its own hardware; retail prices were not checked, and the MaixCAM2 figure links to a Kickstarter |
| Running it on a device you already own | No hardware spend | Official FAQ: "Minimum: any device with 64MB RAM and an internet connection for LLM API calls. Recommended: 512MB RAM." The separate "<10MB" headline is PicoClaw's own memory footprint, not the device requirement |
All checked September 21, 2026. Version, for the record: the latest tagged release is v0.3.1, published July 3, 2026, while the repository was last pushed September 17, 2026 — so code on main is ahead of the tag, and the README's own news list is staler still, its newest release entry being v0.2.9 of May 28, 2026. Every behaviour below was read on main, not from the v0.3.1 binary you would download; a reader on the tagged release may see something different. One live condition on the check date: the TLS certificate for picoclaw.io had expired (valid February 25 to September 10, 2026), so a browser shows a security warning on the official download page. That may be fixed any day and says nothing about the project; GitHub Releases is unaffected.
PicoClaw API key setup: model_list and .security.yml
picoclaw onboard creates ~/.picoclaw/config.json and the workspace. Models are declared in a model_list array and selected by name from agents.defaults.model_name; the two must match, which is the single case PicoClaw's troubleshooting document covers.
{
"agents": {
"defaults": {
"model_name": "gateway-sonnet"
}
},
"model_list": [
{
"model_name": "gateway-sonnet",
"provider": "openai",
"model": "claude-sonnet-4-6",
"api_base": "https://api.kunavo.com/v1",
"enabled": true
}
]
}Keys live in a second file. PicoClaw's security documentation calls config.json "Main configuration (safe to share)" and .security.yml "Security data (never share)", and tells you to chmod 600 it. The YAML shape is a map keyed by model_name, not the array used in config.json, and api_keys is plural and an array even for a single key.
# The map key must equal the model_name in config.json.
# api_keys is plural and is an array even for one key.
model_list:
gateway-sonnet:
api_keys:
- "sk-kn-..."Four details that catch people. provider is optional: set it and model is sent upstream unchanged; omit it and PicoClaw reads everything before the first / in model as the provider, which is the legacy protocol/model form. Config is schema-versioned and version 3 is current; migration writes a date-stamped backup, and the docs warn that a V3 file cannot be safely loaded by older V2-only builds. During the V1 to V2 migration enabled is auto-inferred — entries with no API key, and not named local-model, default to disabled — which is why the example above sets enabled explicitly after the keys have moved out to .security.yml. And streaming is off by default and gated twice: the model entry's streaming.enabled and the channel's settings.streaming.enabled must both be true.
One boundary worth stating before you write entries: PicoClaw's vendor table lists Groq as "LLM + Voice transcription (Whisper)", and Kunavo does not serve speech-to-text, text-to-speech or embeddings — a transcription or embedding entry has to point at another provider, and only the chat entries are candidates for a Kunavo key.
The protocol names are inverted, and that is the whole trap
In PicoClaw, anthropic means Claude-shaped models over the OpenAI wire format, and anthropic-messages means Anthropic's native Messages API. The documentation says it outright: "The anthropic protocol uses OpenAI-compatible format (/v1/chat/completions), while anthropic-messages uses Anthropic's native format (/v1/messages)." The source agrees — factory_provider.go builds the shared OpenAI-compatible HTTP provider for anthropic and a separate native provider for anthropic-messages. PicoClaw's own "All Supported Vendors" table contradicts both by labelling the anthropic row's protocol column "Anthropic"; a reader who only reads that table configures the wrong one.
provider value | Wire format it speaks | How api_base is handled | Final request URL |
|---|---|---|---|
openai, and the OpenAI-compatible family (openrouter, groq, litellm, ollama…) | OpenAI chat completions | Used verbatim; only trailing slashes trimmed. You supply /v1 yourself | <api_base>/chat/completions |
anthropic | OpenAI chat completions, despite the name | Forced to end in /v1: one trailing /v1 is stripped, then /v1 re-appended | <base>/v1/chat/completions |
anthropic-messages | Anthropic native Messages | Same forced /v1, applied inside the provider constructor | <base>/v1/messages, with X-API-Key and Anthropic-Version: 2023-06-01 |
Read from openai_compat/provider.go, common/anthropic_common.go, anthropic_messages/provider.go and factory_provider.go on main, September 21, 2026 — derived from code, not observed on the wire. The consequence is concrete: you cannot point anthropic or anthropic-messages at a gateway whose path must not end in /v1, because PicoClaw appends it regardless. A gateway at https://gw.example.com/anthropic becomes https://gw.example.com/anthropic/v1/messages. For such an endpoint the openai protocol, which respects the path verbatim, is the only one that can express the URL. Only these three protocols were audited; do not generalise the rule to gemini, azure or the rest.
Two further limits on the native path, both read in the same file. anthropic-messages requires an API key and hard-errors without one, so the OAuth branch — which factory_provider.go wires to anthropic and openai, alongside the CLI bridges and antigravity — cannot be reached through it. And while five branches in factory_provider.go forward cfg.CustomHeaders, the anthropic-messages branch is not one of them: its constructor takes only the key, base URL, user agent and timeout. So the documented custom_headers escape hatch for a gateway with non-standard auth appears to reach the OpenAI-compatible protocols and not the native Messages one. That is a source reading, not a runtime test. What the native path does not cost you is tool calling: it builds native tools with input_schema and handles tool_use and tool_result blocks.
For Kunavo the two documented base URLs are https://api.kunavo.com/v1 for chat completions and https://api.kunavo.com/v1/messages for the Messages route, and Kunavo's Messages handler reads the key from x-api-key as well as Authorization: Bearer. On paper those meet PicoClaw's URL arithmetic from both directions. That is arithmetic over two sets of documentation — no PicoClaw request has been made to Kunavo here, and this page does not claim any PicoClaw protocol is tested against it. See the Anthropic base-URL doc and the chat endpoint doc for the exact shapes, then send one bounded request yourself.
A worked PicoClaw API cost estimate
These are illustrative token arithmetic, not measured task costs and not a bill ceiling. Assume one agent turn that resolves in 8 tool rounds, where each round resends a transcript averaging 12,000 input tokens and returns 700 output tokens. Those ratios are assumptions for illustration. The second column runs the same shape to the compiled-in max_tool_iterations default of 50 in pkg/config/defaults.go, which applies when the field is absent — the shipped config/config.example.json writes 20, so read your own file before treating 50 as your ceiling. Rates are live Kunavo catalog prices per million tokens.
| Model | Input / output per 1M | Estimate, 8 tool rounds | Estimate, 50-round ceiling |
|---|---|---|---|
| GPT-5.6 Luna | $0.07 / $0.42 | $0.009 | $0.057 |
| Claude Haiku 4.5 | $0.40 / $2.00 | $0.050 | $0.310 |
| Gemini 3.8 Flash | $0.525 / $2.625 | $0.065 | $0.407 |
| Claude Sonnet 4.6 | $1.20 / $6.00 | $0.149 | $0.930 |
| Claude Opus 5 | $2.00 / $10.00 | $0.248 | $1.550 |
Read the two columns as one fact. Going from 8 rounds to the 50-round ceiling multiplies every row by the same 6.25x, because loop length is independent of the rate: one Claude Sonnet 4.6 turn is $0.149 at 8 rounds and $0.930 at the ceiling, while Claude Haiku 4.5 at that same ceiling is $0.310. So cap max_tool_iterations at a number you have actually observed before you shop for a cheaper rate — it sits under agents.defaults and is overridable by the PICOCLAW_AGENTS_DEFAULTS_MAX_TOOL_ITERATIONS environment variable. Then scale by turns per day.
Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache reads and writes are billed at their own rates and are not modelled here in either direction, and external tool calls sit outside the example too. The minimum top-up is $10 in prepaid credit, a funding minimum rather than a task fee or a subscription — see billing details and AI cost optimization for the measurement method.
Best API for PicoClaw: which route wins when
| Route | Wins when | What you give up |
|---|---|---|
| Direct vendor API | One vendor's models all day, and you want that vendor's own caching and batch terms | A second vendor means a second model_list entry and a second key; PicoClaw's built-in defaults already cover the common vendors, so there is little setup saved either way |
| An OpenAI-compatible gateway | You switch models per task and want one key and one balance across them | You choose the protocol by wire format rather than by brand, and you own the /v1 question in the table above. OpenAI-compatible API covers the general shape |
| Anthropic-native gateway path | Your endpoint serves only /v1/messages | No OAuth branch, and no custom_headers forwarding in the code read on the check date — so a gateway with non-standard auth is awkward here |
| Subscription login | Flat-rate heavy use suits you better than metered tokens | PicoClaw ships no subscription of its own, and the OAuth branch is wired to anthropic and openai plus the CLI bridges and antigravity — not to anthropic-messages or the OpenAI-compatible gateway protocols. What that flow authenticates against, and whether the vendor's terms permit it, was not verified here |
| Local model | Private or small work with no per-request charge — ollama, lmstudio and vllm need no key at all | Capability gap against hosted models, and hardware PicoClaw's own 64MB floor does not imply |
Provider counts are not a comparison axis here: PicoClaw's own file set disagrees with itself about which providers exist, so its README phrasing of "30+ LLM providers" is the safest thing to repeat. For where PicoClaw sits among the other single-binary agents, the AI agent API directory lists its configuration surface beside theirs, and OpenRouter alternatives compares gateway routes on funding terms rather than integration depth.
First request, first tool round, and a 404
Run one bounded task and read three things in order. A model not found in model_list error is the documented case and it is a naming mismatch: agents.defaults.model_name must equal a model_name entry, and an unprefixed id with no provider set does not select the vendor you meant — it falls back to the openai protocol, which is the documented "model": "free" case where OpenRouter receives the literal id free and rejects it. A 404 on the first request is the documented signal that you chose the wrong Anthropic protocol — PicoClaw's own guidance says to move to anthropic-messages when "the existing anthropic protocol returns 404 errors (indicating the endpoint doesn't support OpenAI-compatible format)". Check the assembled URL against the table above before changing anything else; there is no official troubleshooting entry for this, so that diagnosis comes from the providers note and the source, not from a support page. Third, if the first tool round fails while plain chat worked, suspect schema strictness rather than auth: PicoClaw forwards tool schemas unchanged by default, and tool_schema_transform: "simple" is the per-model opt-out for endpoints that reject $ref, $defs, anyOf, oneOf, allOf or pattern.
Kunavo publishes no PicoClaw setup page and has run no PicoClaw compatibility test; keep a working route available while you try it, then read the charge your account actually recorded for that task rather than estimating from this page. Create a Kunavo account when you are ready to fund a key, and compare model rates on cheapest Claude API if Claude is the family you have settled on.
FAQ
How much does PicoClaw cost?
The PicoClaw software costs nothing. The repository github.com/sipeed/picoclaw carries an MIT license, and the official site picoclaw.io answers its own FAQ with "The software is free. You only pay for the LLM API usage (e.g., OpenAI, Claude) based on your own consumption" (both checked September 21, 2026). Sipeed advertises no paid tier, no subscription and no hosted PicoClaw plan on either surface. One unaffiliated look-alike, pico-claw.com, puts a $16.99-per-month package next to the PicoClaw name; its own footer states it is not officially affiliated with Sipeed or PicoClaw, and that price is for the site's own managed-hosting module.
Where does PicoClaw store the API key?
In ~/.picoclaw/.security.yml, not in config.json. PicoClaw's security documentation describes config.json as "Main configuration (safe to share)" and .security.yml as "Security data (never share)", and tells you to chmod 600 the latter. Model keys go under model_list keyed by the model_name you used in config.json, and the field is api_keys, plural, an array even when you have one key — the docs state that all models must use the array form. The shipped config/config.example.json is already schema version 3 and still writes api_keys inline; moving them into .security.yml is a manual step the security document walks you through, while an older config at version 0, 1 or 2 is auto-migrated on load with a date-stamped backup. Several keys in one array enable per-request rotation and failover. Read on branch main, September 21, 2026.
What is the difference between the anthropic and anthropic-messages protocols in PicoClaw?
The names are the opposite of what they look like. PicoClaw's provider documentation states verbatim: "The `anthropic` protocol uses OpenAI-compatible format (`/v1/chat/completions`), while `anthropic-messages` uses Anthropic's native format (`/v1/messages`)." The source agrees — in pkg/providers/factory_provider.go the anthropic branch builds the same OpenAI-compatible HTTP provider used by openai, openrouter and groq, while anthropic-messages builds a separate native Messages provider that sets X-API-Key and Anthropic-Version: 2023-06-01. PicoClaw's own vendor table contradicts this by labelling the anthropic row's protocol column "Anthropic"; the note and the code agree against the table. So pick by the wire format your endpoint serves, not by the vendor whose models you want. Checked on branch main, September 21, 2026.
What is the best model for PicoClaw?
There is no benchmark that answers this, so treat any ranking as editorial. PicoClaw lists a handful of common_models per provider in pkg/providers/provider_metadata.go, which is a convenience list rather than a capability ranking, and no PicoClaw model comparison has been run here. Choose on three mechanical properties instead. First, tool-schema tolerance: PicoClaw forwards tool JSON Schemas unchanged by default, so a model whose endpoint rejects $ref, $defs, anyOf, oneOf, allOf or pattern needs tool_schema_transform set to "simple" on that model entry. Second, how few tool rounds the model needs, because each round resends the transcript and the ceiling is 50 iterations when max_tool_iterations is unset. Third, whether you need the native Messages path at all. Then use the fallbacks field to put a cheap model first and a stronger one behind it, and measure both on your own task.
What is the cheapest API for PicoClaw?
Cheapest listed rate and cheapest way to finish the task are different questions, and PicoClaw's agent loop is where they separate. Each tool iteration resends the conversation, so a cheap model that needs twenty rounds can cost more than a stronger model that needs six, and the compiled-in default for max_tool_iterations is 50 in pkg/config/defaults.go, which applies when the field is absent — the shipped config/config.example.json and the Zhipu examples in the docs write 20 instead, so which number you get depends on which file you started from. Cheapest of all is a local model through PicoClaw's ollama, lmstudio or vllm protocols, which need no API key at all and cost hardware and power instead; on a 64MB-class device that is not realistic, which is why most PicoClaw installs call a hosted endpoint. Budget by measuring one real task at the rate your provider charges, not by ranking price lists.
Can PicoClaw use a custom API endpoint?
Yes, and no plan or licence gates it: PicoClaw is MIT-licensed and Sipeed advertises no paid tier. Set api_base on the model_list entry. The handling differs by protocol and it decides whether your gateway is reachable: the openai protocol uses api_base verbatim after trimming trailing slashes and appends /chat/completions, so you supply the /v1 yourself, while the anthropic and anthropic-messages protocols force the base to end in /v1 by stripping one trailing /v1 and re-appending it. A gateway whose path must not end in /v1 therefore has to go through the openai protocol or another member of its OpenAI-compatible family; gemini, azure and the remaining protocols were not audited here. Three things a custom base URL cannot reach: the OAuth login path, which factory_provider.go wires to the anthropic and openai protocols via auth_method: "oauth" or "token", and which the CLI bridges and antigravity use instead of a key; AWS Bedrock and the Azure identity path, which need a rebuild with go build -tags bedrock or -tags azidentity; and github-copilot, whose branch defaults to gRPC on localhost:4321, and antigravity, whose branch takes no api_base at all. Source read on branch main, September 21, 2026.
Checked September 21, 2026: the GitHub repository and releases API, picoclaw.io (read with certificate validation disabled, because its certificate had expired), the README, docs/guides/providers.md, docs/security/security_configuration.md, docs/reference/config-versioning.md, docs/guides/configuration.md, docs/operations/troubleshooting.md, config/config.example.json, and seven source files on branch main — factory_provider.go, openai_compat/provider.go, common/anthropic_common.go, anthropic_messages/provider.go, provider_metadata.go, pkg/config/defaults.go and pkg/config/config.go — plus the two look-alike domains. Not checked: the third-party quotas in PicoClaw's own comparison table, retail hardware prices, and the v0.3.1 release notes. Nothing was installed or run: no PicoClaw request was sent to any endpoint. Kunavo token rates come from the live catalog, and every dollar example here is illustrative token arithmetic rather than a measured task cost.