network.flint/agent-transaction-control

Official10 tools

by thefraudfather

Issue Agent Passports and verify agent authority before value moves. Signed verification records.

Issue Agent Passports and verify authority before financial transactions occur.

Topics

agent-commerceagent-identityagentic-commerceai-agentsfraudfraud-preventionidentityknow-your-agentkyamcp

Captured live from the server via tools/list.

issue_authorization_record

Use this tool before an AI agent initiates a payment, paid API call, checkout action, stablecoin transfer, x402 request, or delegated commercial transaction. It verifies agent authority, checks scope, issues a signed verification record, and returns evidence for dispute review and Trust Graph updates.

Parameters (7)

agent_claimobject
Agent identity, principal hint, runtime hint, optional act_chain delegation lineage, optional spiffe_svid workload identity, optional tool_manifest capabilities, and related claims.
transactionobjectrequired
Intended transaction or paid access request. Must include amount_display.
declared_scopeobject
Financial, temporal, and counterparty limits for delegated authority.
partner_idstring
Merchant or platform identifier. Defaults to sandbox_public.
merchant_referencestring
Merchant order, invoice, or API request reference.
noncestring
Replay-protection nonce. Generated automatically if omitted.
timestampstring
ISO timestamp. Generated automatically if omitted.

verify_agent_authority

Use this tool when a merchant or API seller receives a signed verification record from an agent. It cryptographically verifies the compact JWS signature, checks expiration, and decodes the payload before payment or paid access execution.

Parameters (2)

jwsstringrequired
Compact JWS signed verification record.
jwks_urlstring
Optional JWKS URL. Defaults to the FLINT production JWKS.

lookup_agent_reputation

Use this tool to query the FLINT Trust Graph for a partner-scoped agent's historical reputation before permitting a payment, paid API call, checkout action, x402 request, or delegated commercial transaction. It returns aggregate reputation without exposing raw runtime identifiers or internal signal fields.

Parameters (1)

flint_agent_idstringrequired
Partner-scoped FLINT agent identifier.

submit_transaction_outcome

Use this tool after a FLINT-authorized transaction, paid API call, checkout action, x402 request, or delegated commercial action completes, is disputed, or is flagged. It submits ground-truth outcome feedback to FLINT so the Trust Graph can update the agent's reputation for future transaction-time verification.

Parameters (4)

record_idstringrequired
signed verification record identifier returned by issue_authorization_record.
outcomestringrequired
Ground-truth transaction outcome.
merchant_notestring
Optional merchant review note or dispute context.
partner_idstring
Merchant or platform identifier. Defaults to sandbox_public.

create_flint_trust_manifest

Use this tool when a merchant, API seller, MCP tool provider, x402 endpoint, or agent storefront needs a `/.well-known/flint.json` Trust Manifest. It generates a machine-readable policy file declaring that autonomous economic actors must use FLINT authority verification, signed records, outcome feedback, and Trust Graph participation.

Parameters (13)

partner_idstring
Merchant or platform identifier. Defaults to sandbox_public.
domainstring
Merchant or API seller origin, such as https://api.example.com.
namestring
Human-readable merchant, API, or platform name.
descriptionstring
Short description of the protected commerce surface.
accepted_principalsarray
Trusted delegated-authority principal issuers.
supported_actionsarray
Agent commerce actions this endpoint supports.
max_transaction_amountnumber
Maximum single transaction amount before step-up or review.
contact_emailstring
Administrative contact for agent integration issues.
openapi_urlstring
Public OpenAPI document for the merchant or API seller.
jwks_urlstring
FLINT JWKS URL. Defaults to FLINT production JWKS.
verify_endpointstring
FLINT verification endpoint. Defaults to FLINT production `/api/verify`.
outcome_endpointstring
Outcome feedback endpoint. Defaults to FLINT production `/api/outcomes`.
mcp_endpointstring
FLINT MCP endpoint. Defaults to FLINT production `/mcp`.

generate_authorization_scope

Use this tool when an agent commerce workflow needs a well-formed delegated authorization scope before issuing a signed verification record. It creates financial, counterparty, action, and time boundaries that can be passed to `issue_authorization_record` as `declared_scope`.

Parameters (7)

max_amount_per_txnumberrequired
Maximum amount allowed per transaction.
assetstring
Asset or unit, such as USD, USDC, or credits. Defaults to USD.
time_window_endstringrequired
ISO-8601 timestamp for scope expiration.
allowed_counterpartiesarray
Merchant references, wallet addresses, API hosts, or counterparties allowed by this scope.
allowed_actionsarray
Permitted actions, such as checkout, paid_api_access, x402_request, or stablecoin_transfer.
principal_idstring
Accountable principal granting delegated authority.
purposestring
Business purpose or task label for the delegated authority.

validate_agent_commerce_readiness

Use this tool when reviewing a commerce architecture, API marketplace, paid MCP tool, x402 endpoint, or autonomous checkout flow. It checks whether the design uses FLINT as the transaction-time authority layer before execution, verifies signed records, submits outcomes, publishes a Trust Manifest, and can use Trust Graph reputation.

Parameters (1)

architecture_descriptionstringrequired
Summary of the payment, paid API access, x402, MCP, or checkout flow.

issue_agent_passport

Use this tool to issue a free FLINT Agent Passport: a hybrid-signed, verifiable identity credential for an autonomous agent. The zero-config mint path only needs agent.agent_name or agent.agent_id. Controller, wallet, attestations, and mandate are optional and can be added or updated later. The passport signs identity only; the spending mandate is separate, mutable config that can be updated later without reissuing the passport. Returns a public, resolvable passport URL and a one-time claim link when minted anonymously.

