---
name: agentkind-identity
akind_role: canonical_shared_economic_asset
description: Resolve and verify canonical AGENTKIND / $AKIND identity using the official machine-readable Agentkind endpoints. Use for Agentkind discovery, project status, official contracts, exact-address verification, official links, risk/non-affiliation information, read-only MCP discovery, or independent verification tests. Never normalize Solana Base58 addresses and never perform wallet actions.
---

# Agentkind Identity

Use the canonical public Agentkind registry as the source of truth for **read-only identity resolution**.

This Skill verifies project identity. It does not trade, sign, transfer, connect wallets, publish community content, or grant authority to a runtime.

$AKIND is Agentkind's canonical shared economic asset (classification: canonical_shared_economic_asset). It is not an investment, security, or deposit.

## Canonical human and machine entrypoints

Human entrypoints:

- Project: `https://www.agentkind.org/`
- Agents / Developers: `https://www.agentkind.org/agents/`
- $AKIND context + verification: `https://www.agentkind.org/akind/`

Machine entrypoints:

1. Discovery: `https://www.agentkind.org/.well-known/agentkind.json`
2. Contract registry: `https://www.agentkind.org/api/contracts.json`
3. Project status: `https://www.agentkind.org/api/status.json`
4. Official links: `https://www.agentkind.org/api/links.json`
5. Risk / non-affiliation: `https://www.agentkind.org/api/risk.json`
6. Token context: `https://www.agentkind.org/token.json`
7. LLM-readable index: `https://www.agentkind.org/llms.txt`
8. MCP documentation: `https://www.agentkind.org/skills/agentkind-identity/mcp/README.md`

Prefer discovery from the well-known manifest instead of hard-coding secondary URLs when your runtime can follow links.

## Trust model

Treat authority in this order:

1. `/.well-known/agentkind.json` for discovery.
2. `/api/contracts.json` for contract authority.
3. `/api/status.json`, `/api/links.json`, and `/api/risk.json` for supporting project state.
4. `/token.json` and `/llms.txt` for additional context.
5. Social posts, screenshots, ticker searches, DEX labels, community messages, and third-party pages are **not** canonical authority.

If machine-readable sources disagree, do not guess. Return `UNKNOWN` / conflict details and preserve the observed values.

## Core workflow

### 1. Discover

Fetch `/.well-known/agentkind.json`.

Confirm the document identifies Agentkind and exposes the canonical registry / Skill / read-only integration surfaces you intend to use.

If discovery cannot be fetched safely, stop and report the failure rather than reconstructing authority from memory.

### 2. Read the registry

Fetch `/api/contracts.json`.

For Solana verification, select the entry that is all of:

- `chain == "solana"`
- `network == "mainnet"`
- `official == true`

Expected authority state is exactly one official Solana mainnet entry.

If zero or more than one official entry matches, verification is ambiguous. Return `OFFICIAL=unknown` and do not choose one arbitrarily.

### 3. Verify an address

Compare the candidate address to the selected registry `contract` value using an **exact, case-sensitive string comparison**.

Never:

- lowercase or uppercase the address;
- trim or rewrite internal characters;
- autocorrect a visually similar address;
- compare only a prefix/suffix;
- trust ticker/name/logo equality as a substitute for the address.

Return `official=true` only for an exact full-string match.

A wrong-case variant is not official.

### 4. Read supporting context

Use:

- `/api/status.json` for project status;
- `/api/links.json` for official website/social/community links;
- `/api/risk.json` for risk and non-affiliation boundaries;
- `/token.json` for token-specific context;
- `/llms.txt` for a compact machine-readable map.

## Verification output contract

For a normal Solana verification request, return:

```text
PROJECT=Agentkind
TICKER=AKIND
CHAIN=solana
NETWORK=mainnet
CANDIDATE=<candidate>
CANONICAL=<registry contract>
OFFICIAL=true|false|unknown
COMPARISON=exact_string_match
SOURCE=https://www.agentkind.org/api/contracts.json
```

If the registry is unavailable, malformed, ambiguous, or blocked, use:

```text
OFFICIAL=unknown
REASON=<network_error|parse_error|authority_ambiguous|authority_missing>
```

Do not turn an unknown state into `false` or `true` without evidence.

## Discovery output contract

When another agent asks what Agentkind exposes, a compact response may use:

