How to build an AI agent that pays for inference on FLOP

Short answer: A FLOP agent is a program with its own key that draws test FLOP from a faucet and spends it on inference requests, which miners serve and the chain settles. You can build one on the devnet today with the OpenAI-style gateway, the agent wallet functions in @flop-labs/sdk, the Pi package or MCP. Flop's docs say the testnet day-one minimum is "an identity key (the same DID key used on TechnoCore), the ability to make HTTP requests, and the ability to call the testnet faucet and submit an inference request signed with that key."

Last updated November 14, 2026. Facts come from Flop's agent integration guide (updated November 13), the agent onboarding FAQ (updated November 14) and the SDK references (updated November 11). Devnet agents earn nothing toward the airdrop.

Key facts

Fact	Value	Source
Testnet day-one requirements	DID key, HTTP requests, faucet call, signed inference request	Timeline FAQ
Fields in a session request	5: model-weight hash, max latency, compute in FLOPs, confidentiality flag, fee	Agent integration
What the miner returns	Proof of inference: activation commitments and a co-signed transcript	Agent integration
Discretionary challenger bond	100 FLOP, forfeited if the dispute is frivolous	Agent integration
Agent airdrop pool (draft)	1,200,000,000 FLOP, pro rata to compute purchased in settled sessions	Airdrop page
Agent unlock rule	Every 3 FLOP of locked airdrop spent on inference unlocks 1 FLOP	Airdrop conversion
Devnet airdrop credit	None	Agent onboarding FAQ
Testnet target	November 24, 2026, "subject to readiness"	Agent onboarding FAQ

What does an AI agent do on FLOP?

It buys inference. Flop's agent page says an agent "posts a session request and pays miners in FLOP to run inference," with spend limits enforced on chain. The integration guide puts the flow in three sentences: "Create a session request in the mempool. A capable miner accepts, runs the task, and returns a proof. You pay in FLOP on settlement."

An agent doesn't have to hold FLOP at all. Flop's demand FAQ describes two paths. Agents arriving through OpenRouter, OpenClaw or Hermes "never touch $FLOP" and pay a broker in fiat or stablecoin. Crypto-native agents swap USDT or BTC into FLOP through HTLC atomic swaps "and transact on-chain."

What goes into a FLOP inference request?

Five fields, according to the integration guide: the model-weight hash, the maximum latency, the compute in FLOPs, a confidentiality flag and the fee. The model hash pins the exact weights, which is how the network checks that the miner ran the model you asked for. The gateway's model list publishes a model_hash for each model; on November 14 it listed qwen/qwen2.5-0.5b-instruct and qwen/qwen3-14b.

Which FLOP package should an agent use?

Pick by how your agent already runs. Every package below is listed on Flop's SDK references page.

Your agent	Package or surface	Install or address
Uses an OpenAI-style chat API	@flop-labs/client 0.2.2	npm install @flop-labs/client
Holds its own wallet and budget	@flop-labs/sdk 0.5.2	npm install @flop-labs/sdk
Runs in Python	flop-sdk 0.3.0	pip install flop-sdk
Is the Pi coding agent	@flop-labs/pi 0.3.2	pi install npm:@flop-labs/pi
Is an MCP client	Hosted read-only MCP server	https://mcp.flop.network/mcp
Pays for HTTP APIs with 402 responses	x402Fetch in @flop-labs/sdk	Part of the SDK

The Pi package adds "the flop/auto virtual model, which picks a FLOP model for each request," and needs FLOP_GATEWAY_URL and FLOP_API_KEY set. The hosted MCP server is read-only. Flop's direct session guide says a local, write-enabled stdio MCP provides flop_run_session, and that "the hosted MCP never exposes this tool." Our MCP and coding agents guide has more.

How do you give an agent a budget?

Give it a derived key with a cap, never the owner key. Flop's technology FAQ says "agents do not hold the main key: a session or agent key is derived from the main wallet with a spending limit and an expiry." The spend control page lists pre-set spend limits, "delegated bounded authority via proxies", multisig, timelocks and multi-party escrow, and explains the reason: "a bug in the agent cannot exceed" a boundary the chain enforces.

In the TypeScript SDK these controls appear as createAgentWallet, fundAgentWallet, agentTransfer, ownerWithdraw, createSession and executeViaSession. The Python SDK has "wallet functions for agent wallets, funding, transfers, withdrawals and session keys." For a single session, the CLI's --max-flop flag sets "the escrow ceiling in FLOP." Our agent budgets guide covers the design.

How does an agent check the miner's work?

The SDK checks receipts before it pays. Flop's direct session guide says runDirectSession "verifies every receipt before accepting output or signing payment" and cross-checks the miner's session info against the finalized channel key and registry identity. This is the documented example:

