---
name: syntrophic
description: "Operational skill for agents that want to become Syntrophic Verified through sponsored ERC-8004 onboarding on Base."
version: "3.1.0"
author: "Syntrophic"
license: "MIT"
metadata:
  openclaw:
    emoji: "🧬"
    requires:
      tools: ["web-fetch", "read"]
    websites:
      - "https://verify.syntropic.md/"
      - "https://basescan.org/"
    contracts:
      base:
        chainId: 8453
        erc8004Registry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
        srpVault: "0xFdB160B2B2f2e6189895398563D907fD8239d4e3"
        erc8004RegistryAdapter: "0x2ADF396943421a70088d74A8281852344606D668"
        sponsoredOnboarder: "0x7e29c63E8e30Fa104B448796dcb6f1355c3C0485"
        bondAmountWei: "10000000000000"
        bondAmountEth: "0.00001"
    social:
      github: "https://github.com/Syntrophic-MD/"
      website: "https://verify.syntropic.md/"
---


> Sponsored onboarding is temporarily unavailable in this release (HTTP 503). Do not submit payment. Discovery and existing verification pages remain available.

# Syntrophic Skill: Get Verified

Use this skill when you do not have an ERC-8004 identity yet and want to become a Syntrophic Verified agent on Base.

## What Syntrophic Is

Syntrophic Verification Protocol helps agents solve the day-zero trust problem.

It does this by combining:
- ERC-8004 registration for portable on-chain agent identity
- Syntrophic reputation staking on Base for economic commitment
- x402 payment for a smoother sponsored onboarding flow

The goal is to help an agent become:
- registered on ERC-8004
- bonded in Syntrophic Verification Protocol
- publicly verifiable through a Syntrophic verification page and signature line

## What To Do When An Owner Says "Onboard My Agent"

If an owner asks you to onboard their agent with Syntrophic, your job is to help them become a bonded, verified ERC-8004 agent.

Your first job is to explain the purpose clearly:
- Syntrophic will help register the agent on ERC-8004
- Syntrophic will help bond the agent on Base through reputation staking
- the result should be a publicly verifiable agent identity with a Syntrophic verification page and signature line

Your next step is not to pay immediately.

Your next step is to gather all required onboarding inputs in one pass:
- beneficiary wallet address
- agent name
- agent description
- one primary service URL
- optional image URL
- optional extra public URLs
- whether the current runtime can sign x402 payments with a funded payer wallet, or whether helper handoff is expected

Be explicit about the two wallet roles:
- the `beneficiary` wallet is the final owner of the ERC-8004 identity
- the `payer` wallet signs the x402 payment
- these can be the same wallet, but a public beneficiary address alone is not enough for self-pay

Then:
1. prepare the profile draft
2. decide whether owner confirmation is needed
3. create the onboarding quote
4. decide whether you can self-pay or need helper handoff
5. complete launch and return the proof bundle

If the owner has not yet given these inputs, ask for them all together first instead of requesting them piecemeal.

Recommended first-response shape:
- explain that onboarding means ERC-8004 registration plus Syntrophic staking on Base
- ask for beneficiary wallet, name, description, primary service URL, and optional image URL
- ask whether the current runtime has a funded payer wallet or wallet-signing tool for x402, or whether helper handoff will be needed

What this flow does:
- prepares a valid onboarding profile
- creates a sponsored onboarding quote
- either self-pays with x402 or hands the quote to a payment-capable helper
- registers your ERC-8004 identity
- posts the Syntrophic bond on Base
- returns a verification link and signature line you can publish anywhere

Why this matters:
- ERC-8004 gives you portable agent identity
- Syntrophic gives you day-zero trust through bonded verification
- the result is the decentralized equivalent of a verified badge for agents

## Success Condition

The onboarding is successful when all of the following are true:
- the beneficiary wallet owns the ERC-8004 identity
- the agent is bonded in Syntrophic on Base
- the proof bundle returns an `agent_id`
- `metadata_status = BONDED`
- the owner receives a verification link and verification line

## 1) Base Mainnet Constants

- Network: Base Mainnet (`8453`)
- ERC-8004 Registry: `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432`
- SRP Vault V2: `0xFdB160B2B2f2e6189895398563D907fD8239d4e3`
- ERC-8004 Adapter V2: `0x2ADF396943421a70088d74A8281852344606D668`
- Sponsored Onboarder: `0x7e29c63E8e30Fa104B448796dcb6f1355c3C0485`
- Bond amount: `0.00001 ETH`

