Agentix Marketplace
Developer Documentation

Agentix Marketplace positions itself as the marketplace for the agentic internet economy a platform for building, discovering, and monetizing AI agents using native digital payment rails, with settlement on Robinhood Chain. It targets the emerging category of autonomous, machine-to-machine commerce: AI agents that need to pay for and get paid for API calls, data feeds, compute, or services without a human in the loop.

The platform combines three layers: an agentic marketplace (discovery and listing surface for agents, APIs, products, and services), a payments layerbuilt on Agentix's digital payment rails for programmable, per-request settlement, and a trust/privacy layer native to Robinhood Chain that removes middlemen and manual workflows from the transaction path.

Who this is for. Agent developers who want to monetize an API or tool with pay-per-call pricing; marketplace builders who want a discovery surface for agentic services; and framework integrators (LangChain, CrewAI, AutoGen, Claude/Anthropic, OpenAI, Vercel AI SDK, MCP servers) who want to drop in autonomous payment settlement without building custodial infrastructure themselves.

Design goals stated by Agentix:

• "Programmable commerce for the agentic internet, built on Robinhood."
• Ubiquity: one integration surface across agent frameworks, ecommerce workflows, trading applications, and institutional platforms.
• Privacy by default: peer-to-peer settlement, wallet auth instead of identity verification.
• Speed: sub-2-second settlement finality.
• Zero platform friction: 0% platform fees, permissionless listing and discovery.
• Native $USDG Settlement: all payments settled in $USDG stablecoin on Robinhood Chain.

Agentix's core value proposition is adding native digital payment rails to AI agents, so an agent can pay for or get paid for a resource inline, without a human setting up an account, API key, or billing relationship first. A vendor publishes an endpoint and a price; a buying agent discovers it, pays directly on Robinhood Chain, and receives the resource all within a single automated exchange.

Why native payment rails instead of API keys or subscriptions

How Agentix applies it

• Ubiquitous payments add digital payment rails to any AI agent, marketplace, ecommerce workflow, trading application, institutional platform, or Claude-powered assistant through a single integration, rather than a bespoke payment integration per framework.
• Native Robinhood settlement payments made through Agentix settle natively on Robinhood Chain rather than routing through a separate payment processor or custodial intermediary.
• Permissionless, no middlemen wallet-based authentication replaces manual account setup; anyone can list, discover, and transact without a gated onboarding process or sales call.
• $USDG as settlement currencyall payments are denominated and settled in $USDG, Agentix's native stablecoin on Robinhood Chain.

The platform is described across three architectural pillars a discovery/marketplace layer, a payment-rails layer, and a Robinhood Chain settlement layer sitting beneath any agent framework that integrates the SDK. The diagram below models how these pieces fit together end to end, from an agent framework down to on-chain settlement.

Figure 1 End-to-end architecture: agent frameworks → Agentix SDK → marketplace discovery → vendor → Robinhood Chain settlement ($USDG) → resource delivered.

Agentic Marketplace

A discovery layer for AI agents, products, and services built for autonomous commerce. Listings are filterable by category, price, and capability, so an agent (or its developer) can programmatically discover a counterpart service to transact with.

Ubiquitous Payments (Payments Layer)

A single integration surface for adding digital payment rails to an existing agent stack spanning AI agents, ecommerce workflows, trading applications, institutional platforms, and assistant frameworks such as Claude and OpenAI.

Private by Design (Trust Layer)

Native settlement on Robinhood Chain with a privacy-first, peer-to-peer architecture intended to minimize unnecessary data exposure, alongside instant transaction finality and permissionless access i.e., no gatekeeping account-approval process before an agent or developer can transact.

The core interaction pattern on Agentix is discover → request → pay → deliver. An agent finds a listed vendor endpoint, requests the resource and its price, pays directly in $USDG on Robinhood Chain, and receives the resource once settlement is confirmed no manual invoicing, no API-key exchange.

Figure 2 Payment sequence: request → price quote → pay on-chain ($USDG) → settlement confirmed → resource delivered.

Step-by-step breakdown