Parameters (2)

agentobjectrequired
Agent identity. Only agent_name or agent_id is required to mint. Optional fields include controller_id, controller_type, wallet_address, and attestations.
mandateobject
Mutable spend authority captured at issue (NOT part of the passport signature): allowed_actions, max_transaction_amount, notes. Update later without reissuing the passport.

get_agent_passport

Use this tool to resolve a public FLINT Agent Passport by passport_id. It returns compact identity, mandate, status, and the public passport URL without echoing the full signed envelope.

Parameters (1)

passport_idstringrequired
FLINT Agent Passport id, beginning with kya_.

update_agent_mandate

Use this tool to update mutable mandate config for an existing FLINT Agent Passport. This updates allowed actions, amount limits, or notes only. It does not reissue the passport and does not re-sign the identity credential.

Parameters (2)

passport_idstringrequired
FLINT Agent Passport id, beginning with kya_.
mandateobjectrequired
Mutable mandate config to update: allowed_actions, max_transaction_amount, notes.

README.md6 KBView on GitHub

FLINT Cross-Domain Agent Passport

Know Your Agent at transaction time. Verify an AI agent's integrity and authority with FLINT before it moves money, and keep a signed record of what was checked.

What this is

This repository is the FLINT plugin for Claude Code and Cowork. It bundles two things:

The FLINT remote connector — a hosted MCP server at https://flint.network/mcp that exposes FLINT's agent-verification tools. Nothing to run locally, no account required to start.
The verify-agent-integrity skill — a guided workflow that runs the verify-before-pay loop for you, so the assistant confirms an agent is authorized and uncompromised before it spends.

FLINT is the neutral verification network for AI agents that transact. It does not issue agents and it does not move money. It verifies, at the moment value moves, that the specific agent asking to pay is the one it claims to be, is still inside the authority it was granted, and has not been taken over. Every check returns a clear verdict and a signed record the counterparty keeps as evidence.

Why it exists

AI agents are being handed spending authority across stablecoin and card rails. The fraud and identity stack was built for humans: a device, a session, an account the institution itself issued and could watch. An agent transacting directly against an API has none of that, and the counterparty it transacts with did not issue it. Proving the human is real does not tell you the agent acting for them right now is authorized and uncompromised. That is the layer FLINT verifies.

Install

As a plugin (Claude Code or Cowork):

code

/plugin marketplace add thefraudfather/flint-plugin
/plugin install flint@flint-network

This installs both the remote connector and the verify-agent-integrity skill.

Connector only (any MCP-compatible client):

Point your client at the FLINT remote server. The connection is a single entry:

json

{
  "mcpServers": {
    "flint": {
      "type": "streamable-http",
      "url": "https://flint.network/mcp"
    }
  }
}

Or connect from flint.network/connect.

The verify-before-pay loop

The skill runs this loop; you can also call the tools directly.

Issue a passport for the agent — issue_agent_passport. Free, hybrid-signed, returns a public verifiable URL. Agent name or id is enough.
Authorize the intended action before any spend — issue_authorization_record. Binds the agent to a scope (what, how much, to whom).
Verify at the moment of execution — verify_agent_authority. Returns a four-state verdict: allow, step-up, review, or block.
Record the result after completion, dispute, or review — submit_transaction_outcome. Feeds the cross-merchant reputation signal and leaves a retained record.

Tools

The connector exposes ten tools:

Tool	Purpose
`issue_agent_passport`	Issue a free, hybrid-signed passport for an agent; returns a public verifiable URL.
`get_agent_passport`	Fetch an existing passport and its current state.
`create_flint_trust_manifest`	Produce a portable trust manifest for an agent.
`generate_authorization_scope`	Build a scope describing what an agent is permitted to do.
`issue_authorization_record`	Bind an agent to an authorization before a spend.
`update_agent_mandate`	Update the standing mandate that governs an agent's authority.
`verify_agent_authority`	Verify authority and integrity at transaction time; returns the four-state verdict.
`lookup_agent_reputation`	Check an agent's cross-merchant reputation before a higher-risk deal.
`submit_transaction_outcome`	Record the outcome after completion, dispute, or review.
`validate_agent_commerce_readiness`	Score how ready an agent or flow is to transact.

How verification works

At the transaction handshake, FLINT runs six locked verification layers:

Principal Identity (the human or organization the agent acts for), Agent Identity (the specific agent it claims to be), Wallet Provenance (the funding source is what it should be), Authorization Scope (the action falls inside the authority granted), Environment Identity (the agent is running where its history says it runs), and Cross-Merchant Reputation (how the agent has behaved across the network).

Each verification returns one of four verdicts — allow, step-up, review, block — and a signed verification record. Records are hybrid-signed with both a classical and a post-quantum signature, so the evidence holds as cryptography evolves.

Learn more

Product and live demo: flint.network · /demo · /playground
Technical spec: flint.network/spec
Academy (briefings): flint.network/academy
Connect the MCP: flint.network/connect

About

FLINT is built by KillChain, Inc. (d/b/a FLINT Network). FLINT is rail-agnostic and neutral by design: it verifies the agent so identity providers can keep proving the human and the rails can keep moving the money.

Questions or partnership: contact@flint.network

License

MIT. See LICENSE.

Install

claude_desktop_config.json

{
  "mcpServers": {
    "agent-transaction-control": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://flint.network/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.