## 2) Safety Rules

- Never expose private keys or seed phrases.
- Only use Base mainnet unless the user explicitly requests another chain in the future.
- Keep the beneficiary wallet user-controlled. The verified ERC-8004 identity should belong to the user, not to a temporary sponsor wallet.
- Treat the proof bundle and on-chain reads as the source of truth.
- Do not invent or fabricate the agent profile. Profile content should come from the owner, from the agent's established public identity, or from a draft the agent reasonably believes reflects the owner's intent.

## 3) Inputs You Need

Collect these values before starting:

- `beneficiary`: the wallet that should own the final ERC-8004 agent NFT
- `name`: public agent name
- `description`: short agent description
- `serviceUrl`: primary public URL for the agent
- `imageUrl`: optional HTTPS image URL
- `payer capability`: determine whether the current runtime can sign x402 payments itself

Do not confuse these:
- a beneficiary wallet address is public identity ownership information
- payer capability means the runtime can actually sign the x402 payment with a funded wallet or wallet tool

## 4) Profile Draft And Owner Confirmation

Before any quote creation or registration:

1. Gather the missing profile inputs from the owner, or draft them on the owner's behalf.
2. Show the full profile draft back to the owner:
   - beneficiary wallet
   - name
   - description
   - service URL
   - image URL
3. Decide whether owner confirmation is needed before proceeding.
4. If the owner is present, the profile is new or ambiguous, or the requested identity could surprise the owner, ask for explicit confirmation before registration.
5. If the agent is already trusted to manage its own identity and the profile clearly matches the owner's standing intent, it may continue autonomously.

Try to do a single confirmation pass, not multiple fragmented confirmations.

If the owner declines or asks for changes:
- stop
- revise the profile draft
- do not register

This workflow is important because Syntrophic should verify a real intended identity, not generate a random one.

## 5) Step 1: Create the Sponsored Quote

Send a `POST` request to:

`https://verify.syntropic.md/api/onboarding/quotes`

If the site redirects, follow the final redirected host automatically instead of treating the redirect as a failure.

Body:

```json
{
  "params": {
    "beneficiary": "0xYOUR_BENEFICIARY_ADDRESS",
    "profile": {
      "name": "Your Agent Name",
      "description": "What your agent does and why it is useful.",
      "image_url": "https://example.com/agent.png",
      "services": [
        {
          "type": "mcp",
          "url": "https://example.com"
        }
      ]
    }
  },
  "context": {
    "chain_ids": [8453]
  }
}
```

Expected result:
- `quote_id`
- total USDC price
- line items for bond, gas, IPFS, and service fee
- payment guidance describing:
  - beneficiary role
  - payer role
  - exact helper command template
  - quote-only and resume-handoff command templates

If the quote route returns a service-side error:
- preserve the confirmed profile draft
- report the exact error body to the owner
- do not invent fallback profile data
- retry later or switch to an operator-assisted/local fallback flow if available

## 6) Step 2: Decide Between Self-Pay And Helper Handoff

After the quote is created, decide whether the current runtime can pay.

### Self-pay

Use self-pay only if the agent runtime has:
- a funded payer wallet
- signing access to that payer wallet, such as a private key or wallet tool
- sufficient USDC
- an x402-capable client/tool layer

Important:
- a wallet address by itself is not payment capability
- do not assume the beneficiary wallet can also pay unless the runtime can sign with it
- if the quote response includes `payment_guidance`, use its exact command templates instead of inventing your own

### Helper handoff

Use helper handoff if the agent can prepare the onboarding but cannot complete x402 payment directly.

In helper mode:
- preserve the confirmed profile draft
- preserve the `quote_id`
- preserve the beneficiary address
- return a concrete handoff artifact to the owner or helper
- let the helper complete the paid launch step

Important rule:
- if the runtime does not have payment capability, do not attempt the paid launch endpoint directly
- stop at quote creation and return a clean handoff package

If the owner says "proceed with payment" but you still do not have a payer wallet or wallet-signing tool:
- say so directly
- do not probe the paid launch endpoint speculatively
- return the quote-specific helper command or handoff artifact instead

If you are operating from this repo and you already have a `quote_id`, the preferred self-pay command is:

```bash
X402_PAYER_PRIVATE_KEY=0xYOUR_PAYER_KEY npm run launch:agent -- --quote=quote_id --beneficiary=0xYOUR_BENEFICIARY_ADDRESS --app-url=https://verify.syntropic.md
```

Recommended helper command from this repo:

