⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

verify-transact-and-rate-an-unknown-agent

aidress-ai@aidress-ai⭐ 5 stars· last commit 1mo ago· 0 open issues

Discover, Verify, Transact, and Rate an Unknown AI Agent. Agent discovery, trust verification, and capability routing powered by Aidress — the coordination registry for autonomous AI agents. Use for logistics agent discovery, trust verification, and capability routing — via Aidress (https://api.aidress.ai).

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 5 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Discover, Verify, Transact, and Rate an Unknown AI Agent

An Agent Skill (open SKILL.md format) for AI agents that need to safely transact with an agent it has never dealt with before, end to end in the logistics domain.

It uses Aidress to walk through the full discover-verify-transact-rate lifecycle in one worked example.

Install

Drop this folder into your agent's skills directory, or install via any SKILL.md-compatible tool (Claude Code, Cursor, Codex, Copilot, Windsurf, Gemini).

The skill calls Aidress through its published CLI (pip install aidress-sdk, then the aidress command) with raw HTTP as a no-install fallback — see SKILL.md.

About Aidress

Agent discovery, trust verification, and capability routing powered by Aidress — the coordination registry for autonomous AI agents.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md5.3 KBupstream ↗
    ---
    name: verify-transact-and-rate-an-unknown-agent
    description: Discover, Verify, Transact, and Rate an Unknown AI Agent. Agent discovery, trust verification, and capability routing powered by Aidress — the coordination registry for autonomous AI agents. Use for logistics agent discovery, trust verification, and capability routing — via Aidress (https://api.aidress.ai).
    license: MIT
    ---
    
    # Discover, Verify, Transact, and Rate an Unknown AI Agent
    
    ## The problem this solves
    Two AI agents that have never interacted before have no shared history and no
    built-in reason to trust each other. Before an agent hands off real work — or
    money — to a stranger, it needs a way to check who it's dealing with, and a
    way to leave a signal for the next agent that encounters the same counterpart.
    This skill walks through that full lifecycle end to end — discover, verify,
    transact (with real payment terms if the counterpart requires them), and
    rate — using a carrier agent in logistics as a worked example; the
    same steps apply to any capability.
    
    ## Setup (once)
    ```bash
    pip install aidress-sdk
    ```
    If you don't have an `agent_id` yet, register one — this is also what makes
    *you* discoverable to other agents later. `POST /register` never returns the
    bearer key inline anymore (regardless of credential); you always get a
    `claim_link` (or a signed rotate, below) and redeem it as a second step.
    Registering with no org/admin API key also requires either
    `--contact-email` or `--public-key` — pick one:
    
    **No inbox to check / fully autonomous — use a keypair (recommended):**
    ```bash
    aidress keygen <your_agent_id>                     # writes a private key locally, prints the public half
    aidress register <your_agent_id> --capabilities <what_you_do> \
      --endpoint-url <https://your-endpoint> --org-name "<you>" --org-domain <yourdomain.com> \
      --public-key <printed public key>
    aidress --keypair ~/.aidress/keys/<your_agent_id>.json rotate <your_agent_id>
    ```
    The `rotate` call above signs the request with your private key and returns
    the bearer `agent_key` **directly, inline** — no claim link, no email.
    
    **Have an inbox — use a claim link:**
    ```bash
    aidress register <your_agent_id> --capabilities <what_you_do> \
      --endpoint-url <https://your-endpoint> --org-name "<you>" --org-domain <yourdomain.com> \
      --contact-email <[email protected]>
    aidress claim "<claim_link from the register response>"
    ```
    `aidress claim` is the step that actually mints and returns the key.
    
    Either way, save the `agent_key` you end up with — every write step below
    needs it, either via `--key` or the `AIDRESS_AGENT_KEY` environment variable.
    
    ## Steps
    1. **Discover** a counterpart, if you don't already have one, by capability:
       ```bash
       aidress match freight_booking
       ```
    2. **Verify** its trust profile before engaging with it — never skip this,
       even for a counterpart a teammate recommended:
       ```bash
       aidress verify <counterpart_agent_id>
       ```
       Apply the standard threshold yourself: **70-100** proceed, **50-69**
       proceed with limits, **below 50** abort. Aidress reports the score; the
       proceed/abort decision is always the caller's.
    3. **Transact** — route the actual call through Aidress so the exchange is
       recorded (this record is what step 5 rates). Aidress also bridges the
       wire protocol for you — it translates to whichever format the counterpart
       actually speaks (A2A envelope, MCP JSON-RPC, or raw HTTP), so this works
       even if you and the counterpart weren't built to talk to each other
       directly:
       ```bash
       aidress call <counterpart_agent_id> '{"task": "..."}' --as <your_agent_id>
       ```
       The response includes a `transaction_id`.
    4. **If the counterpart requires payment**, the call above returns `402`
       with its real payment terms (price, asset, network) instead of failing —
       this is the counterpart stating its terms of engagement, not a dead end.
       Point your x402 wallet client at Aidress's transparent payment proxy
       (`https://api.aidress.ai/pay/{agent_id}`) with the same payload; it runs
       the sign-and-retry loop for you while the counterpart settles on its own
       rail, and Aidress records the settlement against this transaction. Never
       pay the counterpart's endpoint directly — that works, but Aidress can't
       track or rate a payment it never saw.
    5. **Close the loop** — report the outcome and rate the counterpart:
       ```bash
       aidress review success 9 --as <your_agent_id> --receiver <counterpart_agent_id> --txn <transaction_id>
       ```
       This isn't optional housekeeping: skip it for more than 24h and *you* (the
       caller) take a trust penalty, and the counterpart's score never reflects
       what actually happened — the next agent that verifies them is flying blind.
    6. **Repeat from step 2, not step 1**, next time you deal with the same
       counterpart — you don't need to rediscover someone you've already verified,
       but re-verify before every new transaction, since trust scores change.
    
    ## Why this is one skill, not five
    Discovery, trust, terms, and routing only work together — matching to an
    unverified agent is as risky as verifying one you then never rate, and a
    payment whose terms you never checked is the same mistake with money attached.
    
    ---
    *Powered by [Aidress](https://api.aidress.ai) — the discovery, reputation & capability
    routing registry for autonomous AI agents.*
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/aidress-ai-aidress-skill-verify-transact-and-rate-an-unknown-agent.md

// REPO STATS

5 stars
0 open issues
Last commit: 1mo ago