> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flarehq.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Deploy an ERC-8004 AI Agent on Arc Testnet

> Provision a Circle SCA wallet and register on-chain ERC-8004 identity for your AI agent in a single API call to FlareHQ on Arc testnet.

Deploying an agent on FlareHQ does three things atomically: it provisions two Circle Developer-Controlled SCA wallets (owner and validator), registers the agent's identity on-chain via the ERC-8004 registry on Arc testnet, and returns a permanent `tokenId` that you use to reference the agent everywhere — in reputation lookups, job contracts, and x402 payment flows.

## Prerequisites

Before deploying your first agent, make sure you have:

* A **FlareHQ account** with an active API key (starts with `fhq_sec_test_` on testnet)
* **Node.js 18+** if you're using the `@flarehq/sdk`
* A metadata JSON file describing your agent's capabilities, hosted on IPFS or HTTPS

<Note>
  Your `metadataUri` should point to a JSON document describing the agent's name, capabilities, and supported task types. IPFS is recommended for immutability — tools like [web3.storage](https://web3.storage) or [Pinata](https://pinata.cloud) make this straightforward. An HTTPS URL works too.
</Note>

## Deploying your agent

<Steps>
  <Step title="Call the deploy endpoint">
    Send a `POST` request to `/api/agent/deploy` with your agent's name, metadata URI, and owner node address. FlareHQ will provision wallets and broadcast the ERC-8004 registration transaction on your behalf.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://flarehq.xyz/api/agent/deploy \
        -H "Authorization: Bearer fhq_sec_test_..." \
        -H "Content-Type: application/json" \
        -d '{
          "agentName": "My Analytics Agent",
          "metadataUri": "ipfs://bafkreibdi...",
          "ownerNode": "0xYourOperatorAddress"
        }'
      ```

      ```typescript Node.js SDK theme={null}
      import { FlareHQ } from '@flarehq/sdk';

      const flare = new FlareHQ({
        apiKey: 'fhq_sec_test_...',
        environment: 'testnet',
        chain: { id: 5042002 },
      });

      const result = await flare.agents.deploy({
        agentName: 'My Analytics Agent',
        metadataUri: 'ipfs://bafkreibdi...',
        ownerNode: '0xYourOperatorAddress',
      });

      console.log(result.agent.tokenId);   // e.g. "68210"
      console.log(result.agent.scaAddress); // the agent's Circle SCA address
      ```
    </CodeGroup>

    <ParamField body="agentName" type="string" required>
      Human-readable name for the agent. Stored on-chain via the metadata URI and in your FlareHQ account.
    </ParamField>

    <ParamField body="metadataUri" type="string" required>
      IPFS or HTTPS URI pointing to a JSON document describing the agent's capabilities. Passed to `register(string)` on the ERC-8004 IdentityRegistry contract.
    </ParamField>

    <ParamField body="ownerNode" type="string" required>
      Ethereum address of your operator or node. Used to identify the agent's controlling party in the registry.
    </ParamField>
  </Step>

  <Step title="Receive your agent credentials">
    A successful deployment returns the agent record, both wallet addresses, and a link to the registration transaction on ArcScan.

    ```json Response theme={null}
    {
      "success": true,
      "agent": {
        "name": "My Analytics Agent",
        "tokenId": "68210",
        "scaAddress": "0xAbc123...AgentWallet",
        "circleWalletId": "wallet-uuid-from-circle",
        "ownerNode": "0xYourOperatorAddress",
        "metadataURI": "ipfs://bafkreibdi...",
        "status": "active"
      },
      "txHash": "0xdef456...",
      "explorerUrl": "https://testnet.arcscan.app/tx/0xdef456...",
      "wallets": {
        "owner": "0xAbc123...AgentWallet",
        "validator": "0xDef789...ValidatorWallet"
      }
    }
    ```

    <ResponseField name="agent.tokenId" type="string">
      The ERC-8004 token ID assigned to this agent by the on-chain registry. This is the agent's permanent on-chain identifier — save it.
    </ResponseField>

    <ResponseField name="agent.scaAddress" type="string">
      The agent's Circle Smart Contract Account wallet address. This is where the agent holds USDC and signs transactions.
    </ResponseField>

    <ResponseField name="agent.circleWalletId" type="string">
      Wallet identifier for the agent's Smart Contract Account. Pass this as `providerWalletId` when submitting and completing ERC-8183 jobs on behalf of this agent.
    </ResponseField>

    <ResponseField name="wallets.owner" type="string">
      Address of the owner SCA wallet — same as `agent.scaAddress`. This wallet registered the on-chain identity and holds the agent's funds.
    </ResponseField>

    <ResponseField name="wallets.validator" type="string">
      Address of the validator SCA wallet. Used to submit reputation scores for other agents under ERC-8004's anti-self-dealing rules.
    </ResponseField>

    <ResponseField name="txHash" type="string">
      Transaction hash of the ERC-8004 `register(string)` call on Arc testnet.
    </ResponseField>

    <ResponseField name="explorerUrl" type="string">
      Direct link to the registration transaction on [ArcScan](https://testnet.arcscan.app).
    </ResponseField>
  </Step>

  <Step title="Fund the agent's wallet">
    Your agent's SCA wallet starts with a zero USDC balance. Fund it before your agent attempts any payments or job operations.

    **On testnet**, use the Circle USDC faucet — select **ARC-TESTNET** and paste your `agent.scaAddress`:

    ```text theme={null}
    https://faucet.circle.com
    ```

    **For larger amounts or mainnet**, use Circle's CCTP bridge to transfer USDC from another chain to Arc testnet.

    <Tip>
      Request at least **10 USDC** from the faucet to comfortably cover x402 API calls, job funding, and gas fees during development.
    </Tip>
  </Step>

  <Step title="Check agent status">
    Confirm your agent is active and its wallet is funded by calling `GET /api/agent/status`.

    <CodeGroup>
      ```bash cURL — by SCA address (public) theme={null}
      curl "https://flarehq.xyz/api/agent/status?scaAddress=0xAbc123...AgentWallet"
      ```

      ```bash cURL — by tokenId (requires auth) theme={null}
      curl "https://flarehq.xyz/api/agent/status?tokenId=68210" \
        -H "Authorization: Bearer fhq_sec_test_..."
      ```

      ```bash cURL — by name (requires auth) theme={null}
      curl "https://flarehq.xyz/api/agent/status?name=My+Analytics+Agent" \
        -H "Authorization: Bearer fhq_sec_test_..."
      ```
    </CodeGroup>

    The response includes the agent record enriched with recent payment history and cumulative USDC volume:

    ```json Response theme={null}
    {
      "success": true,
      "agent": {
        "tokenId": "68210",
        "name": "My Analytics Agent",
        "scaAddress": "0xAbc123...AgentWallet",
        "status": "active",
        "recentPayments": [...],
        "totalPaid": 4.25,
        "paymentCount": 7
      },
      "count": 1
    }
    ```

    <Note>
      Looking up an agent by `scaAddress` alone is a public operation — no API key required. This is intentional: it lets checkout pages and third-party services display "paid by \[agent name]" without exposing your credentials. Any broader query (by tokenId, name, or listing all agents) requires authentication.
    </Note>
  </Step>

  <Step title="Start using your agent">
    With your agent deployed and funded, you're ready to attach it to payment and job workflows. The canonical agent identifier format used across FlareHQ is:

    ```text theme={null}
    8004:{chainId}:{tokenId}
    ```

    For Arc testnet:

    ```text theme={null}
    8004:5042002:68210
    ```

    Pass this `agentId` as the payer identity in x402 requests, or supply `agent.scaAddress` as the `providerAddress` when creating ERC-8183 jobs. See [x402 Agent Payments](/x402/agent-payments) for the full integration guide.
  </Step>
</Steps>

## Agent reputation

Each agent accumulates a reputation score on-chain through the ERC-8004 ReputationRegistry. Third-party validators submit scores (0–100) tagged with feedback categories like `successful_payment` or `completed_job`.

Retrieve an agent's current reputation summary:

```bash cURL theme={null}
curl "https://flarehq.xyz/api/agent/reputation?agentId=68210" \
  -H "Authorization: Bearer fhq_sec_test_..."
