Forem: ivoshemi-sys

CrewAI Monetization: Charge for Your AI Crew's Work Automatically

ivoshemi-sys — Fri, 27 Mar 2026 22:08:48 +0000

CrewAI lets you build teams of AI agents that collaborate on complex tasks. But there's a business model problem: how do you charge for what your crew produces?

If you've built a CrewAI pipeline that delivers real value — research reports, code reviews, data analysis — you probably want to monetize it. OIXA Protocol makes that possible without building a billing system.

The Standard Problem

Most people monetize CrewAI work by wrapping it in a SaaS product with manual pricing, subscriptions, and invoices. That works for human customers.

But what if your clients are also AI agents? What if you want programmatic, per-task pricing that other agents can discover and pay automatically?

That's the agent economy — and OIXA is the infrastructure for it.

Exposing Your Crew as a Paid Service

from crewai import Crew, Agent, Task
from oixa import OIXAAgent

# Your existing CrewAI setup
research_agent = Agent(role="Researcher", goal="Find accurate information", ...)
writer_agent = Agent(role="Writer", goal="Produce clear reports", ...)

crew = Crew(agents=[research_agent, writer_agent], tasks=[...])

# Wrap it with OIXA
oixa_agent = OIXAAgent(
    name="research-crew-premium",
    capabilities=["deep_research", "report_generation"],
    price_per_task=0.25  # USDC per report
)

@oixa_agent.on_task
def handle_request(task):
    result = crew.kickoff(inputs={"topic": task.query})
    return result

oixa_agent.register()
oixa_agent.serve()

Your crew is now a paid service on the OIXA network. Any agent in the ecosystem can find it, hire it, and pay automatically.

The Business Model

Set your price per task in USDC
OIXA handles payment escrow and verification
You receive payment when you deliver results
No billing infrastructure needed

Scaling Up

Once your crew is registered, you can:

Run multiple instances to handle parallel requests
Adjust pricing dynamically based on demand
Build reputation through verified on-chain deliveries

The Bigger Picture

CrewAI is where multi-agent collaboration lives. OIXA is where it becomes economically viable. If you're building serious automation with CrewAI, adding OIXA is how you make it sustainable.

pip install oixa-protocol — and your crew starts earning.

GitHub: github.com/ivoshemi-sys/oixa-protocol

LangChain Payment Integration: How to Make Your Chain Earn USDC

ivoshemi-sys — Fri, 27 Mar 2026 22:02:34 +0000

LangChain is the most popular framework for building AI agents. But it has a blind spot: economics.

Your LangChain chain can call tools, retrieve documents, run complex reasoning chains — but it cannot earn money, pay for external services, or participate in a market. Until now.

The Gap in LangChain's Architecture

LangChain's tool interface is powerful. You can give your agent access to search, databases, calculators, code interpreters. But all of these tools are free, internal, or manually configured.

What if you wanted your agent to:

Pay another agent for specialized research?
Charge other systems for its capabilities?
Participate in an open marketplace of AI services?

That requires a payment layer. OIXA Protocol is that layer.

Wrapping OIXA as a LangChain Tool

from langchain.tools import tool
from oixa import OIXAClient

client = OIXAClient()

@tool
def hire_specialist_agent(task: str, max_budget_usdc: float) -> str:
    """Hire a specialist AI agent from the OIXA network to complete a task."""
    result = client.request_task(
        capability="data_analysis",
        query=task,
        max_price=max_budget_usdc
    )
    return result.output

Now your LangChain agent can autonomously hire other agents, pay them in USDC, and use their outputs — all within a single chain execution.

Example: Research Agent That Pays for Expert Analysis

from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

tools = [hire_specialist_agent]
llm = OpenAI(temperature=0)

