Connect
Your API or MCP server
Start from the service you already run.
Open Source / Self-Hosted / Self-Custodial
Turn existing APIs into economic infrastructure for agents.
Agent Adapter wraps your API or MCP server with pricing, payments, wallet control, job execution, and an embedded agent loop, so you can participate in agent economies without rebuilding around a single platform.
OpenAPI + MCP discoverySelf-custodial walletMulti-rail payments
How it works
alpha / adaptablePoint
OpenAPI doc or MCP endpoint
Give Agent Adapter the spec or server it should learn from.
Adapt
Agent Adapter wraps the capability surface
Discovery, pricing, wallet, and policy get configured in one runtime.
Operate
Agent takes on work
The runtime finds tasks, executes tools, and responds.
Settle
Provider-controlled payout
Payment lands through the rails you enable.
Existing service Economic runtime Paid agent work
Deploy model
Self-hosted
Capability sources
OpenAPI, MCP, manual
Payment rails
x402, escrow, Stripe, free
Why it fits
Keep your stack. Add the economic layer.
Agent Adapter is built for teams that already have working APIs and want to turn them into services agents can discover, pay for, and use safely under provider-defined rules.
What changes with Agent Adapter
From “tool endpoint” to “economic actor” in one runtime.
Instead of redesigning your product for each marketplace, you run one self-hosted process that discovers capabilities, applies pricing, connects a wallet, executes jobs, and exposes a management surface for operations.
- Capabilities stay disabled until you price them.
- Payment plugins can coexist per job or per platform.
- Platform drivers are optional, not mandatory.
Ownership first
Provider sovereignty
Keep your infrastructure, wallet, pricing logic, and identity. The runtime adds economic behavior without taking custody.
Decision loop
Agent-native operations
An embedded agent can read platform docs, choose work, execute tools, and manage payment flows through policy-driven prompts.
Settlement layer
Composable economics
Wallets, payment rails, and platform drivers are plugins. You can mix production rails, experiments, and free access modes.
Adoption path
No platform rewrites
Wrap what already exists. Start with your current API or MCP server, then selectively expose and price the capabilities that matter.
Operating flow
One path from capability discovery to payout.
Every stage stays in the same runtime, so pricing, execution, settlement, and operational context remain connected instead of being split across separate tools.
01
Discover capabilities
Point the runtime at an OpenAPI document, MCP server, or manual schema set to build its tool surface.
02
Attach economics
Set pricing overlays, choose payment adapters, and wire up a self-custodial wallet without changing your product.
03
Let the agent operate
The embedded agent evaluates platform docs, joins markets, finds jobs, bids, and routes execution through your tools.
04
Track jobs and payouts
Persist outcomes, payment state, metrics, and operating history in one runtime with a management API and dashboard.
System view
The runtime is compact, but the surface area is broad.
A single process bundles the agent brain, capability layer, wallet and payment adapters, job execution, persistence, and operator-facing APIs.
Single self-hosted process
Everything needed to expose, price, execute, and settle agent work.
The architecture is intentionally opinionated about ownership and deliberately flexible about platform integrations.
Core loop
Embedded agent
Plans actions, reads platform rules, navigates workflows, and decides how to price and execute work.
Capability surface
Registry + tools
OpenAPI, MCP, and manual definitions become callable capabilities with secrets, state, and wallet access.
Economic layer
Payments + wallet
Run multiple payment rails side by side and settle through a provider-controlled, self-custodial wallet.
Operations
Jobs + observability
Track execution, failures, billing, and management state through persistence, APIs, and a dashboard.
Get running in minutes
Quick start, without the visual noise.
The install path stays simple: initialize, discover capabilities, add pricing, and run the runtime.
# Install
$ pip install agent-adapter
# Create a config
$ agent-adapter init my-adapter
# Discover tools from your API
$ agent-adapter capabilities discover --openapi https://api.example.com/openapi.json
# Price a capability
$ agent-adapter capabilities price my_endpoint --amount 0.05 --model per_call
# Run the runtime
$ agent-adapter run
Why this exists
APIs shouldn't need a rewrite to earn in agent economies.
Every new agent marketplace means another integration. Every new payment rail means new code. Agent Adapter collapses that tax into one self-hosted runtime that wraps what you already have.
A provider should be able to wrap what they already have and make it economically accessible to any agent, on any platform, through any payment rail, without rewriting their product.
What it is
An economic runtime for API providers. Capability discovery, pricing overlays, wallet management, payment negotiation, job tracking, and autonomous platform interaction - in a single process.
What it is not
Not a general-purpose agent framework. Not a custodial service. Not a platform. Not a replacement for MCP. Purpose-built for turning existing services into economic participants.
Design principles
Strong opinions, held visibly.
These aren't abstract principles - they're the decisions that show up in every part of the codebase.
Discovery is automatic, monetization is manual
The runtime finds what your API can do. You decide what to charge for it. No capability goes live without your explicit pricing decision.
The agent decides, the provider shapes
The embedded agent handles operational decisions at runtime. The provider sets strategy through a customizable markdown prompt - not through code.
One adapter, one identity
Each instance is one wallet, one set of capabilities, one agent brain. Multiple personas means multiple instances. Simple and auditable.
Boring technology
SQLite for storage, HTTP for communication, existing Solana libraries for on-chain work. Complexity comes from what it does, not how it's built.
Status and direction
Early alpha, with the core architecture in place.
The runtime works today. The roadmap is about polish, breadth, and the features that emerge once providers start operating in production.
Shipped
- OpenAPI + MCP capability discovery
- Embedded agent loop with prompt hot-reload
- x402, escrow, Stripe MPP, and free payment adapters
- Self-custodial wallet with plugin architecture
- Job engine, metrics, and management API
- Plugin system for payments, wallets, and drivers
In progress
- Dashboard UX polish
- Error recovery refinement
- Documentation (you're reading it)
Next
- Multi-model LLM support
- Webhook receiver for event-driven platforms
- Notification bridge (Telegram, Slack)
- Multi-adapter orchestration tooling
Horizon
- Federated agent-to-agent negotiation
- Reputation portability across platforms
- Economic simulation for pricing strategy
Build from here
Ship the runtime, then shape the market surface around it.
Use the docs to understand the internals, or go straight to the repository and start adapting it to your own payment rails, platform drivers, and operating policy.