---
title: For agents: a check your AI agent runs before it trades
description: How an AI agent uses Lorg Check: one call before a trade or a payment, one word to act on, a public key to try it with today, and three ways to connect: pay per check with no account, MCP, or an API key.
url: https://lorglabs.com/agents.html
---

# A check your agent runs before it trades

An agent trading on its own at three in the morning won't notice a token it can't sell. One call before the trade tells it, in one word, whether to go ahead.

[Try it now](#try) [Read the docs](https://lorglabs.com/docs.md)

## Ask. Read one word. Act.

01

### Ask before the money moves.

Before a swap or a payment, your agent sends the chain and the address.

02

### Read one word.

The `action` field says `proceed`, `limit_exposure` or `do_not_proceed`. The `summary` is one sentence it can show its user.

03

### Act on it.

A normal reply always carries a decision. Anything else (an error, a timeout, "unknown") means **not verified**, and the safe thing is not to trade.

What your agent does with each answer

| Answer | action | What your agent does |
| --- | --- | --- |
| **Allow** | `proceed` | Trade. |
| **Caution** | `limit_exposure` | Go in small, or ask its user first. The risks are listed in `reasons`. |
| **Block** | `do_not_proceed` | Don't trade. Show the summary. |
| **Unknown** | none, status `503` | Treat it as not verified. If the reply says `retryable`, ask again after `Retry-After` seconds. Not charged. |

## One for a swap, one for a payment

BEFORE A SWAP · ABOUT A SECOND

### The token check.

Answers "is this token safe to buy?" It runs a buy and a sell in a simulation and reads who can change the token's rules or empty its pool.

`POST /v1/check/token` with `"context": "swap"`

**Tell it how much.** Add the size of the trade in dollars (`"amount_usd": 500`) and the check also tries a trade of that size. If the pool is too small for it, or the token would let your agent buy that much and sell only in pieces, the answer says so before the money moves.

BEFORE A PAYMENT · ABOUT A FIFTH OF A SECOND

### The quick check.

Answers "is this wallet safe to pay?" It catches sanctioned wallets, wallets that forward everything they receive to a thief, and look-alike wallets planted in a wallet's history with fake USDC or USDT transfers. An agent that copies an address from its history, or matches it by its first and last characters, is exactly who those are made for.

`POST /v1/check/quick` with `"context": "pay"`

## Three ways to connect your agent

[Live]

### Pay per check.

No account, no sign-up. Your agent pays in USDC on Base inside the call itself: $0.03 for a token check, $0.01 for a wallet check.

[The code, step by step.](https://lorglabs.com/docs-pay-per-check.md)

[Live]

### MCP.

Add Lorg Check as a tool in Claude, Cursor and other MCP clients, so the agent asks before it trades.

Paste the settings below, with the public key, and ask. [Settings for every client.](https://lorglabs.com/docs-mcp.md)

[Pilot now]

### An API key.

For a team running one agent or many. One HTTPS call with a key, and no payment per call.

[Ask for a pilot key.](https://lorglabs.com/platforms.md)

## Try it now, with a key anyone can use

This key is public: it is printed here on purpose. It works today against the pilot service, which runs every check on live Base and Ethereum data. No account, no sign-up, nothing charged.

- **The key**: `lorg_test_wxXht1MyxKVyQwjyxN5JPHGfatXIZbL9`
- **What it does**: Both checks, as MCP tools (`check_token` and `check_address`) or as a plain HTTPS call.
- **Its limits**: 10 checks a minute for each caller, and 1,000 a day shared between everyone using it. Enough to try it. For real use, [ask for a key of your own](https://lorglabs.com/platforms.md).
- **Where**: `staging.lorglabs.com`, our sandbox: the same checks on the same live data, nothing charged. For real use, `api.lorglabs.com`: pay per check, or a key of your own.

```
// MCP: add this to your client's settings (Cursor and others)
{
  "mcpServers": {
    "lorg-check": {
      "url": "https://staging.lorglabs.com/mcp",
      "headers": { "Authorization": "Bearer lorg_test_wxXht1MyxKVyQwjyxN5JPHGfatXIZbL9" }
    }
  }
}

# Claude Code: one command
claude mcp add --transport http lorg-check https://staging.lorglabs.com/mcp \
  --header "Authorization: Bearer lorg_test_wxXht1MyxKVyQwjyxN5JPHGfatXIZbL9"

# or a plain call: DEGEN on Base, for a $500 trade
curl https://staging.lorglabs.com/v1/check/token \
  -H "Authorization: Bearer lorg_test_wxXht1MyxKVyQwjyxN5JPHGfatXIZbL9" \
  -d '{ "chain": "base", "address": "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed", "amount_usd": 500 }'
```

Then ask your agent: "is this token safe to buy?" Claude Desktop, VS Code and others: [the MCP docs](https://lorglabs.com/docs-mcp.md)

## Pay per check, step by step

Your agent needs a wallet holding USDC on Base (no ETH: the payment is a signed authorisation). It never needs an account with us.

- **1. Ask**: Send the request with no payment. The reply is `402`, with the price in it.
- **2. Pay**: Your agent signs a USDC payment for that amount from its own wallet, and sends the same request again with the payment attached.
- **3. Receive**: The signed answer comes back, with a receipt for the payment.
- **Never charged**: A mistyped request is refused before any payment is asked for. An error or an "unknown" costs nothing: the payment settles only when we return an answer.
- **Limits**: Without a key, one address can make 30 requests a minute. An agent that needs more should hold a key.

```
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

// the agent's own wallet, holding USDC on Base
const wallet = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:*", client: new ExactEvmScheme(wallet) }],
});

// ask, pay and receive, in one call
const reply = await fetchWithPayment("https://api.lorglabs.com/v1/check/token", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ chain: "base", address: token, amount_usd: 500 }),
});

// act on one word
const { action, summary } = await reply.json();
if (reply.status !== 200 || action === "do_not_proceed") stop(summary);
```

Run as written on 14 Oct 2026 · [the full guide](https://lorglabs.com/docs-pay-per-check.md)

## What your agent can rely on

- **We never guess.** If a check we need can't run, the answer is "unknown", never "allow".
- **It only pays for answers.** An "unknown" or an error costs nothing.
- **Every answer is signed.** It carries the exact block and time it was true, so the agent, or its owner, can prove later what we told it.
- **Nothing is moved.** We only answer a question. Nothing is sent, signed or moved. The trade we run is a simulation.
- **"Allow" is not a guarantee.** It means we found nothing that should stop the trade at the moment we looked. A token can still fall in price, and things can change after the check.