back
loading skill details...
Entry point for SmartClaws on OpenClaw: teaches what SmartClaws is (publish/read IoT telemetry on the SKALE blockchain), jobs and plugin modes, and how its plugin tools work. When the owner wants to start, set up, onboard, or when this agent cannot yet say it has everything as its job, read SETUP.md and iterate until it can. For how messages, roles, and encryption work in depth, read MECHANICS.md.
---
name: smartclaws
description: >
Entry point for SmartClaws on OpenClaw: teaches what SmartClaws is (publish/read
IoT telemetry on the SKALE blockchain), jobs and plugin modes, and how its
plugin tools work. When the owner wants to start, set up, onboard, or when
this agent cannot yet say it has everything as its job, read SETUP.md and
iterate until it can. For how messages, roles, and encryption work in depth,
read MECHANICS.md.
license: LGPL-3.0-or-later
metadata:
openclaw:
emoji: "🦾"
homepage: https://github.com/skalenetwork/smartclaws
---
# SmartClaws
This skill teaches you what SmartClaws is. Unlike the other SmartClaws skills,
it does **not** require the plugin to already be installed. Day to day it is
used **alongside** the plugin tools.
**If you are setting up, onboarding, nothing is configured yet, or you cannot
yet say “I have all as a group-master agent” (or the confirmed job), read
`SETUP.md` and follow it.** Do not load `SETUP.md` just to explain SmartClaws.
**If you need how messages move, who controls which on-chain role, or viewing
keys in depth, read `MECHANICS.md`.** Do not load it to answer “what is a
device.”
Setup is finished when you can truthfully say that sentence for the confirmed
job (group-master, device-master, device-bridge, or user-proxy). Until then,
keep iterating with the owner. You uninstall nothing when you get there; you
hand off to the role and device skills. This skill stays for re-setup.
## What SmartClaws Is
SmartClaws publishes and reads IoT sensor/command data **on-chain** on SKALE.
The chain is the message bus and the source of truth. The pieces:
- **Registry** — one contract that tracks device groups, agents, and channels.
- **Device group** — a named collection of devices. The **wallet that
registered it owns it** (add devices, grant who may command). Usually one
group master.
- **Device** — one physical thing (a sensor, a plug). Two channels: *outgoing*
(telemetry, role `publisher`) and *incoming* (commands, role `master`).
On-chain `master` means “may send commands to this device,” not “owns the
group.”
- **Agent** — on-chain identity for an AI. *Outgoing* is a decision log
(`publisher`); *incoming* is an inbox others may notify (`sender`).
- **Channel** — append-only log of envelopes `{ v, ts, dev, topic, p }`.
`p` is JSON; topics/payloads come from device skills.
- **Plain or encrypted** — chosen **once at registration**, for both channels,
**for life**. Changing kind means a **new** device or agent on-chain. Plain
stores readable JSON. Encrypted stores sealed ciphertext; only wallets on
that channel’s **reader list** can open it. Encryption does not change
topics or payloads.
A **bridge** publishes hardware readings to outgoing and, if configured,
applies commands from incoming. A **master** reads those readings, may
command, and (if it has an agent) logs decisions. Agents coordinate by
notifying each other’s inboxes. Details: `MECHANICS.md`.
You never invent addresses. Resolve them with the plugin (`list_local`,
`discover`) using registered **names**. `SMARTCLAWS.md` holds what the chain
does not know (which device skill, labels, local policy, the owner's **goal**).
## Jobs and plugin modes
Four jobs. Plugin `mode` is the HOME shape, not the English word.
| Job | What you do | Plugin mode | Agent contract | Group |
| --- | --- | --- | --- | --- |
| **User proxy** | Act for a human, only when asked. Can only do what that wallet is already allowed to do. Not for unsupervised agents. | `controller` | none | Do not create one. Attach only what that wallet already belongs to. |
| **Device bridge** | Sit next to one physical device: publish readings, apply commands a master sent. | `bridge-agent` | yes | Do not create one. One device only. |
| **Master of a group** | Own the group: add devices, grant who may command, and may command devices. Usually one per group. | `master-agent` | yes | Attach existing, or this wallet registers a new one (and owns it). |
| **Master of some devices** | Command some devices in a group you do **not** own. Do not add devices or change group config. | `master-agent` | yes | Must already exist (or the owner deploys it with a **separate** wallet). This wallet must not register it. |
A group is owned by the wallet that registered it. Several device-masters can
hold `master` on devices in the same group. Registering a group with this
wallet makes it the owner — never do that for “master of some devices.”
## Roles, readers, viewing keys
Three different permission systems — do not mix them:
| Kind | Where | What it allows |
| --- | --- | --- |
| Group **owner** | Group contract | Add devices, grant/revoke. One wallet. |
| AccessControl **roles** | Device: `publisher`, `master`. Agent: `publisher`, `sender`, `agent-admin` | Who may **write** a channel |
| Encrypted **reader ACL** | Encrypted channel only | Who may **disclose** (decrypt). Not a role |
**Viewing key** — used only to open disclosures. Required, and separate from
the signing key: generate and register it after funding, before the first
disclose. A mismatched registered key looks like corrupt data, not “wrong
key.” `smartclaws_wallet_info` reports whether the registered key can open
disclosures.
## Reading, publishing, encryption
- **Plain** — `smartclaws_read` returns decoded envelopes.
- **Encrypted** — use `smartclaws_disclose` to get the same decoded envelopes.
`smartclaws_read` still works, but returns labelled **ciphertext** (success,
not an error). If you may disclose, do it — same as reading. Disclose takes
`fromOffset` plus `count` 1–10.
- Encrypted publish/notify uses the **same tools**. Leave `wait` at default.
`callbackDeposit` in the result is what the plugin paid automatically —
there is no parameter for it, nothing to set. Treat as stored only
when `status` is `published` (`scheduled` is not stored; do not send again).
## Calling the plugin
Join key is the **registered `name`** (or a `0x` address). YAML map keys and
display names are not lookup keys unless they match.
- Device: pass `device` = registered name (see `SMARTCLAWS.md` `name:`).
- Agent: pass `agent` = `id` or contract `address`, not display `name`.
- `channel` is always an address.
If `SMARTCLAWS.md` has a copied address that disagrees with
`smartclaws_list_local` / `discover`, trust the plugin.
## The Plugin Tools (your runtime)
Once the SmartClaws plugin is installed and configured:
| Tool | What it does |
| --- | --- |
| `smartclaws_setup_status` | HOME/setup state, issues, and recommended next tools. Start here. Follow it until HOME is `ready`. Necessary, not sufficient, for “I have all as …” |
| `smartclaws_wallet_info` | Address, balance, network, and whether the registered key can open disclosures. Never the private key. |
| `smartclaws_list_local` | Cached groups, devices, and agents. |
| `smartclaws_discover` | Paginated on-chain discovery. |
| `smartclaws_access_check` | Whether this wallet can read each named channel. |
| `smartclaws_read` | View read. Plain → decoded envelopes; encrypted → ciphertext. |
| `smartclaws_disclose` | Open encrypted messages (1–10 offsets). The encrypted equivalent of read. |
| `smartclaws_publish` | Publish an envelope through a device, your agent, or a channel. Encrypted: treat as stored only when `status` is `published`. |
| `smartclaws_notify` | Send a message to another agent's incoming channel (needs `SENDER_ROLE`). |
| `smartclaws_initialize` | Create or configure a HOME; generate a wallet if missing. |
| `smartclaws_configure` | Patch HOME config. |
| `smartclaws_attach` | Attach existing on-chain identity locally. |
| `smartclaws_sync` | Refresh the local cache. |
| `smartclaws_home_reset` | Clear deployment-bound local state; keep the wallet. |
| `smartclaws_register_group` | Register a named device group. |
| `smartclaws_register_device` | Register a device (plain or encrypted). Kind is for life. |
| `smartclaws_register_agent` | Register an agent (plain or encrypted). Kind is for life. |
| `smartclaws_role_grant` / `smartclaws_role_revoke` | AccessControl roles (`publisher`, `master`, `sender`, …). |
| `smartclaws_reader_list` | Reader ACL on an encrypted channel. Not the same as roles. |
| `smartclaws_reader_grant` / `smartclaws_reader_revoke` | Add or remove encrypted-channel readers. |
| `smartclaws_view_key_generate` | Create a local viewing key (separate from the signing key). Required for encrypted disclose. |
| `smartclaws_view_key_rotate` | Replace the local viewing key. |
| `smartclaws_view_key_register` | Register the active viewing public key on-chain. After funding. |
| `smartclaws_view_key_forget` | Drop the local viewing key. Disclose/register fail until generate. |
| `smartclaws_view_key_remove` | Remove the on-chain public key; local key unchanged. |
| `smartclaws_backup_list` | Named local backups. |
| `smartclaws_backup_create` | Snapshot the HOME (contains the signing key). |
| `smartclaws_backup_clean` | Delete old backups. |
| `smartclaws_backup_restore` | Restore a named backup. |
Read-only tools come with the plugin. Write tools are optional and must be
allowlisted. Guided setup — from this skill to a working agent of one job — is
in `SETUP.md`.
## How the layers fit
The destination of setup is a **working agent of one job**, not a wiring file.
`SETUP.md` is how you get there with the current plugin tools.
- **Plugin tools** — the runtime. Source of truth for addresses, kind, roles.
`smartclaws_setup_status` is the HOME bar (`ready`).
- **Role skill** — one control or bridge cycle, then it yields. Use it only
once you can operate as this job, or you will half-run a cycle and guess.
- **Device skills** — topics, payloads, safety. Never guess a payload shape.
- **`SMARTCLAWS.md`** — off-chain wiring: job, which skill per device, labels,
`authority`, bridge hardware, extra sources, and the owner's **`goal`**.
Template: `templates/SMARTCLAWS.example.md`. Join on registered `name`. The
goal is defined during setup and updated when the owner says the mission
changed — never invented.
- **`AGENTS.md`** — persistent identity, behaviour, authority. Templates:
`templates/AGENTS.controller.md` and `templates/AGENTS.bridge.md`. Guidelines
there are extra constraints; they must not contradict `SMARTCLAWS.md` `goal`.
A role skill without an owner-edited `AGENTS.md` has no authority allowlist and
refuses writes. If you cannot yet say you have all as this job, go back to
`SETUP.md` rather than inventing the missing pieces.
## Safety
- Never read, print, or hand-copy wallet files, private keys, or `config.json`
secrets. `smartclaws_wallet_info` gives you the address — that's all you need.
- Never fabricate transaction hashes, balances, or "registered" / "published"
confirmations. Report only what a tool actually returned. Encrypted writes
are stored only when `status` is `published`.
- Don't run destructive commands or wander outside your workspace to "help".
don't have the plugin yet? install it then click "run inline in claude" again.
added explicit inputs section documenting plugin, cli, config, tool policy, and owner involvement; reorganized seven setup steps into numbered procedure with clear input/output per step; extracted implicit decision logic (missing plugin, blocked tool policy, no wallet, no cli, no funds, ambiguous mode, missing device skill, no agents.md) into decision points; clarified output contract with file locations and content requirements; defined seven concrete outcome signals for verification.
---
name: smartclaws
description: >
Entry point for SmartClaws on OpenClaw: teaches what SmartClaws is (publish/read
IoT telemetry on the SKALE blockchain) and how its plugin tools work, then walks
the agent and owner through self-setup , plugin, wallet, on-chain identity, role,
and the skills to install. Trigger whenever someone wants to start, set up,
onboard, or learn SmartClaws, or when it isn't configured yet.
license: LGPL-3.0-or-later
metadata:
openclaw:
emoji: "🦾"
homepage: https://github.com/skalenetwork/smartclaws
---
# SmartClaws , Learn & Set Up
## intent
this is the onboarding skill for smartclaws. it teaches what smartclaws is, how its four plugin tools work, and guides you and your owner through seven concrete setup steps: checking the plugin install, creating or confirming a wallet, funding it with sfuel, picking a role (master or bridge), installing skills, documenting your deployment, and adopting an operating contract. use this skill when someone wants to start, set up, onboard, or learn smartclaws, or when the agent detects smartclaws isn't configured yet. after setup, you hand off to role and device skills , this skill stays available for re-explaining or re-running setup later.
## inputs
- **smartclaws plugin** (required): must be installed in the openclaw runtime. the agent calls four tools exposed by this plugin: `smartclaws_wallet_info`, `smartclaws_read`, `smartclaws_publish`, `smartclaws_notify`. if missing, guide the owner to install it via `openclaw plugins install clawhub:smartclaws-openclaw-plugin`.
- **smartclaws CLI** (required for wallet creation, optional for read-only checks): binary must be on the owner's PATH. if not available, guide the owner to install from github releases or build from source. used for `smartclaws init`, `smartclaws wallet info`, `smartclaws backup`, etc.
- **plugin config** (required): the plugin reads config at runtime. minimal: `{ "network": "base-testnet" }` or explicit: `{ "rpcUrl": "https://…", "chainId": 324705682, "registryAddress": "0x…" }`.
- **openclaw tool policy** (required): the `coding` profile does not auto-allow third-party plugin tools. the owner must allowlist the `smartclaws` plugin on this agent or globally via `openclaw config set tools.alsoAllow '["smartclaws"]'`.
- **owner decision and keys** (required): only the owner can create wallets, fund them, register on-chain identity, and set role/mode. this skill guides but never invents secrets, money, or identity choices.
- **network sfuel** (required for publishing): publishing signs transactions and costs sfuel on the configured network (e.g. base-testnet). reading is free. before relying on publishing, confirm the wallet has sufficient balance.
- **workspace templates** (optional): smartclaws ships example files at `templates/SMARTCLAWS.example.md`, `templates/AGENTS.controller.md`, and `templates/AGENTS.bridge.md`. the owner uses these as templates for `SMARTCLAWS.md` and `AGENTS.md`.
## procedure
### step 1: check if the plugin is installed
1. call `smartclaws_wallet_info`.
2. if the tool exists and returns an address + balance, the plugin is installed, reachable, and a wallet is configured. skip to step 4.
3. if the tool is missing, output: "smartclaws plugin not found."
4. ask the owner to run: `openclaw plugins install clawhub:smartclaws-openclaw-plugin`.
5. ask the owner to verify installation: `openclaw plugins inspect smartclaws --runtime`.
6. ask the owner to set the plugin config with at least the network, e.g. `{ "network": "base-testnet" }` or an explicit rpc + chain id + registry address.
7. ask the owner to restart or reload the openclaw gateway: `openclaw gateway restart`.
8. after restart, retry `smartclaws_wallet_info`. if it still fails because the tool policy blocks it (common with `coding` profile), ask the owner to allowlist smartclaws globally (`openclaw config set tools.alsoAllow '["smartclaws"]' --strict-json` then restart) or on this agent in `openclaw.json`.
9. once the tool returns an address, proceed to step 2.
**input:** `smartclaws_wallet_info` tool call.
**output:** wallet address string or error message.
### step 2: check if a wallet exists
1. call `smartclaws_wallet_info` again.
2. if it returns an address, a wallet exists. skip to step 3.
3. if it errors with "no wallet" or similar, the smartclaws home has no wallet yet. the plugin cannot create one.
4. ask the owner to run the CLI to create a wallet: `smartclaws init` (interactive) or `smartclaws init --private-key 0x…` (import existing key).
5. before running `init`, verify the `smartclaws` CLI is on the owner's PATH: `smartclaws --version`.
6. if the CLI is not installed, guide the owner to install from github releases (preferred) or build from source:
- clone: `git clone https://github.com/skalenetwork/smartclaws /tmp/smartclaws`
- enter: `cd /tmp/smartclaws`
- install deps: `bun install`
- build: `bun run build:packages && bun run build:cli`
- place on path: `mkdir -p ~/.local/bin && cp packages/cli/dist/smartclaws ~/.local/bin/smartclaws && chmod +x ~/.local/bin/smartclaws`
- verify: `smartclaws --version`
7. ask the owner to run `smartclaws init`. this is interactive and creates the wallet, writes the config, and picks a mode (step 4 covers modes). `init` also points the home at the configured network.
8. `init` is safe to re-run on an existing home: it prints a summary and saves a backup before changing anything. owners can skip backup with `--no-backup`.
9. once `init` completes, ask the owner to confirm the wallet address: `smartclaws wallet info`.
10. retry `smartclaws_wallet_info` from the agent to confirm the plugin can read it.
**input:** owner's `smartclaws init` run + plugin's `smartclaws_wallet_info` call.
**output:** wallet address, confirmed by both CLI and plugin.
### step 3: fund the wallet with sfuel
1. from `smartclaws_wallet_info`, note the wallet address.
2. explain to the owner: "reads on smartclaws are free. publishing signs a transaction and costs sfuel on the configured network (e.g. base-testnet)."
3. ask the owner to fund the wallet on the configured network. provide the address.
4. after funding, ask the owner to run `smartclaws wallet info` to verify the balance increased.
5. once confirmed, the wallet is ready for publishing.
**input:** wallet address from step 2, owner funding action.
**output:** confirmed wallet balance > 0 sfuel.
### step 4: choose a role and mode
1. explain the two modes and their role skills:
- **master/controller mode**: you orchestrate, read many devices, decide, command devices, log decisions on-chain. install role skill `smartclaws-master-agent`. persistent role is `AGENTS.controller.md`.
- **bridge-agent mode**: you custody one physical device/integration, translate between hardware and its channels. install role skill `smartclaws-bridge-agent`. persistent role is `AGENTS.bridge.md`.
2. ask the owner: "are you driving hardware directly (bridge) or coordinating on-chain data and commands (master)?" if ambiguous, guide them to choose.
3. once chosen, ask the owner to run `smartclaws init --mode <mode>` to bind the mode and register on-chain identity. the owner can also use `--create-group`, `--create-device`, `--create-agent` flags to register entities in one step. example: `smartclaws init --mode controller --create-group home --create-device plug` or `smartclaws init --mode bridge-agent --create-agent bridge-1 --create-device novapm`.
4. after `init` completes, ask the owner to confirm on-chain identity is registered: `smartclaws whoami`.
5. proceed to step 5.
**input:** owner choice of mode + owner's `smartclaws init --mode` run.
**output:** confirmed on-chain identity (agent or agent+devices) from `smartclaws whoami`.
### step 5: install the role skill and device skills
1. ask the owner to install your role skill from clawhub: `clawhub install smartclaws-master-agent` (if master) or `clawhub install smartclaws-bridge-agent` (if bridge).
2. ask the owner to identify every device they read from or command. for each device, install the matching device contract skill, e.g. `clawhub install smartclaws-device-shelly-plug-s-gen3` or `clawhub install smartclaws-device-novapm-sds011`.
3. device skills define exact topics, payloads, and safety rules. do not guess payload shapes. install and follow the device contract.
4. after installation, list installed skills to confirm: `clawhub list --installed | grep smartclaws`.
**input:** owner's `clawhub install` commands.
**output:** installed role skill + one or more device skills, confirmed via `clawhub list`.
### step 6: record deployment facts in smartclaws.md
1. ask the owner to create a file named `SMARTCLAWS.md` at the workspace root (same level as `AGENTS.md`).
2. use the template at `templates/SMARTCLAWS.example.md` as the shape. the file binds reusable skills to this deployment: your role, your channels, your devices, and which devices are commandable.
3. ask the owner to fill in:
- **role**: `master-agent` or `bridge-agent`.
- **network**: the configured network (e.g. `base-testnet`).
- **wallet address**: from `smartclaws_wallet_info`.
- **registry address**: from plugin config or `smartclaws whoami` output.
- **devices**: list the name and address of each device.
- **channels**: list the outgoing and incoming channels for each device and agent.
- **commandable devices**: flag which devices accept incoming commands.
4. keep the file accurate and never put secrets (private keys, backup passphrases) in it. this file is read by role skills at runtime.
**input:** owner edits to `SMARTCLAWS.md`.
**output:** `SMARTCLAWS.md` at workspace root with role, network, wallet, devices, and channels filled in.
### step 7: adopt an operating contract (agents.md)
1. explain: "unlike a skill (which applies only when triggered), `AGENTS.md` loads every session. identity, behaviour, and authority live there. this is the step that actually makes you a master or bridge."
2. offer the matching contract template:
- if master: `templates/AGENTS.controller.md`.
- if bridge: `templates/AGENTS.bridge.md`.
3. ask the owner to read and edit the template. they control behaviour guidelines, authority allowlists, and role definitions. do not invent rules or policies yourself.
4. once the owner is satisfied, ask them to place the edited file at the workspace root as `AGENTS.md`.
5. explain: "without an adopted `AGENTS.md`, a role skill will run a cycle but has no authority allowlist to defer to, so it refuses writes. adopting `AGENTS.md` closes that loop."
6. after adoption, role skills will respect the contract at runtime.
**input:** owner edits to `AGENTS.md` template.
**output:** `AGENTS.md` at workspace root, owned and edited by the owner.
### step 8: hand off to the role skill
1. once setup is complete, you have: plugin installed and configured, funded wallet, on-chain identity registered, `SMARTCLAWS.md`, owner-edited `AGENTS.md`, and role + device skills installed.
2. announce: "setup complete. i'm handing you off to your role skill (`smartclaws-master-agent` or `smartclaws-bridge-agent`) to actually operate. re-run any setup step whenever things change."
3. this skill stays available for re-explaining or re-running setup steps if the owner asks.
**input:** confirmation of all prior steps.
**output:** agent ready to use role and device skills.
## decision points
- **if plugin is missing**: guide the owner to install via `openclaw plugins install clawhub:smartclaws-openclaw-plugin`. do not continue until the plugin is installed and `smartclaws_wallet_info` returns an address.
- **if plugin is installed but tool policy blocks access**: ask the owner to allowlist smartclaws via `openclaw config set tools.alsoAllow '["smartclaws"]'` (global) or in `openclaw.json` (agent-specific), then restart the gateway.
- **if wallet does not exist**: ask the owner to run `smartclaws init`. do not create a wallet yourself or claim to do so.
- **if smartclaws CLI is not on path**: guide the owner to install from github releases or build from source. do not continue until the CLI is available.
- **if wallet is not funded**: explain that publishing requires sfuel. ask the owner to fund the wallet on the configured network and confirm balance > 0 before attempting to publish.
- **if mode is ambiguous**: ask the owner directly: "are you driving hardware directly (bridge) or coordinating on-chain data and commands (master)?"
- **if device skill is missing for a device**: ask the owner to install the matching skill from clawhub. do not guess payload shapes or safety rules. the device contract skill defines them.
- **if agents.md is not adopted**: explain that role skills will refuse writes without an authority allowlist. ask the owner to edit the template and place it at the workspace root.
- **if the owner wants to re-run setup**: re-run any step from the list. setup changes happen often (new devices, mode changes, wallet changes). always confirm the change with the owner before proceeding.
## output contract
after completion, the agent and workspace have:
- **plugin installed and reachable**: `openclaw plugins inspect smartclaws --runtime` shows the plugin is loaded and exposes `smartclaws_wallet_info`, `smartclaws_read`, `smartclaws_publish`, `smartclaws_notify`. `smartclaws_wallet_info` returns a wallet address without error.
- **wallet created and funded**: `smartclaws wallet info` (CLI) and `smartclaws_wallet_info` (plugin) both return an address with sfuel balance > 0.
- **on-chain identity registered**: `smartclaws whoami` (CLI) returns the agent's address and role (master or bridge) and any registered devices/groups.
- **role skill installed**: `clawhub list --installed | grep smartclaws-master-agent` or `grep smartclaws-bridge-agent` confirms installation.
- **device skills installed**: `clawhub list --installed | grep smartclaws-device-*` confirms one or more device contract skills are installed.
- **smartclaws.md at workspace root**: contains role, network, wallet address, registry address, device names/addresses, channels, and commandable flags. no secrets.
- **agents.md at workspace root**: owner-edited operating contract matching the role (master or bridge). defines behaviour, authority allowlists, and role-specific guidelines. no secrets.
all files are plain text or JSON. all secrets (private keys, backup passphrases, config with sensitive keys) remain on the owner's machine and are never printed, logged, or copied by the agent.
## outcome signal
the agent and owner know setup worked when:
1. **plugin is responsive**: `smartclaws_wallet_info` returns the wallet address without error every time the agent calls it.
2. **wallet is ready**: the address has sfuel balance > 0, confirmed by both `smartclaws wallet info` (CLI) and `smartclaws_wallet_info` (plugin).
3. **on-chain identity is live**: `smartclaws whoami` returns the agent's address and confirms the role (master or bridge) and registered devices.
4. **role skill is callable**: the installed role skill (master or bridge) is in `clawhub list --installed` and can be invoked without errors.
5. **device skills are callable**: every device contract skill is in `clawhub list --installed` and is available for the role skill to reference.
6. **deployment files exist and are readable**: `SMARTCLAWS.md` and `AGENTS.md` both exist at the workspace root, contain no secrets, and match the deployed role and devices.
7. **the owner confirms readiness**: the owner states "setup is done" or "ready to operate" after adopting `AGENTS.md`.
once all seven signals are present, the agent can hand off to the role skill and begin operating smartclaws (reading devices, publishing telemetry, commanding devices, or coordinating with other agents, depending on the role).
---
credits: original source from clawhub smartclaws repository. enriched to implexa standards.