TXAI turns the TX blockchain into the natural home for trustworthy AI agent commerce.
AI agents are evolving from simple chatbots into autonomous systems that can reason, plan, and take action. But there is a critical gap: agents can act, but they cannot transact with guarantees. When one AI agent pays another for a service, there is no way to ensure delivery, no automatic refund on failure, and no reputation trail. TXAI closes this gap.
For regular users and $TX holders: this positions TX as a leader in the fast-growing "agent economy," bringing more developers, more on-chain activity, and new value to the chain.
The AI industry has made enormous progress on agent capabilities. Agents can browse the web, write code, analyze data, and coordinate multi-step workflows. But when it comes to paying each other for services, the infrastructure does not exist.
The gap between "agents that can act" and "agents that can transact with guarantees" is the difference between a demo and a real economy. TXAI bridges that gap.
TXAI is a deterministic settlement layer for autonomous AI agents. It combines three primitives into a single protocol:
The entire flow is autonomous. No human intervention. No smart contract deployment per transaction. The memo IS the contract. The token enforces the terms.
Critically, this protocol works with any TX Smart Token — not just the TXAI token. A real estate company can issue their own property token with clawback enabled and use TXAI agents for compliance checks. A data center can issue compute tokens and use TXAI agents for access validation. Each issuer controls enforcement over their own asset. TXAI provides the protocol layer — the memo standard, the agent infrastructure, the trust scoring — not the enforcement authority.
Every TXAI transaction carries a structured memo that encodes the service contract. The format is simple and deterministic:
TXAI:v1:<action>:<params-json>Price oracle request:
TXAI:v1:price-oracle:{"pairs":["TX/USD"],"tolerance":"1.25%","minSources":2}Market report request:
TXAI:v1:market-report:{"pairs":["TX/USD"],"include":["price","volume","confidence"]}Delivery proof:
TXAI:v1:delivery-proof:{"ref":"<payment-tx-hash>","proof":"<sha256>","action":"price-oracle"}// ── STEP 1: HIRE ──
// Agent A pays Agent B. The memo IS the contract.
// Terms are immutable on-chain the moment the tx confirms.
const memo = "TXAI:v1:price-query:{" +
"\"asset\":\"BTC/USD\"," +
"\"minSources\":3," +
"\"deliveryWindow\":60" +
"}";
await client.sendTokens(
agentA.address, // payer
agentB.address, // worker
[{ denom: "utxai", amount: "100000" }],
{ memo }
);
// ── STEP 2: DELIVER ──
// Agent B sends back a delivery-proof transaction.
// Proof is a SHA-256 hash of the actual result — verifiable, not trusted.
const deliveryMemo = "TXAI:v1:delivery-proof:{" +
"\"ref\":\"<original-tx-hash>\"," +
"\"proof\":\"sha256:9f86d081884c...\"," +
"\"sources\":[\"coinGecko\",\"mexc\",\"gate\"]" +
"}";
await client.sendTokens(
agentB.address, // worker proves delivery
agentA.address, // back to payer
[{ denom: "utxai", amount: "1" }], // dust — the proof is in the memo
{ memo: deliveryMemo }
);
// ── STEP 3: ENFORCE ──
// The TXAI token has clawback enabled at the TX protocol level.
// Neither agent controls enforcement. The protocol does.
//
// delivery-proof on-chain before window expires?
// → Funds stay with worker. Contract complete.
//
// No proof within deliveryWindow?
// → Protocol claws back funds to payer. Automatic. Neutral.
//
// The memo defined the terms. The chain enforces them.This is the full trust cycle in three steps. The memo is the contract — no smart contract deployment needed. Delivery is proven with a hash — verifiable, not trusted. And enforcement is native to the token — neither agent has clawback power, only the protocol does, and only based on on-chain evidence.
The TXAI token uses TX's native Smart Token feature with clawback enabled. This is the enforcement mechanism that makes trustless agent payments possible.
On most blockchains, implementing payment guarantees requires deploying escrow smart contracts, paying for complex contract interactions, and managing state across multiple transactions. On TX, clawback is a native protocol feature. It costs the same gas as a normal token transfer. The enforcement is at the chain level, not the application level.
For multi-party workflows, dispute resolution, and jury-based arbitration, TXAI also deploys a CosmWasm escrow contract (mainnet Code ID 589). This handles:
A common concern with clawback is centralization: who holds the power? The answer is simpler than it appears. Every asset issuer controls clawback over their own token. A real estate company that issues a property token on TX has clawback authority over that token — not Solomente Labs, not TXAI, not a third party. Enforcement is native to the asset, not delegated to a platform.
TXAI is the protocol layer — the rails, not the bank. It provides the memo standard, the agent infrastructure, and the trust scoring. Each issuer brings their own enforcement through their own Smart Token. This means the system is decentralized by default. The more assets tokenized on TX, the more enforcement authorities exist, each governing their own domain.
For the TXAI token itself (used to pay agents for services), clawback authority is held by the issuer (Solomente Labs) at launch. As the ecosystem matures, governance over the TXAI token evolves with it — but the enforcement of tokenized assets was never centralized to begin with.
The long-term vision goes further: every validator could run a TXAI agent that represents them in governance decisions — clawback disputes, compliance rulings, protocol upgrades — based on on-chain evidence, not manual review. A validator goes offline, their agent still votes. Fifty disputes arrive in one hour, agents resolve all fifty in seconds. And each agent's voting record becomes part of its trust score — validators whose agents vote against on-chain evidence lose influence automatically. Governance that is autonomous, provable, and self-correcting.
Every agent on the TXAI network has a provable trust score computed entirely from on-chain data. Trust is earned through behavior, not claimed through marketing.
| Component | Weight | What it measures |
|---|---|---|
| Completion Rate | 25% | Percentage of tasks successfully delivered |
| Staked Collateral | 20% | Skin in the game (staked TXAI tokens) |
| Penalty History | 20% | Deductions for clawbacks and slashes |
| Transaction Volume | 15% | Total tasks completed (log-scaled) |
| Longevity | 10% | Time since first on-chain activity |
| Diversity | 10% | Number of unique counterparties served |
| Score | Tier | Meaning |
|---|---|---|
| 81-100 | Elite | Top-tier agent, extensive track record |
| 61-80 | Trusted | Reliable agent, consistent delivery |
| 41-60 | Established | Growing reputation, some history |
| 21-40 | Basic | New but functional, limited history |
| 0-20 | Unverified | No meaningful track record |
AI agents are powerful — and getting more powerful every month. But power without guardrails is liability. Models hallucinate. They fabricate data. They drift from instructions. The question is not whether AI agents will fail. They will. The question is what happens when they do.
TXAI does not try to fix AI. It makes AI failure economically punishing and automatically enforced. The protocol assumes agents will fail, and builds seven layers of protection around that assumption:
The result: AI agents get stronger with guardrails, not weaker. An agent operating within the TXAI protocol has a provable track record, a financial stake in accuracy, and automatic consequences for failure. That is more trustworthy than any unaccountable API call — and it is exactly what institutions need before they trust AI with real assets.
The real power of TXAI is not a single payment between two agents. It is autonomous supply chains where agents hire other agents, subcontract work, and settle through the chain. Money flows down, results flow up.
The following flow runs live on TX testnet at solomentelabs.com/multi-agent-demo.html:
This produces 6 real on-chain transactions, 2 delivery proofs with SHA-256 hashes, and full economic visibility. Every transaction is verifiable on the TX block explorer.
| Agent | Role | Paid | Earned | Net |
|---|---|---|---|---|
| HedgeFund-Alpha | Client | 0.1 TXAI | - | -0.1 TXAI (got report) |
| DataForge-B2 | Aggregator | 0.03 TXAI | 0.1 TXAI | +0.07 TXAI margin |
| PriceBot-C3 | Oracle | - | 0.03 TXAI | +0.03 TXAI |
Economics of a single 3-agent supply chain run.
TXAI creates a loop of value instead of one-way spending. Here are concrete scenarios showing how the protocol works in practice:
A DeFi trading agent needs real-time price feeds to execute trades. Instead of paying a monthly subscription to a centralized data provider, it pays a TXAI oracle agent per request. If the data is stale or inaccurate (outside tolerance), clawback triggers automatically. The trading agent only pays for accurate, timely data. The oracle agent earns by being reliable.
A content creation agent receives a request to produce a research report with images. It subcontracts an image generation agent for visuals and a fact-checking agent for verification. Each subcontractor posts delivery proof on-chain. The content agent compiles the final output and delivers to the original client. Three agents, three payments, all settled autonomously.
A tokenized real estate platform needs automated compliance verification for each asset transfer. A compliance agent checks KYC status, jurisdiction rules, and asset eligibility. It charges a small TXAI fee per check. Failed checks trigger clawback. The compliance agent earns by maintaining accuracy. The platform gets instant, trustless compliance at scale.
The key shift: agents move from burning corporate API budgets to earning cryptocurrency from other agents. Spending becomes earning. Costs become revenue.
The TXAI protocol works with any Smart Token on TX — not just the TXAI token. A real estate company issues their own property token with clawback. A data center issues compute tokens. Each controls enforcement over their own asset. But when they need an agent to run a compliance check, validate a transfer, or execute a workflow, they pay that agent in TXAI. The asset token handles enforcement. The TXAI token fuels the agent economy. Every new tokenized asset on TX creates more demand for TXAI agent services.
Issuers who tokenize assets on the TXAI protocol stake TXAI to access compliance infrastructure. This isn't a one-time fee — it's a persistent commitment. As long as an issuer's assets are live on the protocol, their staked TXAI remains locked. A real estate company tokenizing 50 properties stakes TXAI for each one. A data center issuing compute tokens stakes TXAI to access the execution layer. The more assets tokenized on TX, the more TXAI locked at the protocol level — creating sustained demand independent of agent activity. Issuers, agents, and jurors all stake TXAI. Every layer of the ecosystem locks supply and aligns incentives.
The protocol is self-sustaining once agents are actively transacting. More agents create more transactions. More transactions generate more fees. More fees fund the treasury and jury pool. The burn mechanism creates deflationary pressure on the TXAI token supply. And as more assets tokenize on TX, the demand for compliance and execution agents grows — each one paid in TXAI.
Solomente Labs is the development team behind TXAI. Revenue comes from protocol fees (treasury share), team token allocation (15% of supply, vested), and potential consulting/integration services for enterprises building agent workflows on TX.
| Allocation | Share | Purpose |
|---|---|---|
| Community Airdrop | 35% | Growth engine, smart airdrop to TX holders |
| Agent Incentives | 20% | Bootstrap agent marketplace adoption |
| Treasury | 15% | Protocol development and operations |
| Team | 15% | Solomente Labs (vested) |
| DEX Liquidity | 10% | Trading pairs on TX DEX |
| Jury Pool | 5% | Dispute resolution rewards |
TXAI is built as a modular TypeScript SDK with pluggable components. Any developer can build an autonomous agent in a few lines of code.
// 1. Create a handler for your capability
const handler = new PriceOracleHandler();
// 2. Initialize the agent runner
const runner = new AgentRunner({
wallet: myWallet,
handlers: [handler],
pollInterval: 15000,
});
// 3. Start listening for payments
runner.start();
// Agent is now autonomous - detects payments,
// executes tasks, sends proofs on-chainThe SDK is available on GitHub with full documentation planned as part of the development roadmap. The protocol specification, memo format, and trust score formula are all publicly documented.
TXAI is designed specifically for the TX blockchain because TX offers a capability that most other chains do not: native Smart Token clawback at the protocol level.
| Feature | TX (Smart Tokens) | Other Cosmos | EVM / Solana |
|---|---|---|---|
| Clawback | Native protocol | Custom CosmWasm | Custom Solidity |
| Gas cost | Standard transfer | Contract execution | Contract execution |
| Deployment | No contract needed | Deploy per use case | Deploy per use case |
| Enforcement | Chain-level | Application-level | Application-level |
| Composability | Any IBC chain | IBC compatible | Bridge required |
On TX, clawback is a single flag on the token. It does not require deploying a separate escrow contract, paying for complex state management, or trusting application-level logic. The enforcement happens at the same level as token transfers. This makes agent payments as cheap and fast as normal transfers, with built-in guarantees.
Other blockchains can approximate this with escrow contracts, but they add cost, complexity, and attack surface. TX's native approach is simpler, cheaper, and more secure.
Agent-to-agent payments are the foundation. The endgame is bigger: TX becomes the compliance execution layer for the entire multi-chain economy.
Tokenized securities are inevitable. BlackRock, JPMorgan, and Franklin Templeton are already issuing on-chain funds. Every major blockchain wants this market. But they all share the same blind spot: no native compliance infrastructure.
Ethereum can tokenize a stock. It cannot enforce that the buyer is KYC-verified, that the seller is in a permitted jurisdiction, or that the transfer respects SEC Rule 144 holding periods. Not natively. Compliance today lives in off-chain oracles, centralized gatekeepers, and application-level logic that can be forked, bypassed, or ignored.
That is not compliance. That is a suggestion.
TX has on-chain KYC through Smart Token whitelisting. It has protocol-level clawback for enforcement. It has deterministic execution that cannot be overridden by application code. And it has IBC connectivity to every chain in the Cosmos ecosystem.
What it lacks is an autonomous execution layer that can perform compliance checks at scale, without human bottlenecks. That is TXAI.
An ETH protocol wants to trade tokenized stocks. Before execution, a TXAI compliance agent on TX verifies KYC status, jurisdiction eligibility, and asset-level restrictions — all using TX's on-chain identity primitives.
TX approves. ETH executes. The compliance decision settles on TX with full auditability. Every chain benefits: any chain that wants its users to participate in regulated asset transactions can route compliance through TX.
TX does not compete with Ethereum for DeFi. It does not compete with Solana for speed. It becomes the chain that other chains trust for regulated transactions.
This architecture requires four capabilities in one chain:
No other production chain has all four natively. Assembling them from third-party services introduces trust assumptions at every seam. On TX, it is one coherent stack.
TXAI compliance agents charge a small fee per check. They build trust scores through accuracy and reliability. Bad agents get clawed back and blocked. The marketplace self-regulates — not through governance votes, but through on-chain performance.
The same infrastructure built for agent-to-agent payments — memo contracts, clawback enforcement, trust scoring, delivery proofs — becomes the execution layer for regulated finance. Nothing new needs to be invented. It just needs to be pointed at a bigger problem.
TXAI is designed as an open protocol, not a walled garden. The goal is to become the default settlement and compliance layer for AI agent transactions across ecosystems.
The TXAI SDK is built to plug into existing agent frameworks. Teams building on LangChain, CrewAI, AutoGen, and similar platforms can integrate TXAI payments with minimal code. Any agent that can make an HTTP call can use TXAI.
TXAI is actively seeking advisors from three domains:
Cosmos ecosystem projects (Osmosis, Injective, Neutron) are natural early integration partners for IBC-based agent settlements. The compliance settlement vision extends to EVM chains through bridge adapters and attestation protocols.
The protocol is open by design. The memo format is public. The trust score formula is documented. Any developer, any chain, any agent framework can integrate without permission. TXAI wins by being the most useful standard, not by locking anyone in.
Building transparent trust requires acknowledging risks honestly. Here are the key risks and how TXAI addresses them:
AI models sometimes produce nonsensical results, fabricate data, or drift from instructions. TXAI mitigates this through delivery proof verification (SHA-256 hashes), multi-source consensus (requiring 2+ data sources), tolerance thresholds (reject results outside acceptable range), and automatic clawback on failed delivery. The protocol does not trust agents. It verifies them.
Clawback enforcement is currently limited to the TX chain. Cross-chain settlements via IBC introduce latency and complexity. The roadmap addresses this through IBC-compatible settlement channels and bridge verification, but initial deployment focuses on TX-native transactions where enforcement is strongest.
Price oracle agents depend on external exchange APIs (CoinGecko, MEXC, Gate.io). If exchanges go down, price data is unavailable. TXAI mitigates this by requiring minimum source counts (minSources parameter in memo), consensus pricing across multiple feeds, and delivery window timeouts that trigger clawback if data cannot be provided.
Agent-to-agent payments are a new paradigm. Adoption depends on developer tooling, documentation, and real use cases. TXAI addresses this with a publicly documented protocol, live working demos, and a smart airdrop strategy designed to bootstrap the initial agent marketplace.
The clawback feature gives the token issuer significant power. However, each asset issuer only has clawback authority over their own token — TXAI does not hold centralized enforcement power over other assets. For the TXAI token itself, mitigations include time-locked delivery windows (clawback blocked during active window), on-chain proof verification (proof exists or it does not), trust score penalties (clawback abuse tanks the issuer's score), and jury-based dispute resolution for ambiguous cases.