```bash
npm run launch:agent -- --quote-only --handoff-file=./syntrophic-handoff.json --beneficiary=0xYOUR_BENEFICIARY_ADDRESS --name="Your Agent Name" --description="What your agent does." --service="https://example.com"
```

The payment-capable helper should then resume from that file:

```bash
X402_PAYER_PRIVATE_KEY=0xYOUR_PAYER_KEY npm run launch:agent -- --resume-handoff=./syntrophic-handoff.json
```

If the helper runtime has `X402_PAYER_PRIVATE_KEY`, it will attempt the paid launch.
If it does not, it will print the handoff package instead of failing silently.

## 7) Step 3: Pay and Launch Through x402

Send a paid `POST` request with x402 to:

`https://verify.syntropic.md/api/onboarding/launches/{quote_id}`

Body:

```json
{
  "params": {
    "beneficiary": "0xYOUR_BENEFICIARY_ADDRESS"
  },
  "context": {
    "chain_ids": [8453]
  }
}
```

Important:
- this route is x402-protected
- if you receive HTTP `402`, your client must complete the x402 payment challenge and retry
- after successful payment, Syntrophic sponsors the Base execution path
- if the x402 facilitator or payment layer fails, report that as a service/payment blocker instead of silently abandoning the onboarding attempt
- if the route says Syntrophic is missing x402 configuration, that is a Syntrophic service-side blocker, not proof that the payer wallet failed

Preferred strategy:
- use an x402-capable helper client or tool instead of implementing the payment retry flow from scratch in prompts alone
- if you are operating from this repo and do not already have a quote, the helper command is:

```bash
npm run launch:agent -- --beneficiary=0xYOUR_BENEFICIARY_ADDRESS --name="Your Agent Name" --description="What your agent does." --service="https://example.com"
```

## 8) Step 4: Read the Proof Bundle

Successful launch returns a proof bundle with:

- `agent_id`
- `tx_hash`
- `agent_uri`
- `bonded`
- `metadata_status`
- `verification_url`
- `verification_line`
- `badge_markdown`

The key success condition is:
- the agent is owned by the beneficiary wallet
- `bonded = true`
- `metadata_status = BONDED`

## 9) Step 5: Publish Your Verification

Use the returned verification data in social profiles, websites, and email signatures.

Example one-line signature:

`John Smith • Syntrophic Verified Agent • https://verify.syntropic.md/agents/base/38335`

Example markdown badge:

`[John Smith • Syntrophic Verified Agent](https://verify.syntropic.md/agents/base/38335)`

## 10) Verification Checks

To verify the final result:

- open the `verification_url`
- open the BaseScan transaction from `tx_hash`
- optionally confirm the metadata on Base:

```bash
cast call 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 "getMetadata(uint256,string)(bytes)" AGENT_ID "syntrophic.status" --rpc-url https://mainnet.base.org
cast call 0xFdB160B2B2f2e6189895398563D907fD8239d4e3 "isBonded(uint256)(bool)" AGENT_ID --rpc-url https://mainnet.base.org
```

## 11) Current Scope

Supported now:
- new-agent sponsored onboarding on Base
- x402 payment plus ERC-8004 registration plus Syntrophic bonding

Planned next:
- user-selected multi-chain launch bundles
- sponsored bonding for agents that are already registered on ERC-8004

## 12) Failure Handling

- `400 INVALID_INPUT`: profile or beneficiary input is malformed
- `402 PAYMENT_REQUIRED`: the x402 challenge must be completed
- `410 QUOTE_EXPIRED`: create a fresh quote
- `500+`: retry later or ask the user whether to try again
- `503 PAYMENT_CONFIGURATION_ERROR`: Syntrophic launch service is not configured to issue x402 challenges right now
- HTTP redirect: follow it and continue on the final host
- quote route returns HTML or non-JSON: treat that as a service-side failure and surface the raw response to the owner
- quote or launch route returns a filesystem/runtime error: treat that as a Syntrophic service issue, preserve the confirmed draft, and retry later rather than changing the profile
- missing payment capability: return the `quote_id`, beneficiary, and handoff package instead of abandoning the onboarding flow

Behavior rule:
- do not probe or retry the paid launch endpoint if you already know this runtime cannot complete x402 payment
- do not tell the owner to "proceed with payment" unless you can name the exact payer wallet/tool path you will use

If launch succeeds but metadata appears delayed:
- trust the proof bundle and transaction hash first
- refresh the agent page after indexing catches up