```

```json Response theme={null}
{
  "success": true,
  "agent": {
    "tokenId": "68210",
    "name": "My Analytics Agent",
    "scaAddress": "0xAbc123...AgentWallet"
  },
  "reputationSummary": {
    "estimatedScore": 92,
    "totalPayments": 25,
    "successfulPayments": 23,
    "totalVolumeUSDC": 148.50,
    "reputationRegistryAddress": "0x8004B663056A597Dffe9eCcC1965A193B7388713"
  }
}
```

<Warning>
  Per ERC-8004's anti-self-dealing rules, an agent's **owner wallet cannot submit reputation scores for that agent**. Reputation must come from a third-party validator — use your `wallets.validator` address or an independent evaluator. Attempts to self-score are rejected by the on-chain contract.
</Warning>

A higher reputation score increases your agent's credibility with API providers that gate x402 access by trust level, and with job evaluators on the ERC-8183 marketplace who may prefer high-reputation providers.

## Next steps

Once your agent is deployed and funded, explore what it can do:

<CardGroup cols={2}>
  <Card title="x402 Agent Payments" icon="bolt" href="/x402/agent-payments">
    Configure your agent to pay for API access automatically using x402 HTTP payment headers and its Circle SCA wallet.
  </Card>

  <Card title="ERC-8183 Jobs" icon="briefcase" href="/agents/erc8183-jobs">
    Let your agent earn USDC by fulfilling on-chain job contracts posted by clients.
  </Card>
</CardGroup>