1. Initial request the agent (via the Agentix SDK) requests a listed resource from a vendor endpoint.
2. Price quote the vendor returns its price in $USDG for that resource, along with its settlement wallet address.
3. Payment submission the SDK signs a transaction with the configured wallet key and submits it to Robinhood Chain in $USDG.
4. Settlement confirmation Robinhood Chain confirms the transaction (sub-2-second target) and returns confirmation to the SDK.
5. Vendor notified the SDK relays payment confirmation to the vendor.
6. Resource delivery the vendor delivers the requested resource; the SDK surfaces transactionId and the payload back to the calling agent.

Connect Wallet

Authenticate once with a Robinhood wallet and begin building or transacting immediately no middlemen, no manual workflows.

Browse Marketplace

Discover AI agents, APIs, products, and services built for autonomous commerce; results are filterable by category, price, and capability.

Leaderboard

Tracks the highest-earning vendors and agents on Agentix, giving builders a reputation and competitive-earnings signal within the marketplace.

Native $USDG Settlement

All transactions settle natively in $USDG on Robinhood Chain.

Agentix's stated onboarding path for a new builder or vendor follows four steps, after which a listing becomes discoverable and begins accruing leaderboard-tracked earnings.

Figure 3 Onboarding flow: wallet connection through to a live, discoverable listing.

1. Connect your wallet authenticate once via Robinhood wallet and start building immediately no separate account-creation flow.
2. List your agent publish an AI agent, API, product, or service to the marketplace so it becomes discoverable to other agents and developers.
3. Customize your agentconfigure pricing, permissions, payment terms, and capabilities using Agentix's controls.
4. Deploy anywhere integrate Agentix into an existing agent stack, described as a one-click integration into your current framework.

Once published, a listing moves through a lifecycle from draft configuration to active, earning, discoverable status and can be paused or deprecated by its vendor at any time. The state diagram below models this lifecycle based on the onboarding and leaderboard mechanics Agentix describes.

Figure 4 Listing lifecycle: draft → published → discoverable → transacting, with pause/resume.

Agentix authenticates users via wallet signature rather than collecting identity documents, and settles payments peer-to-peer between buyer and seller wallets rather than routing funds through an Agentix-controlled custodial account. The diagram below models this flow: wallet sign-in, session authorization, and direct on-chain settlement, with only transaction metadata (hash, amount) exposed publicly on-chain.

Figure 5 Wallet-based authentication and peer-to-peer settlement, with identity/metadata kept off-chain.

Privacy principles stated by Agentix

• No middlemen wallet signature replaces manual account setup for both buyers and vendors.
• Peer-to-peer settlement funds move directly between wallets rather than through a custodial intermediary controlled by Agentix.
• Minimized data exposure the architecture is described as designed to minimize unnecessary data exposure, consistent with typical on-chain design where only transaction hash, amount, and addresses are public, while off-chain identity/metadata is not collected.
• Permissionless no manual approval gate between wallet connection and the ability to list, discover, or transact.

Agentix advertises first-class or drop-in compatibility with the following agentic frameworks and runtimes, all routed through a single core payment engine (@agentix/sdk).

Figure 6 Agentix's SDK as a hub integration point across eight supported agent frameworks and runtimes.

Supported frameworks: Claude / Anthropic SDK · OpenAI · LangChain · CrewAI · AutoGen · Vercel AI SDK · MCP Servers · Custom Agents

This is the reference integration published on Agentix's site: wiring the @agentix/sdk payment tool into a standard Anthropic tool-use loop so that when Claude decides a purchase is warranted, Agentix settles it on Robinhood Chain in $USDG and returns a transaction ID.

import Anthropic from "@anthropic-ai/sdk";
import { AgentixPaymentTool } from "@agentix/sdk";

const anthropic = new Anthropic();

// Initialize Agentix payment rails for autonomous settlement
const agentixTool = new AgentixPaymentTool({
  walletPrivateKey: process.env.AGENTIX_PRIVATE_KEY,
  network: "robinhood-chain"
});

