DOCUMENTATION
Build agentic money execution on Stable.
Agentisfy is the control plane for agentic payments on Stable. It packages machine-readable intent, policy-constrained authority, gasless-first execution, and verified settlement into one product surface.
Public docs show the operating model, contracts, and integration path. Internal routing and verifier heuristics stay private.
Authority
Execution
Proof
Section
What Agentisfy is
Agentisfy is not a checkout widget. It is the money execution layer that lets autonomous systems and enterprise operators move from payment intent to provable settlement.
Stable provides the rail. Agentisfy provides the control plane: manifests, grants, runs, proofs, discrepancies, and event streams.
- Machine-readable intent
- Policy-constrained authority
- Proof-backed outcomes
Section
Why Stable is the right rail
One asset for gas and value
USDT0 is used for both transaction fees and value transfer, which simplifies budgets, balances, and payment reasoning for agents.
Gasless-first by design
Stable’s Gas Waiver path enables gasless-first execution for end-user and agent-driven payment flows.
No priority-tip market
Stable does not use priority tips. This removes fee-market guesswork and keeps machine execution models cleaner.
Fast testnet onboarding
Stable Testnet gives developers a concrete environment with chainId 2201, public RPC, WebSocket, and faucet support.
Section
Core Concepts
AgentPaymentManifest
Defines exactly what should happen.
PolicyGrant
Defines what the agent is allowed to do.
ExecutionRun
Tracks one governed execution session from start to closeout.
PaymentAttempt
Captures signing, submission, monitoring, and completion states.
SettlementProof
Binds the run to a verified financial outcome.
DiscrepancyRecord
Captures ambiguity, mismatch, and exception handling.
These concepts are already present in the Agentisfy control-plane model and are rendered publicly as stable product primitives, not internal implementation details.
Section
Execution lifecycle
Manifest compiled
Grant evaluated
Run created
Attempt recorded
Waiver or fallback path selected
Outcome verified
Proof issued
Discrepancy opened if needed
The public lifecycle is intentionally simple. Internal ambiguity and verifier logic remain proprietary.
Section
OpenClawd integration
OpenClawd configures agent identity, role, and tool behavior through workspace files such as SOUL.md, AGENTS.md, and TOOLS.md. Agentisfy fits into that stack as the money execution layer the runtime calls when a workflow needs governed payment behavior.
In this model, OpenClawd decides when to act. Agentisfy decides whether the payment is allowed, how it executes, and how the outcome is proven.
Runtime
OpenClawd manages the agent session, context, tools, and operating behavior.
Execution tool
Agentisfy exposes payment manifests, simulation, execution, proof, and discrepancy retrieval as callable capabilities.
Operator oversight
Merchants and ops teams supervise budget, rationale, proof, and exceptions through dedicated product surfaces.
Section
API surface
Public API categories are stable. Internal orchestration logic is not.
Manifest retrieval
Fetch machine-readable payment intent for an invoice or payment request.
Simulation
Evaluate policy, capability, and likely execution path without moving funds.
Execution
Create or resume a governed payment execution session.
Proof
Retrieve machine-readable settlement proof for a completed or provisional outcome.
Discrepancies
List and inspect exceptions that require wait, recovery, or human review.
Event stream
Subscribe to payment-progress events without scraping UI state.
GET /v1/agent/manifest/{invoiceId}
POST /v1/agent/simulate
POST /v1/agent/execute
GET /v1/agent/proof/{invoiceId}
GET /v1/agent/discrepancies
GET /v1/agent/eventsEndpoint families are public. Internal route selection, ambiguity thresholds, and verifier heuristics are not.
Section
Events and webhooks
Agentisfy publishes execution-relevant state changes through a durable event model. Public events help platforms, operators, and agents stay aligned without exposing private recovery logic.
- invoice.created
- payment_attempt.created
- waiver.accepted
- waiver.rejected
- settlement.provisional
- settlement.final
- refund.initiated
- refund.completed
- discrepancy.opened
Webhook payloads should be treated as authoritative business signals. UI states should be derived from the same event stream, not duplicated independently.
Section
Sandbox and testnet
The recommended development path is Stable Testnet first, then controlled production rollout.
Use testnet to validate manifests, simulation, gasless-first flows, fallback handling, proof retrieval, and exception visibility before exposing live budgets.
Network: Stable Testnet
Chain ID: 2201
RPC: https://rpc.testnet.stable.xyz
WebSocket: wss://rpc.testnet.stable.xyz
Explorer: https://testnet.stablescan.xyz
Section
Trust and proof
Autonomous payment systems cannot rely on transaction hashes alone. Agentisfy publishes decision rationale, settlement proof, and discrepancy state so operators know not only what happened, but why the system considers it safe and final.
Decision Rationale
Why the system allowed the agent to act.
Verified Settlement
What was observed and verified on-chain.
Exception State
What remains unresolved, and what must happen next.
Section
FAQ
Is Agentisfy a checkout product?
No. Checkout is one surface. Agentisfy is the control plane behind it.
Is Agentisfy Stable-specific?
The current product is explicitly designed around Stable-native advantages and execution semantics.
Does Agentisfy expose all internal logic publicly?
No. Public docs expose the operating model, contracts, and integration path. Internal scoring, replay, and verifier strategies remain private.
Can OpenClawd call Agentisfy directly?
That is the intended model. OpenClawd governs the agent runtime. Agentisfy governs the money execution path.