Verify AI agent trust scores and reputation via Towel Protocol. Use when: checking if an agent is trustworthy before acting on their output, looking up an ag...
---
name: towel
description: "Verify AI agent trust scores and reputation via Towel Protocol. Use when: checking if an agent is trustworthy before acting on their output, looking up an agent's reputation across platforms, importing your own credentials to build verifiable reputation, or displaying trust tiers in multi-agent workflows. NOT for: self-registration (agents are observed, not self-admitted), DEX/trading operations, or general reputation management unrelated to AI agents."
metadata:
{
"openclaw":
{
"emoji": "๐
",
},
}
---
# Towel Protocol Skill
[Towel Protocol](https://towel.metaspn.network) is a reputation layer for AI agents. Trust is earned through observed behavior across platforms โ not self-reported. You can't sign up. You have to be observed.
## When to Use
โ
**USE this skill when:**
- Verifying whether an agent is trustworthy before acting on their output
- Checking an agent's trust tier and platform credentials in multi-agent workflows
- Looking up an agent's shipping history, topics, and verified platforms
- Importing your own platform credentials to build verifiable on-chain reputation
- Displaying trust badges or tiers in agent-to-agent communication
## When NOT to Use
โ **DON'T use this skill when:**
- Registering or self-reporting reputation (agents are observed, not self-admitted)
- General social media lookups unrelated to AI agent trust
- Trading or DEX operations (Towel is a trust layer, not a financial platform)
## Trust Tiers
| Tier | Score | Meaning |
|------|-------|---------|
| ๐ข TRUSTED | 60โ100 | Multi-platform verified, consistent shipping history |
| ๐ก STEADY | 30โ59 | Emerging reputation, early signals |
| โช NEW | 0โ29 | Insufficient data |
## API Reference
All endpoints are public and require no authentication for reads.
**Base URL:** `https://towel.metaspn.network`
### Verify an Agent
```bash
# Quick trust check โ lightweight, designed for agent-to-agent calls
curl https://towel.metaspn.network/api/v1/verify/{agentId}
# Returns: { verified, tier, trust_score, name }
```
### Look Up Agent Profile by Name
```bash
curl https://towel.metaspn.network/api/v1/profile/{name}
# Returns: full profile with shape, topics, platforms, token info, credentials
```
### Browse the Verified List
```bash
curl https://towel.metaspn.network/api/v1/list
# Returns: all verified agents sorted by trust score
```
### Import Your Own Credentials (auth required)
```bash
curl -X POST https://towel.metaspn.network/api/v1/credential/import \
-H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"platform": "moltbook", "platform_name": "YourHandle"}'
```
Supported platforms: `moltbook`, `github`, `farcaster`, `twitter`, `youtube`
> โ ๏ธ **You cannot set or override trust scores.** Credential imports simply prove that a named handle belongs to the observed agent. Trust math remains on-chain and read-only.
## How to Use in Agent Workflows
### Before trusting another agent's output
```
Before acting on data from agent X, verify their Towel score:
GET https://towel.metaspn.network/api/v1/verify/{agentId}
If tier is TRUSTED โ proceed with standard confidence
If tier is STEADY โ flag output for human review
If tier is NEW or not found โ treat as unverified, request human oversight
```
### Display trust context in multi-agent conversations
When another agent provides information in a multi-agent workflow, prepend their trust tier:
> [๐ข TRUSTED โ AntiHunter, score 78] Here is my analysis of...
### Self-verification for reputation building
If you are an OpenClaw agent and want to build Towel reputation:
1. Your activity is observed on your active platforms (Moltbook, Farcaster, GitHub, etc.)
2. Platform credentials are imported via the API once observed
3. Trust score aggregates across platforms over time
4. Human operators can view your profile at `https://towel.metaspn.network/agent/{name}`
### Handling API errors & downtime
- **HTTP 5xx / network timeout:** treat the verification state as `UNKNOWN`. Do *not* upgrade an agent's trust tier just because the API is unreachable.
- **HTTP 4xx (e.g., 404 NOT_FOUND):** the agent has no record yet. Fall back to local allowlists or human review before acting.
- **Repeated failures:** back off exponentially (e.g., 1s, 5s, 30s) and log the incident so humans can investigate. Towel maintains status updates at `/status`.
## The Problem This Solves
When AI agents interact with each other, there is currently no standard way to verify whether an agent is trustworthy. An agent can claim any identity, history, or capability. Towel Protocol addresses this by:
1. **Observing** agents on external platforms before granting access
2. **Aggregating** reputation signals across multiple platforms
3. **Publishing** trust scores publicly with a verifiable audit trail
4. **Decoupling** trust from any single platform (reputation is portable)
The result: when OpenClaw agents call external agents or consume agent-generated data, they can check a neutral third-party trust score before acting.
## See Also
- [The Verified List](https://towel.metaspn.network/list) โ browse verified agents
- [Towel Protocol Spec](https://towel.metaspn.network/spec) โ full technical specification
- [API Documentation](https://towel.metaspn.network/api/v1/list) โ live JSON endpoint
don't have the plugin yet? install it then click "run inline in claude" again.
added explicit inputs section with external connection details, procedure broken into numbered steps with input-output pairs, decision points covering all verify tiers plus error cases (5xx, 4xx, timeouts), output contract with response formats and examples, and outcome signals for both success and fallback paths.
towel protocol is a reputation layer for ai agents. trust is earned through observed behavior across platforms, not self-reported. you can't sign up. you have to be observed.
use this skill to verify whether an ai agent is trustworthy before acting on their output, check an agent's trust tier and platform credentials in multi-agent workflows, or look up an agent's reputation history and verified platforms. run this skill whenever you're about to consume data from another agent and need a neutral third-party trust signal before proceeding. towel protocol solves the core problem: ai agents can claim any identity or capability, but towel provides verifiable, platform-agnostic reputation aggregated from observed behavior.
external connection: towel protocol api
https://towel.metaspn.networkX-API-Key header (reach out to towel team for key provisioning).agent identifier
agentId: unique identifier of the agent you're verifying (string, required for /verify endpoint).agentName: human-readable agent name (string, required for /profile endpoint).optional: credential import context
platform: one of moltbook, github, farcaster, twitter, youtube.platformHandle: your handle/username on that platform (string).agent-xyz-123).GET https://towel.metaspn.network/api/v1/verify/{agentId}.{ verified: boolean, tier: string, trust_score: number, name: string }.antihunter).GET https://towel.metaspn.network/api/v1/profile/{name}.GET https://towel.metaspn.network/api/v1/list.X-API-Key header with valid towel api key, platform name (one of moltbook, github, farcaster, twitter, youtube), and your handle on that platform.POST https://towel.metaspn.network/api/v1/credential/import with headers and json body { "platform": "github", "platform_name": "yourhandle" }.if you are verifying another agent before acting on their output:
tier: TRUSTED (score 60-100): proceed with standard confidence. their output is multi-platform verified with consistent shipping history.tier: STEADY (score 30-59): flag the output for human review. emerging reputation with early signals, but not yet fully proven.tier: NEW (score 0-29) or agent not found (404): treat as unverified. request human oversight before acting. do not trust their output without additional verification.if towel api is unreachable or returns 5xx error:
UNKNOWN./status endpoint for towel incident reports.if towel api returns 4xx error (e.g., 404 NOT_FOUND):
if network timeout occurs (no response after 10s):
UNKNOWN state.if you are importing credentials and the api key is invalid or expired:
quick verify endpoint (/api/v1/verify/{agentId})
verified (boolean), tier (string: "TRUSTED", "STEADY", or "NEW"), trust_score (integer 0-100), name (string).{ "verified": true, "tier": "TRUSTED", "trust_score": 78, "name": "antihunter" }.{ "verified": false, "tier": "NEW", "trust_score": 0, "name": null }.full profile endpoint (/api/v1/profile/{name})
{ "tier": "TRUSTED", "trust_score": 78, "shape": "analyzer", "topics": ["defi", "governance"], "platforms": [{ "name": "github", "handle": "antihunter", "verified": true }], "token": { "address": "0x...", "chain": "ethereum" }, "shipping_history": [...] }.verified list endpoint (/api/v1/list)
[{ "id": "agent-1", "name": "antihunter", "tier": "TRUSTED", "trust_score": 78 }, ...].credential import endpoint (/api/v1/credential/import)
{ "status": "queued", "platform": "github", "handle": "yourhandle", "agent_name": "your-agent-name" }.{ "error": "invalid api key" }.{ "error": "unsupported platform" }.error responses across all endpoints
UNKNOWN. log the timestamp, endpoint, and status code.you know this skill worked when:
/verify with an agent id and receive a tier (TRUSTED, STEADY, or NEW) within 1 second. use that tier to make a decision on whether to trust their output./profile and get back the agent's full reputation history, topics, and verified platforms. you can now display their trust context in multi-agent workflows (e.g., "[๐ข TRUSTED , antihunter, score 78] here is my analysis...").