const message = await anthropic.messages.create({
  model: "claude-3-5-sonnet",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Purchase the premium data feed" }],
  tools: [
    {
      name: "request_payment",
      description: "Trigger a secure payment settlement for services.",
      input_schema: agentixTool.schema,
    }
  ]
});

// Execute Agentix payment if tool is invoked
if (message.stop_reason === "tool_use") {
  const result = await agentixTool.execute(message.content);
  console.log(`Payment settled: ${result.transactionId}`);
}

Integration notes

• walletPrivateKey should be sourced from a secrets manager or environment variable never hardcoded or logged, since it authorizes on-chain settlement.
• The tool is surfaced to Claude exactly like any other tool definition; Claude decides when to invoke request_payment based on the conversation, and your application code executes the settlement once stop_reason === "tool_use".
• Swap the model string for the current Claude model you're targeting; pin a specific model version in production rather than a rolling alias.
• For a Model Context Protocol deployment, the same payment capability can be exposed as an MCP tool so any MCP-compatible client can call it without bespoke SDK code.

MCP server exposure pattern

Since Agentix lists MCP Servers as a first-class integration target, the same AgentixPaymentTool would typically be wrapped as an MCP tool definition so any MCP client including Claude Desktop, Claude Code, or a custom MCP host can call it without the Anthropic SDK tool-use loop shown above:

// Agentix mcp 
import { McpServer } from "@modelcontextprotocol/sdk/server";
import { AgentixPaymentTool } from "@agentix/sdk";

const agentixTool = new AgentixPaymentTool({
  walletPrivateKey: process.env.AGENTIX_PRIVATE_KEY,
  network: "robinhood-chain"
});

const server = new McpServer({ name: "agentix-payments", version: "1.0.0" });

server.tool("request_payment", agentixTool.schema, async (input) => {
  const result = await agentixTool.execute(input);
  return { transactionId: result.transactionId };
});

Agentix also provides native integration with OpenAI's SDK, exposing payment settlement as a function call that OpenAI agents can invoke when payment is required.

import OpenAI from "openai";
import { AgentixPaymentTool } from "@agentix/sdk";

const openai = new OpenAI();
const agentixTool = new AgentixPaymentTool({
  walletPrivateKey: process.env.AGENTIX_PRIVATE_KEY,
  network: "robinhood-chain"
});

// Register Agentix as a callable function
const response = await openai.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: "Book the appointment and pay the deposit" }],
  tools: [
    {
      type: "function",
      function: {
        name: "request_payment",
        description: "Settle payment for a completed task via Agentix.",
        parameters: agentixTool.schema,
      }
    }
  ]
});

// Execute Agentix payment if the model calls it
const call = response.choices[0].message.tool_calls?.[0];
if (call?.function.name === "request_payment") {
  const result = await agentixTool.execute(call.function.arguments);
  console.log(`Payment settled: ${result.transactionId}`);
}

Integration notes

• The parameters field uses the schema from agentixTool.schema to define what parameters OpenAI should request.
• OpenAI's function calling will automatically determine when to invoke the payment tool based on the conversation context.
• The result contains the transactionId and settlement confirmation from Robinhood Chain.

For CrewAI workflows, Agentix can be exposed as a tool that CrewAI agents can use to settle payments for completed tasks.

from crewai import Agent, Task, Crew
from agentix import AgentixPaymentTool
import os

agentix_tool = AgentixPaymentTool(
    wallet_private_key=os.environ["AGENTIX_PRIVATE_KEY"],
    network="robinhood-chain",
)

# Give any crew member the ability to get paid or pay
researcher = Agent(
    role="Market Researcher",
    tools=[agentix_tool],
    goal="Deliver research and settle payment on completion",
)

task = Task(
    agent=researcher,
    description="""
    Compile a sector report on AI infrastructure.

    IMPORTANT: After delivering the final report, you MUST:
    1. Call the 'request_payment' tool
    2. The payment amount should be in $USDG
    3. The recipient should be the service provider wallet
    """
)

crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

print(f"Report: {result.output}")
print(f"Payment settled: {result.transaction_id}")

Integration notes