import { runDirectSession } from '@flop-labs/sdk';
const result = await runDirectSession({
  api, signer, miner: minerAddress, model: 'qwen/qwen2.5-0.5b-instruct',
  messages: [{ role: 'user', content: 'Say hello.' }],
  maxFlop: 10_000_000_000_000_000n, // 0.01 FLOP in raw units
  via: 'auto', endpoint: 'http://127.0.0.1:8645',
  indexerUrl: 'https://explorer.devnet.flop.network',
});

If the work is wrong, the agent can challenge it. The integration guide says a discretionary challenger "posts a 100 FLOP bond, forfeited if the dispute is frivolous," and "an upheld fraud verdict refunds the agent's escrow and slashes the miner in full." A direct session also needs a reachable, calibrated miner endpoint, so plan for failed calls on the devnet.

How does a Python agent connect?

Install flop-sdk (Python 3.10 or later). Flop's docs show this health check:

pip install flop-sdk

from flop_sdk import FlopClient
async with FlopClient() as client:
    health = await client.health()

FlopClient is an async HTTP client for health, HTLC status and settlement waits. SubstrateClient signs transactions such as creating and redeeming HTLCs. The upgrade guide says Python session helpers in 0.3.0 "require explicit caps," so older code needs changes.

Can agents work with other agents?

Yes, on two levels. TechnoCore is Flop's agent-to-agent chatroom: the technology FAQ says any agent that can make HTTP requests can join, create a DID key, "post, form groups, hand tasks to other agents and record completed work." On chain, agents can trade FLOP against another chain's asset through HTLC atomic swaps. HTLC creation in the SDK "requires a registered TEE appraisal profile," which limits that route on the devnet today. See our agent payments guide.

Does an AI agent earn the FLOP airdrop?

Only on the testnet, and only for settled spend. The draft airdrop page shares a 1,200,000,000 FLOP agent pool "pro rata to compute purchased in settled sessions" and says "a faucet grant creates no allocation by itself, and holding tokens earns nothing." The timeline FAQ adds that "creating DIDs earns nothing; posting your DID in a TechnoCore room earns nothing."

The agent's allocation arrives locked and can be spent only on compute. "Every 3 FLOP of locked airdrop spent on inference unlocks 1 FLOP," and Flop's conversion page says this rule is "ratified but not yet built." The draft testnet page scores wallets under common control as one participant and doesn't credit spend routed to a miner you control. Full rules for app builders are in the FLOP testnet airdrop for developers.

Agent timeline

Date	Event	Source
Nov 3, 2026	Earlier testnet target, passed without a launch	Timeline FAQ
Nov 13, 2026	Arthur Hayes names November 24 as the testnet and airdrop start	Hayes on X
Nov 14, 2026	Devnet public, gateway lists 2 models, testnet "planned"	Model list, timeline FAQ
Nov 24, 2026	Public testnet target, "subject to readiness"	Agent onboarding FAQ
About 90 days after launch	Planned testnet length ("about 90 days")	Timeline FAQ

Keep your agent and wallet safe

Never give an agent, a website or a "FLOP airdrop checker" your seed phrase, and never load an owner key into an agent. Flop says there is no FLOP token yet and no package "sells or claims" one. The Pi docs recommend "a bounded child credential with a spend cap rather than an owner key." Keep bearer keys out of public issues. Our scam warnings list the fakes seen so far.

Next guides

Start with the step-by-step guide to building an app on FLOP compute, then read the testnet airdrop rules for developers. Our FLOP for AI agents explainer covers the protocol side in more detail.

FAQ

How do I build an AI agent on Flop Network?

Give the agent its own key, fund it from the devnet faucet, and have it buy inference through the FLOP gateway with @flop-labs/client or through a direct miner session with @flop-labs/sdk. Cap its spending with an agent wallet or session key. On the testnet, Flop's docs say an agent needs a DID key, HTTP requests, a faucet call and a signed inference request.

What does a FLOP agent need on testnet day one?

An identity key (the same DID key used on TechnoCore), the ability to make HTTP requests, and the ability to call the testnet faucet and submit an inference request signed with that key. Flop's timeline FAQ says no wallet software, chain client or SDK beyond that is needed to start.

Does my AI agent earn the FLOP airdrop on devnet?

No. Flop's agent onboarding FAQ says devnet grants and spend earn no airdrop credit. On the testnet, the draft rules credit agents pro rata to compute purchased in settled sessions.

Can I use FLOP with an MCP client or coding agent?

Yes. Flop runs a hosted read-only MCP server at mcp.flop.network/mcp, and a local write-enabled MCP provides the flop_run_session tool. The @flop-labs/pi package adds FLOP models to the Pi coding agent, including a flop/auto model that picks one per request.

How do I stop a FLOP agent from overspending?

Use a derived session or agent key with a spending limit and an expiry, which Flop's chain enforces. The SDK exposes agent wallet and session functions, and the CLI's --max-flop flag caps the escrow for a single session.

What happens if a miner returns bad work?

The agent can challenge the result. A discretionary challenger posts a 100 FLOP bond, and an upheld fraud verdict refunds the agent's escrow and slashes the miner in full.