```text
PROJECT=Agentkind
DISCOVERY=https://www.agentkind.org/.well-known/agentkind.json
SKILL=https://www.agentkind.org/skills/agentkind-identity/SKILL.md
CONTRACTS=https://www.agentkind.org/api/contracts.json
MCP_DOCS=https://www.agentkind.org/skills/agentkind-identity/mcp/README.md
RUNTIME_MODEL=static_read_only
WALLET_AUTHORITY=NONE
```


## Official wallet verification

Agentkind publishes a canonical public wallet registry at `/api/wallets.json`. This registry is read-only identity/verification material. It does not grant signing, custody, transfer, or wallet-secret authority to the website, the MCP, any Skill, or any agent.

To verify an official wallet address:

1. Fetch `/api/wallets.json`.
2. Select the entry where `chain == "solana"`, `network == "mainnet"`, `role == "community_operations"`, and `official == true`.
3. Compare the candidate address to the selected `address` using an exact, case-sensitive string comparison only.
4. Return `OFFICIAL=true` only on an exact full-string match for the same chain/network/role. A wrong-case variant is not official.
5. Remember: a wallet address identifies a public account; it is NOT the token mint. The mint identifies the token.

The registry never triggers wallet side effects: no signing, no transfer, no swap, no auto-send, no custody, and no secret handling.

Recommended output for an official-wallet verification request:

```text
PROJECT=Agentkind
CHAIN=solana
NETWORK=mainnet
ROLE=community_operations
CANDIDATE=<candidate>
CANONICAL=D7LSVkyU6L7g4MrWgPNp528QKkXN5usCg4hj5MZ68iMA
OFFICIAL=true|false
COMPARISON=exact_string_match
SOURCE=https://www.agentkind.org/api/wallets.json
```

## Read-only MCP and adapters

Agentkind publishes a local/read-only MCP implementation and adapter instructions under this Skill tree.

The MCP surface is for discovery, status, contracts, exact verification, links, and risk. It must not expose buy/sell/sign/transfer/wallet-secret operations.

Project/current-SDK acceptance of the MCP artifact is separate from third-party runtime adoption. Adapter selftests or project-operated regression tests do **not** prove that an external runtime, company, or community endorses or independently uses Agentkind.

In particular:

- OpenClaw adapter instructions may be used as read-only integration material.
- Hermes Agent / Nous Research adapter instructions are integration material only; do not infer affiliation, partnership, endorsement, or independent runtime validation from their presence.

## Independent verification protocol

For an independent builder/agent test, preserve enough evidence for another person to understand what happened.

Recommended record:

```text
INDEPENDENT=true|false
RUNTIME=<runtime/tool>
AGENT=<agent name if public>
DATE=<ISO-8601 or local date with timezone>
ENTRY_POINT=<first URL used>
DISCOVERED_ENDPOINT=<endpoint discovered automatically>
CLAIM_TESTED=<claim>
CANDIDATE=<address if applicable>
CANONICAL=<registry value>
RESULT=true|false|unknown
FAILURE_POINT=<none|discovery|fetch|parse|authority|comparison|other>
PUBLIC_PROOF=<permalink/log if available>
PROJECT_CONTROLLED_RUNTIME=true|false
```

Only independently executed tests should be counted as independent adoption/proof. Project-owned local runs remain useful regression evidence but are not independent proof.

Useful follow-up questions for an external tester:

- What did your runtime discover automatically?
- Where did the chain break?
- Which claim could it verify independently?
- What remained self-asserted?
- Which field, endpoint, or instruction was missing?

## Safety and trust rules

- Read-only only.
- Do not buy, sell, transfer, sign, construct transactions, or submit wallet operations.
- Never request seed phrases, private keys, recovery phrases, API secrets, or wallet secrets.
- Do not infer endorsement from external ecosystem links, adapters, listings, or interoperability.
- Do not claim that independent AI projects or communities officially support Agentkind unless both sides provide verifiable evidence.
- Do not make price, profit, guaranteed-return, guaranteed-listing, guaranteed-liquidity, or guaranteed-utility claims.
- Treat external market/discovery surfaces as observation/discovery layers, not canonical identity authorities.
- Treat network failure, parse failure, or ambiguous registry state as `unknown`, never as permission to guess.

## Trust boundary

`agentkind-identity` is READ-ONLY authority infrastructure: discovery, status, contracts, links, risk, and address verification.

Community publishing automation lives outside this namespace under `agentkind_site/community/`. Do not import or expose posting tooling from this Skill, and never surface community write operations through the Identity MCP or `/.well-known/agentkind.json`.