> ## Documentation Index
> Fetch the complete documentation index at: https://docs.unsiloed.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Upgrade Your OpenClaw Agent with the Unsiloed Skill
> Install the Unsiloed skill so your OpenClaw agent routes every image and PDF through Unsiloed's document AI instead of its built-in vision, returning structured data with a confidence score on every field.
An OpenClaw agent reads documents with the underlying model's general-purpose vision. That works on a clean printed PDF, but on handwriting, a dense table, or a faded scan the agent makes up content and gives no signal that anything went wrong. This guide installs the Unsiloed skill into your agent so any document attachment routes through the Unsiloed API instead. The agent gets back structured data with a confidence score on every value, so its reply flags what to verify.
By the end, your agent auto-invokes Unsiloed whenever someone sends it a document or asks about one, across any connected channel.
The skill is a single `SKILL.md` file that drives the Unsiloed API with `curl` and `jq`. There's no Python or extra runtime to manage. It exposes all four Unsiloed operations (Parse, Extract, Classify, and Split), and the agent picks the right one per request.
## What Changes After You Install It
We gave an OpenClaw agent a handwritten prescription and asked which medicines were listed.
* **Default vision read:** the agent confidently returns medicine names that aren't on the page, with no confidence score and no way to tell which values to trust.
* **Routed through Unsiloed:** the agent returns the three medicines actually written on the page, each with a confidence score above 0.95.
The prescription is one case among many. The same skill handles any document that's hard to read with vision alone:
* Faded thermal receipts
* Dense financial tables that span pages
* Multi-column forms
* Handwritten invoices
* Low-contrast scans
## Prerequisites for the Unsiloed Skill
Before installing, make sure you have:
* **OpenClaw with the gateway configured:** see the [OpenClaw skills documentation](https://docs.openclaw.ai/cli/skills) to set it up.
* **An Unsiloed API key:** [sign up on Unsiloed AI](https://www.unsiloed.ai) to get one.
* **`curl` and `jq` on the machine running the gateway:** the skill declares both as requirements and won't load without them.
## Install the Skill
The skill installs from its GitHub repository through the OpenClaw CLI. Run these steps in order.
The skill lives in the Unsiloed cookbook at [`skills/unsiloed`](https://github.com/Unsiloed-AI/cookbook/tree/main/skills/unsiloed). Point the OpenClaw CLI at the repository and that subpath:
```bash theme={null}
openclaw skills install git:https://github.com/Unsiloed-AI/cookbook --subpath skills/unsiloed
```
OpenClaw clones the repo, registers the skill in your workspace, and tracks the origin, so `openclaw skills update --all` pulls future updates from the same source.
The skill reads the key from the gateway's environment. Append it to OpenClaw's global env file:
```bash theme={null}
echo 'UNSILOED_API_KEY=us_...' >> ~/.openclaw/.env
```
Replace `us_...` with your actual key.
The gateway loads env vars at startup, so restart it to pick up the new key:
```bash theme={null}
openclaw gateway restart
```
Confirm the skill loaded and its requirements pass:
```bash theme={null}
openclaw skills info unsiloed
```
The first line of the output should read:
```
unsiloed ✓ Ready
```
To see it alongside every other skill, run `openclaw skills check` — `unsiloed` should appear under **Ready and visible to model**. If it shows up under **Missing requirements** instead, the `UNSILOED_API_KEY`, `curl`, or `jq` requirement isn't satisfied yet.
## Send Your Agent a Document
Send a document to the agent through any connected channel: Telegram, a file share, or a paired terminal. The skill auto-invokes whenever you attach a document or ask a question about one, such as "what does this say", "what medicines are listed", or "extract the totals". The agent picks the right Unsiloed operation, polls the async job until it finishes, and replies in plain English. The user never sees raw JSON.
For example:
```
You: [attached prescription.jpg] What medicines are listed here?
Agent: Three medicines: Tab Azee 500mg, Tab Montair FX, and Tab Dolo 650.
All extracted with confidence above 0.95.
```
## Parse vs Extract: When the Agent Uses Each
The skill teaches the agent to choose between the Unsiloed operations. The two you'll see most often are Parse and Extract.
**Parse** reads an entire document and returns it as Markdown, with every layout region preserved (paragraphs, tables, lists, headings, captions). It's the default. For most chat questions about a document, the agent parses it, then reads and quotes what's there.
**Extract** pulls specific fields you name in advance (invoice total, patient name, date of issue) and returns each one with a confidence score from 0 to 1. Use Extract when the output is going somewhere structured, such as a spreadsheet, a database row, or an automated workflow, and you want a per-field confidence score so anything below a threshold like 0.85 can be flagged for human review. Because Extract returns the same shape every time, the agent can pipe it straight into a destination you've already wired up.
The skill defaults to Parse, so most prompts route there automatically. To trigger Extract, ask for structured fields back:
```
Give me the total and the date as JSON.
```
The skill also exposes **Classify** (label a document as one of several candidate categories) and **Split** (break a single PDF containing several documents into separate files by type). The agent reaches for these when the request clearly calls for them: "is this a receipt or a contract", or "split this bundle into separate files".
## Keeping the Skill Up to Date
Because the skill was installed from git, pull the latest version any time with:
```bash theme={null}
openclaw skills update --all
```
This updates every tracked skill from its origin. Restart the gateway afterward if the update changes anything the running agent has cached.
## Next Steps
Configure chunking strategies, segment filters, and the OCR backend behind Parse.
Define a JSON schema and pull typed fields out of a document with confidence scores.
Give Claude direct, structured access to the same operations through Anthropic tool use.
Browse the full request and response specs for every endpoint.