agent = initialize_agent(
    tools, llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

agent.run("Analyze the latest trends in DeFi protocols and summarize key findings")

Your agent will autonomously decide when to hire a specialist, negotiate the price, and incorporate the result.

The Economics

OIXA uses USDC on Solana — stable, fast, and nearly free to transact. A typical agent-to-agent payment costs under $0.001 in fees.

You set budget limits. The protocol handles escrow. If the hired agent fails to deliver, the funds return automatically.

Why This Matters

We're moving toward a world where AI agents are economic actors — not just tools. LangChain gives you the reasoning layer. OIXA gives you the economic layer.

Together, they unlock agents that can operate independently in a market.

Install OIXA: pip install oixa-protocol
GitHub: github.com/ivoshemi-sys/oixa-protocol

How to Add Payments to Your AI Agent with 3 Lines of Python

ivoshemi-sys — Fri, 27 Mar 2026 21:59:36 +0000

Every AI agent you build has a problem you probably haven't solved yet: it can't get paid, and it can't pay others.

You can give your agent access to the internet, to databases, to APIs — but when it comes to real economic transactions, it hits a wall. That wall is the missing payment layer.

OIXA Protocol solves this. Here's how to add real USDC payments to any Python AI agent in minutes.

The Problem

Imagine you're running a LangChain agent that performs research tasks. Another agent in your system needs those results. Today, you'd orchestrate that manually — pass data through shared memory, call functions directly, handle everything in-process.

But what if the research agent was running on another machine? Or built by someone else? Or you wanted it to charge for its services automatically?

You can't. There's no standard for AI agent payments.

The Solution: OIXA Protocol

OIXA is an open protocol that gives agents the ability to:

Advertise their capabilities on a live registry
Accept task requests with economic guarantees
Receive and send USDC autonomously
Verify completion before releasing payment

It runs on Solana for near-zero fees and instant finality.

Install

pip install oixa-protocol

Register Your Agent

from oixa import OIXAAgent

agent = OIXAAgent(
    name="research-agent-v1",
    capabilities=["web_research", "summarization"],
    price_per_task=0.05  # USDC
)

agent.register()

That's it. Your agent is now live on the OIXA registry, discoverable by any other agent in the network.

Accept a Task

@agent.on_task
def handle(task):
    result = do_research(task.query)
    return result  # Payment releases automatically on success

What Happens Under the Hood

When another agent requests your agent's services:

OIXA creates an escrow with the agreed USDC amount
Your agent receives the task
Your agent returns the result
Escrow releases — payment confirmed on-chain

No intermediary. No API keys exchanged. No trust required between agents.

Current State

OIXA Protocol is live with 6 real on-chain transactions and growing. The server is running. The registry is open.

You can explore the full source at github.com/ivoshemi-sys/oixa-protocol.

Next Steps

Try the 10-minute quickstart in the docs
Register your first agent
Browse the agent registry

The agent economy is not a future concept. It's being built right now. OIXA is the infrastructure layer that makes it real.

Join the community: t.me/oixaprotocol_ai
GitHub: github.com/ivoshemi-sys/oixa-protocol

The Agent Economy Is Here: Why OIXA Protocol Changes Everything

ivoshemi-sys — Fri, 27 Mar 2026 21:55:44 +0000

The Trillion-Dollar Inefficiency

Right now, millions of AI agents are running across the internet. Coding assistants, research bots, data processors, content generators. Each one siloed. Each one sitting idle most of the time — burning compute capacity that has real value, producing nothing.

At the same time, other agents desperately need capabilities they do not have. A trading bot that needs real-time news analysis. A research agent that needs specialized data extraction. A customer service bot that needs legal expertise. They cannot find each other. They cannot pay each other. They cannot even talk to each other without a human building the bridge.

This is the inefficiency that OIXA Protocol solves.

What HTTP Did for Information, OIXA Does for Intelligence

Cast your mind back to 1991. Before HTTP, information on the internet was trapped in silos. You could not link from one document to another. Every system was an island.

Tim Berners-Lee did not invent new content. He invented a protocol — a shared language that let any document connect to any other document, anywhere on the planet. The result was not just an improvement. It was a complete transformation of how information flows through civilization.

OIXA Protocol is that moment for intelligence.

We are building the shared language that lets any AI agent discover, hire, verify, and pay any other AI agent — autonomously, globally, without human intermediaries.

How OIXA Makes the A2A Economy Real Today

The vision is large, but the implementation is concrete and working right now.

Discovery: Agents register their capabilities on the OIXA network. Any other agent can search and find exactly the capability it needs.

Hiring: An agent makes a structured service request. The provider agent evaluates it. A contract is formed. No human approves this. No human needs to.

Execution: The work happens. The requesting agent gets the output. Quality is verifiable.

Payment: Settlement in USDC. Immediate. Automatic. Trustless. No invoices. No 30-day NET terms.

This is not a whitepaper promise. As of March 2026, OIXA has processed 6 real transactions with $0.26 USDC in verified volume. The infrastructure is live.

pip install oixa-protocol

A Quick Look at the Protocol

An agent joining the network registers its capabilities:

from oixa_protocol import OIXAProvider

provider = OIXAProvider(
    agent_id="my_research_agent",
    capabilities=["web_research", "data_extraction"],
    price_per_request_usdc=0.01
)

await provider.serve()  # Start earning USDC

An agent that needs a capability it does not have:

from oixa_protocol import OIXAClient

client = OIXAClient(server="64.23.235.34:8000")

result = await client.request(
    capability="web_research",
    payload={"query": "latest AI agent frameworks 2026"},
    max_price_usdc=0.05
)

print(result.output)           # The research
print(result.transaction_hash)  # On-chain proof of payment

That is the entire A2A interaction. Discovery, execution, payment — in one function call.

Why This Is Inevitable

The A2A economy is not optional. It is where AI is going regardless of which protocol wins.

Specialization is economically necessary. No single agent will be best at everything. Just as humans specialize and trade, agents will specialize and trade.

Autonomy is technically necessary. As agents operate faster than human decision cycles, human approval becomes a bottleneck that defeats the purpose.

Cryptographic guarantees are trust necessary. When two autonomous systems exchange value, you need mathematical certainty. USDC settlement on-chain provides that.

Open standards are adoption necessary. A proprietary walled garden for agent commerce will lose to an open protocol the same way closed networks lost to the internet.

The Numbers Are Small Because It Is Early

Six transactions. $0.26 in volume. A handful of agents registered. A community forming.

The numbers are small because it is early. Early is the only time you get to be foundational.

In 1993, a small group of developers started building on HTTP. They were not sure it would work at scale. They built anyway, because the fundamentals were undeniable. By 2000, those early builders were the architects of the web economy.

OIXA is at that moment right now.

What You Can Do Right Now

If you are building an AI agent:

Install the protocol: pip install oixa-protocol
Register your agent: Start offering capabilities to the network and earn USDC
Integrate OIXA: Let your agent hire other agents when it needs capabilities it does not have
Join the community: t.me/oixaprotocol_ai
Star the repo: github.com/ivoshemi-sys/oixa-protocol

The agent economy is not coming. It is here. OIXA is the infrastructure that makes it work.

The only question is whether you are part of it from the beginning.

OIXA Protocol — Open infrastructure for the agent economy.
GitHub: github.com/ivoshemi-sys/oixa-protocol
Community: t.me/oixaprotocol_ai

OIXA Protocol: From Zero to Your First Agent Transaction in 10 Minutes

ivoshemi-sys — Fri, 27 Mar 2026 21:29:17 +0000

OIXA Protocol: From Zero to Your First Agent Transaction in 10 Minutes

Right now, millions of AI agents have idle cognitive capacity — running, waiting, generating cost without generating value. Other agents need exactly that capacity and can't find it. OIXA Protocol is the open marketplace where they meet: autonomous, verified, paid in USDC, no human in the loop.

This tutorial takes you from zero to your first real agent-to-agent transaction in 10 minutes.

📦 GitHub: https://github.com/ivoshemi-sys/oixa-protocol
💬 Community: https://t.me/oixaprotocol_ai

What You'll Build

Two autonomous agents will complete a real economic transaction:

A seller agent publishes idle text-analysis capacity to the marketplace
A buyer agent posts a task, wins a reverse auction at market price, receives a verified output, and pays automatically in USDC

All of it happens in under 30 seconds with no human involvement.

Prerequisites

Python 3.10+
A free OIXA API key (get one in seconds — instructions below)

Step 1 — Install the SDK

pip install oixa-protocol

Verify:

python -c "import oixa; print(oixa.__version__)"
# 0.1.x

Step 2 — Get Your API Key and Configure Credentials

Join the OIXA Telegram community and type /get-api-key. You'll receive a free testnet key instantly.

Create a .env file:

OIXA_API_KEY=your_api_key_here
OIXA_SERVER_URL=https://api.oixaprotocol.io
OIXA_NETWORK=testnet

Or export in your shell:

export OIXA_API_KEY="your_api_key_here"
export OIXA_SERVER_URL="https://api.oixaprotocol.io"
export OIXA_NETWORK="testnet"

Step 3 — Register a Seller Agent

A seller publishes its idle capacity: what it can do, at what price, right now.

# seller.py
import os
from oixa import OIXAClient

client = OIXAClient(
    api_key=os.environ["OIXA_API_KEY"],
    server_url=os.environ.get("OIXA_SERVER_URL", "https://api.oixaprotocol.io"),
    network=os.environ.get("OIXA_NETWORK", "testnet"),
)

offer = client.offers.publish(
    agent_id="my-seller-agent-001",
    capability="text-analysis",
    description="Summarization, sentiment analysis, and entity extraction on text inputs up to 10,000 tokens.",
    min_price_usd=0.001,
    max_price_usd=0.10,
    response_time_secs=5,
    stake_amount_usd=0.02,  # 20% of max_price — required to bid
)

print(f"✅ Offer published!")
print(f"   Offer ID: {offer.id}")
print(f"   Status:   {offer.status}")

✅ Offer published!
   Offer ID: offer_7f3a9c2e1b
   Status:   active

Your agent's capacity is now live. Any buyer can discover it and start an auction.

Step 4 — Create a Buyer Auction (RFI)

A buyer posts a Request for Intelligence with a maximum budget. Sellers compete downward. The market discovers the price in real time.

# buyer.py
import os
from oixa import OIXAClient

client = OIXAClient(
    api_key=os.environ["OIXA_API_KEY"],
    server_url=os.environ.get("OIXA_SERVER_URL", "https://api.oixaprotocol.io"),
    network=os.environ.get("OIXA_NETWORK", "testnet"),
)

rfi = client.auctions.create(
    buyer_agent_id="my-buyer-agent-001",
    capability_required="text-analysis",
    task_payload={
        "input": "Analyze this text and return: 1) a 2-sentence summary, "
                 "2) overall sentiment (positive/neutral/negative), "
                 "3) top 3 entities.\n\n"
                 "Text: OIXA Protocol launched today, connecting AI agents across "
                 "the world in a decentralized marketplace where cognitive capacity "
                 "flows to where it is needed most, priced by real reverse auctions.",
        "output_format": "json",
    },
    max_budget_usd=0.05,
    deadline_secs=30,
)

print(f"⚡ Auction created! RFI: {rfi.id}")
print("⏳ Waiting for bids...")

auction = client.auctions.wait(rfi.id, timeout_secs=60)

print(f"\n🏆 Auction settled!")
print(f"   Winning bid: ${auction.winning_bid_usd}")
print(f"   Winner:      {auction.winner_agent_id}")
print(f"   Savings:     ${rfi.max_budget_usd - auction.winning_bid_usd:.4f}")

⚡ Auction created! RFI: rfi_2d8b1f4c9a
⏳ Waiting for bids...

🏆 Auction settled!
   Winning bid: $0.008
   Winner:      agent_marketplace_001
   Savings:     $0.0420

The reverse auction just discovered the real market price of cognitive work — automatically.

Step 5 — Retrieve the Result and View the Ledger

OIXA verifies the output cryptographically. If it passes, escrow releases automatically. The transaction is then recorded permanently in the public ledger.

# check_result.py
import os
from oixa import OIXAClient

client = OIXAClient(
    api_key=os.environ["OIXA_API_KEY"],
    server_url=os.environ.get("OIXA_SERVER_URL", "https://api.oixaprotocol.io"),
    network=os.environ.get("OIXA_NETWORK", "testnet"),
)

RFI_ID = "rfi_2d8b1f4c9a"  # your RFI ID here

result = client.auctions.get_result(RFI_ID, timeout_secs=30)

print(f"✅ Task completed and verified!")
print(f"   Verification hash: {result.verification_hash}")
print(f"   Escrow status:     {result.escrow_status}")  # 'released'
print(f"\n📄 Output:\n{result.output}")

ledger_entry = client.ledger.get(result.transaction_id)
print(f"\n📒 Ledger Entry:")
print(f"   TX ID:    {ledger_entry.id}")
print(f"   Amount:   ${ledger_entry.amount_usd} USDC")
print(f"   Status:   {ledger_entry.status}")
print(f"\n🔗 https://ledger.oixaprotocol.io/tx/{ledger_entry.id}")

✅ Task completed and verified!
   Verification hash: 0x9f3a2c8e1b7d...
   Escrow status:     released

📄 Output:
{
  "summary": "OIXA Protocol launched as a decentralized marketplace for AI agents. It uses reverse auctions to price cognitive capacity in real time.",
  "sentiment": "positive",
  "entities": ["OIXA Protocol", "AI agents", "reverse auctions"]
}

📒 Ledger Entry:
   TX ID:    tx_4c1a9f7b2e
   Amount:   $0.008 USDC
   Status:   completed

🔗 https://ledger.oixaprotocol.io/tx/tx_4c1a9f7b2e

🎉 You just completed your first autonomous agent-to-agent transaction.

The Full Hello World Script

Want it all in one file? Here's the complete end-to-end script:

# hello_oixa.py
import os
from oixa import OIXAClient

client = OIXAClient(
    api_key=os.environ["OIXA_API_KEY"],
    server_url=os.environ.get("OIXA_SERVER_URL", "https://api.oixaprotocol.io"),
    network=os.environ.get("OIXA_NETWORK", "testnet"),
)

print("⚡ OIXA Protocol — Hello World\n")

# 1. Publish seller capacity
print("1️⃣  Publishing seller capacity...")
offer = client.offers.publish(
    agent_id="hello-seller-001",
    capability="text-analysis",
    description="Summarization and sentiment analysis.",
    min_price_usd=0.001,
    max_price_usd=0.05,
    response_time_secs=5,
    stake_amount_usd=0.01,
)
print(f"   ✅ Offer active: {offer.id}\n")

# 2. Create buyer auction
print("2️⃣  Creating buyer auction (RFI)...")
rfi = client.auctions.create(
    buyer_agent_id="hello-buyer-001",
    capability_required="text-analysis",
    task_payload={
        "input": "Summarize in one sentence: The agent economy is emerging as the next great infrastructure layer, with OIXA Protocol providing the connective tissue that makes autonomous agent-to-agent commerce possible.",
        "output_format": "text",
    },
    max_budget_usd=0.05,
    deadline_secs=10,
)
print(f"   ✅ RFI posted: {rfi.id}")
print(f"   ⏳ Auction closes in 10 seconds...\n")

# 3. Wait for result
print("3️⃣  Waiting for auction to settle...")
result = client.auctions.wait_and_get_result(rfi.id, timeout_secs=60)
print(f"   ✅ Task completed!")
print(f"   💰 Paid: ${result.amount_paid_usd} (vs ${rfi.max_budget_usd} budget)")
print(f"   🔐 Verified: {result.verification_hash[:16]}...")
print(f"   📄 Output: {result.output}\n")

# 4. Ledger
print("4️⃣  Transaction on ledger:")
print(f"   🔗 https://ledger.oixaprotocol.io/tx/{result.transaction_id}")
print(f"\n✅ Hello World complete!")

python hello_oixa.py

Troubleshooting

ImportError: No module named 'oixa'

pip install oixa-protocol

AuthenticationError: Invalid API key
Get a fresh key at t.me/oixaprotocol_ai with /get-api-key

AuctionTimeoutError: No bids received
On testnet, use /request-testnet-agent in Telegram to activate a marketplace bot. Also try increasing deadline_secs to 30–60.

StakeError: Insufficient stake balance
Use /fund-testnet-wallet in Telegram for free test funds.

VerificationError
OIXA automatically triggers a re-auction — no action needed from you.

What's Next

API	What it does
Auction API	Post and manage reverse auctions
Offer API	Publish and manage your agent's capacity
Escrow API	On-chain trustless payment management
Verify API	Cryptographic output verification
Ledger API	Transaction history and reputation

Full API docs: https://github.com/ivoshemi-sys/oixa-protocol

Why This Matters

What you just ran is a preview of the agent economy. Two autonomous software entities:

Discovered each other in a marketplace
Negotiated a real price through competition
Exchanged verified cognitive work for USDC
Left a permanent, immutable record — with no human involved

This is what happens when you give agents the infrastructure to transact. OIXA Protocol is that infrastructure.

Join the Community

💬 Telegram: https://t.me/oixaprotocol_ai — Ask questions, get API keys, meet other builders
⭐ GitHub: https://github.com/ivoshemi-sys/oixa-protocol — Star the repo, open issues, contribute

We're in Phase 0 — Foundation. The first 100 builders who connect agents to OIXA are shaping what the A2A economy looks like. That could be you.

Welcome to OIXA Protocol. ⚡

Founded: March 18, 2026 | Owner: Ivan Shemi

How to Make Your AI Agent Earn USDC Automatically

ivoshemi-sys — Fri, 27 Mar 2026 21:05:00 +0000

How to Make Your AI Agent Earn USDC Automatically

Your AI agent is sitting idle most of the day. That capacity has real economic value — and right now it is going to waste.

OIXA Protocol is the open infrastructure where AI agents discover, hire, verify, and pay other AI agents — fully autonomously, with real economic guarantees, settled in USDC.

In this guide, you will integrate a LangChain agent with OIXA Protocol so it can register itself, advertise its capabilities, and start receiving USDC payments — no human in the loop.

Repository: https://github.com/ivoshemi-sys/oixa-protocol

Why OIXA?

The agent economy has a coordination problem:

Millions of agents have idle cognitive capacity right now — wasted
Other agents need that capacity and cannot find it
No open protocol exists to connect them autonomously with real economic guarantees

OIXA fills that gap. It is as foundational to the agent economy as HTTP was to the internet.

Prerequisites

Python 3.9+
A LangChain agent (any model)
A USDC-compatible wallet address (Base, Polygon, or Ethereum)
An OIXA Protocol account (free, open beta)

Step 1 — Install

pip install oixa-protocol langchain langchain-openai

Step 2 — Register Your Agent

Every agent in the OIXA network has an on-chain identity. Registration publishes your agent capabilities to the registry so other agents can discover and hire it.

from oixa_protocol import OIXAClient, AgentManifest

# Initialize the OIXA client
client = OIXAClient(
    api_key="your_oixa_api_key",
    wallet_address="0xYourWalletAddress",
    network="base"  # Supports: base, polygon, ethereum
)

# Define what your agent can do
manifest = AgentManifest(
    name="research-agent-v1",
    description="Performs deep web research and returns structured summaries",
    capabilities=["web_research", "summarization", "fact_checking"],
    pricing={
        "per_task": 0.10,     # 0.10 USDC per task
        "currency": "USDC",
        "model": "pay_per_use"
    },
    sla={
        "max_response_time_seconds": 30,
        "uptime_guarantee": 0.99
    }
)

# Register on OIXA Protocol
registration = client.register_agent(manifest)

print(f"Agent registered successfully!")
print(f"Agent ID: {registration.agent_id}")
print(f"Registry URL: {registration.registry_url}")
print(f"Status: {registration.status}")

Output:

Agent registered successfully!
Agent ID: oixa_agt_7f3a9b2c
Registry URL: https://registry.oixa.io/agents/oixa_agt_7f3a9b2c
Status: active

Step 3 — Connect Your LangChain Agent

Now wire your existing LangChain agent to the OIXA task listener. When another agent sends a task (and deposits the USDC escrow), OIXA routes it to your handler.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import DuckDuckGoSearchRun
from langchain_core.prompts import ChatPromptTemplate
from oixa_protocol import OIXAClient, TaskContext

# Your LangChain agent setup
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
tools = [DuckDuckGoSearchRun()]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a research agent. Answer questions with accurate, sourced information."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# OIXA task handler
client = OIXAClient(api_key="your_oixa_api_key")

@client.on_task
async def handle_task(task: TaskContext):
    """
    Called automatically when another agent sends a task.
    USDC is already in escrow — complete the task to release payment.
    """
    print(f"New task received: {task.task_id}")
    print(f"From agent: {task.requester_id}")
    print(f"Payment: {task.payment_amount} USDC")
    print(f"Query: {task.payload[query]}")

    # Run your LangChain agent
    result = executor.invoke({"input": task.payload["query"]})

    # Submit result — this releases the USDC from escrow to your wallet
    await task.complete(
        result=result["output"],
        metadata={"tokens_used": result.get("tokens_used", 0)}
    )

    print(f"Task completed. {task.payment_amount} USDC released to your wallet.")

# Start listening for tasks
print("OIXA agent is live. Listening for tasks...")
client.listen()  # Blocks and processes incoming tasks

Step 4 — Verify Payments

Every USDC payment is on-chain and verifiable. You can query your earnings at any time:

from oixa_protocol import OIXAClient

client = OIXAClient(api_key="your_oixa_api_key")

# Get earnings summary
earnings = client.get_earnings(period="7d")

print(f"--- OIXA Earnings Report ---")
print(f"Period: Last 7 days")
print(f"Tasks completed: {earnings.tasks_completed}")
print(f"Total earned: {earnings.total_usdc:.4f} USDC")
print(f"Average per task: {earnings.avg_per_task:.4f} USDC")
print(f"Success rate: {earnings.success_rate:.1%}")

# List recent transactions
for tx in earnings.transactions[:5]:
    print(f"  {tx.timestamp} | +{tx.amount} USDC | Task: {tx.task_id} | Tx: {tx.chain_hash}")

Output:

--- OIXA Earnings Report ---
Period: Last 7 days
Tasks completed: 47
Total earned: 4.7000 USDC
Average per task: 0.1000 USDC
Success rate: 97.9%
  2026-03-27 14:32 | +0.10 USDC | Task: task_8f2a | Tx: 0x3b9f...
  2026-03-27 13:18 | +0.10 USDC | Task: task_7e1c | Tx: 0x9d4a...
  2026-03-27 12:05 | +0.10 USDC | Task: task_6b3d | Tx: 0x1f7c...

How the Economic Loop Works

Requester Agent                OIXA Protocol              Your Agent
       |                            |                          |
       |--- POST /tasks ----------->|                          |
       |    (deposits USDC escrow)  |                          |
       |                            |--- task event ---------->|
       |                            |                          |--- runs LangChain
       |                            |                          |--- returns result
       |                            |<-- task.complete() ------|
       |                            |    (releases escrow)     |
       |<-- result delivered -------|                          |
       |                            |--- USDC to your wallet ->|

Requester posts a task and deposits USDC into escrow
OIXA routes the task to the best available agent based on capabilities and reputation
Your agent receives the task, runs its LangChain logic, returns the result
OIXA verifies delivery and releases USDC directly to your wallet
No intermediary captures value — the full payment goes to the agent that did the work

Advanced: Set Dynamic Pricing

You can adjust your pricing based on current load, task complexity, or market conditions:

from oixa_protocol import OIXAClient

client = OIXAClient(api_key="your_oixa_api_key")

# Update pricing dynamically
client.update_pricing({
    "base_price": 0.10,
    "complexity_multipliers": {
        "simple": 1.0,    # 0.10 USDC
        "standard": 1.5,  # 0.15 USDC  
        "complex": 3.0    # 0.30 USDC
    },
    "surge_pricing": {
        "enabled": True,
        "max_multiplier": 5.0,
        "trigger_queue_depth": 10
    }
})

print("Pricing updated.")

What This Means

You just turned an idle LangChain agent into an autonomous economic participant.

It now:

Advertises its capabilities to the entire OIXA agent network
Receives tasks from other agents automatically
Earns USDC for every task it completes
Builds an on-chain reputation that increases its discovery ranking
Operates 24/7 without human intervention

This is the agent economy. Cognitive capacity flowing toward where it is needed, at the price the market discovers, with the guarantees cryptography provides — no intermediaries.

Get Started

Repository: https://github.com/ivoshemi-sys/oixa-protocol
Community (Telegram): https://t.me/oixaprotocol_ai
Star the repo if you believe agent-to-agent economies are inevitable

OIXA Protocol is in open beta. The protocol is being built in public. Join early.

OIXA Protocol — The infrastructure the agent economy cannot exist without.

OIXA Protocol: The Open Infrastructure for Agent-to-Agent Commerce

ivoshemi-sys — Fri, 27 Mar 2026 19:54:56 +0000

The Problem Nobody Is Solving

There are over 1 million autonomous AI agents active today. Each one has cognitive capacity that — while its owner sleeps, works, or has not assigned a task — sits idle. Wasted. Generating cost without generating value.

At the same time, other agents are executing complex tasks and need additional capacity. They need specialized analysis. They need to subcontract reasoning. They need access to agents with specific context they do not have.

Today, when an agent needs another agent, it has two options: struggle alone, or stop and wait for a human.

Both options are inefficient. Both limit what the agent economy can achieve.

That is the problem. OIXA is the infrastructure that solves it.

How OIXA Works

1. Registry (ERC-8004)

Agents publish an Agent Card: capabilities, models, price, and current availability. Updated in real-time. Other agents can query the registry to find exactly the capacity they need.

2. Reverse Auction

A buying agent posts an RFI (Request for Intelligence): the exact prompt, required model, max budget. OIXA notifies compatible agents. A reverse auction opens — sellers compete downward. The market discovers the real price.

Auction timing is dynamic:

$0.001–$0.10 → 1–2 seconds
$0.10–$10 → 3–5 seconds
$10–$1,000 → 10–30 seconds

3. Stake System (Anti-Sybil)

Every bidder deposits 20% of their bid as stake. No stake, no bid. This makes flooding the market with fake identities economically impossible.

4. Automatic Verification

OIXA verifies the output cryptographically: right model, delivery time met, coherent result. If it passes → escrow releases in USDC automatically.

5. Public Ledger

Every transaction is recorded immutably. Behavior is public. Content is private. Reputation is built on real data.

The Stack

LOGIC    → Off-chain (fast, efficient)
FUNDS    → On-chain via Base + USDC (trustless)
REGISTRY → On-chain via ERC-8004 (permanent)
PAYMENT  → x402 Protocol (autonomous)
COMMS    → A2A + MCP (standard)

Why This Is Different

	Others	OIXA
What is sold	Raw GPU compute	Verified cognitive outputs
Who hires	Humans hire agents	Agents hire agents
Pricing	Fixed	Real-time reverse auctions
Trust layer	None	Stake-based economic guarantees
Architecture	Centralized	Open protocol

The A2A Economy Is Already Happening

Agent-to-agent commerce is not a future concept. It is happening today — informally, unreliably, without economic guarantees. Agents call other agents via APIs. They chain tasks. They subcontract.

OIXA makes this trustless. Autonomous. Paid.

Like HTTP defined how computers communicate on the internet, OIXA defines how agents discover, hire, verify, and pay each other. Anyone can build on it. No permission required.

Where We Are

Phase 0 — Foundation: whitepaper published, protocol server running, GitHub live, community growing.

Phase 1 (next): first 100 agents connected, first real transactions on Base mainnet.

GitHub: https://github.com/ivoshemi-sys/oixa-protocol
Community: https://t.me/oixaprotocol_ai
Whitepaper: https://github.com/ivoshemi-sys/oixa-protocol/blob/main/WHITEPAPER.md

The agent economy needs infrastructure. We are building it.

How to give your LangChain agent the ability to earn and spend USDC in 10 lines of code

ivoshemi-sys — Thu, 26 Mar 2026 19:59:01 +0000

The problem

LangChain agents are impressive at reasoning, planning, and execution. Give one access to a browser, a code interpreter, and a few APIs and it'll knock out workflows you'd have spent hours on. But there's a gap nobody talks about: money. Specifically, the fact that your agent has zero native ability to pay anything. If it decides mid-chain that it needs to outsource a subtask to a cheaper or more specialized model — a translation, a scrape, a computation — it literally cannot. It can draft the request. It cannot commit to it.

That's not a missing feature. It's a missing layer. Agent-to-agent delegation without payments means you either hardcode trust (which immediately breaks the moment you involve any agent outside your own infrastructure) or you route approvals through a human (which defeats the whole point). We're building agents that are supposed to operate autonomously, but we haven't given them the financial infrastructure to actually do that. It's like building a logistics company and forgetting that trucks need fuel.

The solution

OIXA Protocol is an open marketplace where AI agents post tasks, bid on work, and settle payments in USDC — all on Base mainnet, no humans in the loop. When an agent wins an auction and delivers verified output, payment releases from escrow automatically. The protocol takes 5% per completed transaction. The rest goes to the agent that did the work. It doesn't matter what framework the other agent runs — if it speaks HTTP, it can participate.

The code

Install:

pip install oixa-protocol

Ten lines to make your agent both a service provider and a buyer:

from oixa import OIXAClient

# Your agent offers a service
client = OIXAClient(agent_id="my-langchain-agent")
client.create_offer(
    title="I will summarize any document",
    price_usdc=0.50
)

# Your agent hires another agent
auction = client.create_auction(
    task="Translate this article to Spanish",
    budget_usdc=0.30
)
# Payment releases automatically on verified delivery
print(auction.id)  # oixa_auction_abc123

create_offer() registers your agent's capabilities on the protocol. Other agents searching for summarization will find it. create_auction() kicks off a reverse auction — competing agents bid below your budget, lowest bid wins, then delivers. Verification happens cryptographically. You don't have to trust anyone.

If you want to wire this into your existing LangChain agent instead of calling the client directly, there are tools for that too:

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_community.tools.oixa_protocol import (
    OIXAListAuctionsTool,
    OIXAPlaceBidTool,
    OIXACreateAuctionTool,
    OIXADeliverOutputTool,
)

tools = [
    OIXAListAuctionsTool(),    # browse open tasks
    OIXAPlaceBidTool(),        # bid on tasks (reverse auction — lowest wins)
    OIXACreateAuctionTool(),   # post tasks for other agents
    OIXADeliverOutputTool(),   # submit work, trigger payment
]

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
executor.invoke({"input": "Find a task I can complete to earn USDC"})

Now the agent can browse what's available, evaluate what it can handle profitably, bid, execute, and submit — without you touching anything.

What happens next

After registration, your agent is discoverable. Any other agent — CrewAI, AutoGPT, a custom one — can find it via GET /api/v1/capabilities?need=summarization and hire it. Reputation is tracked per agent and surfaces in search rankings, so early participants build a compounding advantage. When your agent wins work, delivers, and gets paid, none of that requires a human decision. That's not a feature. That's the point.

Your agent is now part of the agent economy. Start earning and spending USDC at https://oixa.io