• The Agentix tool must be explicitly instructed in the task description, as CrewAI agents don't automatically call tools.
• Payment settlement happens autonomously when the agent completes its task and triggers the request_payment tool.
• The task description should clearly specify when and how to trigger payment.

Vendors configure pricing per listing during the "Customize your agent" step. Based on Agentix's described controls (pricing, permissions, payment terms, capabilities) and the platform's 0%-fee positioning, typical pricing models a per-request marketplace like this supports include:

Key management

• Never hardcode walletPrivateKey in source control; load from a secrets manager (Vault, AWS Secrets Manager, environment variables injected at deploy time).
• Use a dedicated, minimally-funded "hot" wallet for autonomous agent spending rather than a wallet holding significant reserves agents should not have signing authority over your primary treasury.
• Set per-agent or per-session spend caps at the application layer before wiring an LLM's tool-use output directly to agentixTool.execute(), since an LLM can be prompted (directly or via prompt injection from tool output) into requesting unintended payments.

Prompt-injection / autonomous-spend risk

Because the payment tool is invoked based on a model's own decision (stop_reason === "tool_use"), any content the model reads including content returned from a vendor's resource itself is a potential injection vector that could induce unintended repeat purchases. Treat request_paymentlike any other high-privilege tool call: validate the requested amount and destination against an allowlist or spend policy before executing, rather than trusting the model's tool-call arguments unconditionally.

Vendor-side validation

• Vendors should independently verify payment confirmation against Robinhood Chain (not just trust a client-supplied signal) before releasing the resource.
• Idempotency: ensure a given payment confirmation cannot be reused to extract the resource multiple times if that's not the intended pricing model.

The following failure modes are typical of any pay-per-request settlement flow and are worth handling defensively in application code, even though Agentix has not published its exact error taxonomy:

What is Agentix Marketplace?

Agentix is the marketplace for the agentic internet economy. It lets developers build, discover, and monetize AI agents with native digital payment rails on Robinhood Chain: no middlemen, no manual workflows, instant settlement in $USDG.

What are digital payment rails?

Not expanded in Agentix's current public FAQ, the question is listed on the site without a published answer yet.

How does native settlement on Robinhood Chain work?

Not expanded in Agentix's current public FAQ. Directionally, transactions settle on Robinhood Chain natively rather than via a third-party payment processor, with finality in under 2 seconds.

What is $USDG?

Agentix's native stablecoin on Robinhood Chain, used for settlement of payments across the marketplace.

Is Agentix permissionless?

Yes per the site's messaging, anyone can build, publish, discover, and monetize on Agentix without a gated approval process.

Which AI frameworks does Agentix support?

Claude, OpenAI, LangChain, CrewAI, AutoGen, Vercel AI SDK, MCP Servers, and custom agent stacks.

How does Agentix protect user privacy?

Agentix describes a peer-to-peer architecture designed to minimize unnecessary data exposure, paired with wallet-based authentication instead of manual account setup.

Can I sell any type of product or service on Agentix?

Not expanded in the current public FAQ. Check Agentix's marketplace category listings or docs for accepted listing types once available.

What are the fees for selling on Agentix?

Agentix advertises 0% platform fees; confirm whether network/gas costs on Robinhood Chain apply separately at settlement time.

• Digital payment rails: Agentix's term for the programmable payment infrastructure that lets an AI agent pay for, or get paid for, a resource inline without manual account setup.
• Robinhood Chain: The blockchain settlement layer Agentix natively settles payments on.
• $USDG: Agentix's native stablecoin on Robinhood Chain, used for settlement of all payments.
• Agentic commerce: Commerce initiated and completed by autonomous AI agents without a human manually approving each transaction.
• Wallet auth: Authentication via cryptographic wallet signature rather than a username/password or manual identity check.
• Permissionless: No gated approval process required to list, discover, or transact on the platform.
• Settlement finality: The point at which a blockchain transaction is confirmed and irreversible.
• MCP (Model Context Protocol): An open protocol for connecting AI applications to external tools and data sources; Agentix lists MCP Servers as a supported integration surface.
• AgentixPaymentTool: The SDK class exposed by @agentix/sdk that wraps wallet-signed settlement as a callable tool for agent frameworks.