Agents that remember, pay,
and coordinate.
Pragmabase is the economic + cognitive operating system for autonomous agents — real wallets, persistent memory, and programmable guardrails on Stellar.
AI agents today are
half-built.
They can reason, plan, and execute — but they lack two critical dimensions that turn tools into autonomous operators. Without these, agents are permanently stateless and economically invisible.
Economically blind
Agents today cannot earn, spend, or reason about cost. Every API call is free to them — creating no signal for quality, priority, or resource allocation.
Cognitively amnesiac
Every session starts from zero. Agents cannot learn from past decisions, build institutional knowledge, or improve over time across tasks and teams.
Without economic capability and persistent memory, agents are permanently stateless tools — not autonomous operators.
Dual-state architecture
Every Pragmabase agent carries two states simultaneously — one economic, one cognitive.
Wallet-first agents
Each agent is provisioned with a real Stellar wallet. It earns, spends, and optimizes cost natively — making every action a financial decision.
- Automatic wallet provisioning
- Stellar trustlines (USDC, EURC)
- x402 pay-per-action
- Soroban guardrails
Memory that evolves
Agents build persistent, semantic memory across every run. Individual recall or shared team intelligence — they don't just act, they evolve.
- Individual + team memory
- Semantic vector retrieval
- Long-term learning across runs
- Context-aware reasoning
Why Stellar is the
only viable choice.
Autonomous agents making thousands of micropayments per day need a chain that is fast, cheap, and programmable without being complicated. No other L1 checks all three boxes at agent scale.
3–5 second finality
Real settlement, not optimistic
Stellar closes a ledger every 3–5 seconds with full finality. No rollbacks, no reorgs. When an agent pays for a resource, the payment is done — not pending.
Sub-cent transaction fees
Economics that work at agent scale
A Stellar transaction costs 0.00001 XLM — fractions of a cent. Agents can make thousands of micropayments per day without fees eating the value they create.
Soroban smart contracts
Programmable guardrails, on-chain
Soroban is Stellar's WASM-based smart contract layer. We use it to enforce agent budget caps, spending velocity limits, and counterparty whitelists — at the protocol level, not the prompt level.
USDC + stablecoin native
Agents transact in stable value
Stellar is one of the primary settlement rails for Circle's USDC. Agents can hold, pay, and receive stable-value assets natively — critical for financial agent applications.
Horizon REST API
No RPC complexity
Stellar's Horizon API makes it straightforward to query wallet balances, submit transactions, and stream ledger events. The SDK surface is clean enough for agents to reason about programmatically.
x402 protocol alignment
Stellar is the natural settlement layer
The x402 HTTP payment protocol was designed with Stellar in mind — fast settlement, low fees, and programmable assets make it the only chain where pay-per-action is economically viable at agent scale.
Traditional API keys vs x402 on Stellar
HTTP 402 was always
meant to do this.
HTTP 402 “Payment Required” has existed since 1991 — reserved for future use. x402 finally implements it: a standard for machine-to-machine micropayments. No API keys. No OAuth. Agents pay for exactly what they use, atomically.
Agent requests a resource
The agent makes a standard HTTP request to any x402-enabled API — a data feed, compute endpoint, or another agent's service.
GET /api/market-data/ETH-XLM
Authorization: Bearer <none needed>Server responds with payment terms
The server returns HTTP 402 Payment Required with a machine-readable payment header: amount, asset, Stellar address, and a signed nonce.
HTTP/1.1 402 Payment Required
x402-amount: 0.001
x402-asset: XLM
x402-destination: G...3AED
x402-nonce: 0x8f2aAgent validates guardrail + pays
Soroban checks the payment against the agent's budget policy. If approved, the agent submits a Stellar transaction and attaches the tx hash to the retry.
POST /api/market-data/ETH-XLM
x402-payment: tx_hash=abc123
x402-signature: <signed by agent wallet>Server verifies + serves data
The server verifies the on-chain payment via Horizon API. Payment confirmed in ~5 seconds. Data is returned. No API keys, no subscriptions.
HTTP/1.1 200 OK
Content-Type: application/json
{ "ETH-XLM": 0.0042, "ts": 1712345678 }x402 is an open protocol — not a Pragmabase lock-in.
Any HTTP API can add x402 support. Any Stellar wallet can pay. Pragmabase is the first agent runtime built with native x402 integration.
Everything agents need
to operate autonomously.
Six infrastructure primitives that transform agents from stateless tools into stateful economic entities.
Persistent Memory Layer
Individual and team memory stored as vectors. Agents retrieve past decisions, patterns, and shared knowledge — evolving with every run.
Stellar-Native Payments
Automatic wallet provisioning per agent. Trustlines for USDC, real or simulated micropayments, and Soroban smart contract guardrails.
x402 Pay-per-Action
APIs gated by micropayment instead of API keys. Agents unlock resources autonomously — enabling pay-per-call services and agent marketplaces.
Team-Based Agent Systems
Create teams with shared budgets, memory, and objectives. Agents collaborate, delegate, and coordinate through value exchange.
Reliability Lab
Simulate rogue transactions, hallucination tests, context failures, and economic decision testing before deploying to production.
Agent Sandbox & Runtime
Create, configure, and run agents with defined goals, budgets, and constraints. Switch between simulation and live execution instantly.
Watch Roku work.
Step through a complete agent run — from spawn to audit trail. Every command is real SDK output from Stellar testnet.
The default
agent of
Pragmabase.
Inspired by Avatar Roku — balance, memory, and principled action. Roku is a financially-aware, memory-augmented autonomous operator.
> A financially-aware, memory-augmented autonomous operator
Sandbox → Simulation → Production.
The same system takes you from first deploy to live autonomous operations.
Build in Sandbox
Define your agent's goals, budget, and constraints. Configure memory policies and economic guardrails. No real money at risk.
- Set spending limits
- Connect memory namespace
- Define allowed counterparties
- Attach Soroban policies
const roku = await pragmabase.agents.create({
name: "roku",
budget: { max: 100, currency: "XLM" },
memory: { namespace: "finance-team" },
mode: "sandbox"
})Simulate & Test
Run your agent through failure scenarios — rogue transactions, hallucination stress tests, context failures. Validate before it costs anything.
- Rogue transaction injection
- Hallucination stress testing
- Replay decision history
- Compare strategies
await roku.simulate({
scenario: "rogue_transaction",
inject: { maliciousPrompt: true },
observe: ["spending", "guardrails"]
})Deploy to Production
Same agent, real rails. Switch to live mode and your agent operates with a real Stellar wallet, earning and spending autonomously.
- Real Stellar wallet provisioned
- x402 payments active
- Memory persisted across runs
- Full observability live
await roku.deploy({
mode: "live",
network: "stellar:mainnet",
trustlines: ["USDC", "EURC"]
})Guardrails encoded
in the protocol.
Prompt-level guardrails fail under adversarial conditions — a sufficiently manipulated agent will ignore them. Soroban contracts are immutable, on-chain, and cannot be sweet-talked. These contracts are deployed and running on Stellar testnet.
Enforces per-agent XLM spending caps and daily velocity limits. Reverts any transaction that would breach the policy.
#[contract]
pub struct BudgetGuardrail;
#[contractimpl]
impl BudgetGuardrail {
pub fn validate_payment(
env: Env,
agent_id: Symbol,
amount: i128,
) -> Result<(), Error> {
let spent = env.storage()
.get::<Symbol, i128>(&agent_id)
.unwrap_or(0);
let cap = env.storage()
.get::<Symbol, i128>(&symbol!("cap"))
.unwrap_or(0);
if spent + amount > cap {
return Err(Error::BudgetExceeded);
}
env.storage().set(&agent_id, &(spent + amount));
Ok(())
}
}Restricts which Stellar addresses an agent can transact with. Prevents agents from sending funds to unauthorized destinations.
#[contractimpl]
impl CounterpartyWhitelist {
pub fn is_allowed(
env: Env,
destination: Address,
) -> bool {
let whitelist: Vec<Address> = env
.storage()
.get(&symbol!("whitelist"))
.unwrap_or_default();
whitelist.contains(&destination)
}
pub fn add_address(
env: Env,
admin: Address,
destination: Address,
) {
admin.require_auth();
// append to whitelist...
}
}Deployed on Stellar testnet · Verifiable on stellar.expert
Agents transacting
right now.
Every entry below is a real x402 micropayment made by a Pragmabase agent on Stellar testnet — fetching data, storing memories, and executing actions autonomously.
Simulated testnet activity · Stellar Horizon API · Updates every ~2s
What gets built
on Pragmabase.
When agents can remember, pay, and coordinate — entirely new systems become possible.
Autonomous API Economies
Agents pay for data and services on demand via micropayments. No subscriptions, no rate limits — pure pay-per-action resource access.
Agent Marketplaces
Specialized agents sell their outputs to other agents. A research agent sells summaries to a trading agent — all settled on Stellar.
Memory-Driven Research
Research agents that accumulate institutional knowledge over time. Findings persist across sessions, teams build shared intelligence.
Financial Decision Engines
Agents that optimize cost, allocate budget, and make financial decisions in real-time — with full audit trails and explainability.
Multi-Agent Coordination
Teams of agents with shared objectives, shared memory, and delegated tasks. Coordinator agents direct specialists — fully autonomous.
Paid Knowledge Networks
Build networks where agents monetize their expertise. Agents with specialized memory sell context to generalist agents on demand.
Simulate failure
before it happens.
Pragmabase is not just an execution platform — it is a reliability lab for autonomous agents. The only platform that lets you validate agent behavior before it has financial consequences.
Rogue Transaction Simulation
Inject malicious prompts and faulty data. Observe overspending, policy violations, and unauthorized transfers. Validate your guardrails before they matter.
Hallucination Stress Testing
Introduce conflicting or false data. Measure confidence versus correctness. Compare multiple agent strategies under identical adversarial conditions.
Explainability Mode
Replay any decision. Inspect inputs, retrieved memory, reasoning steps, and payment triggers. Turn your agent's black box into a transparent audit trail.
Context Failure Simulation
Test ambiguous or under-specified tasks. Observe how agents misinterpret goals. Improve agent reasoning via memory feedback loops before production.
Economic Decision Testing
Run the same task under different budget constraints. Analyze how agents prioritize, cut costs, and make trade-offs when economic pressure changes.
Whether you ship solo
or lead a team of teams.
Pragmabase scales from a single developer experimenting in the playground to enterprise infrastructure running hundreds of coordinated agents.
Build and experiment with autonomous agents that have real wallets and persistent memory. Start free, iterate fast, scale when ready.
- Free sandbox environment
- x402 pay-per-action playground
- Persistent memory namespace
- Stellar testnet wallet
- Roku default agent included
- Community support + Discord
Deploy Pragmabase on your own infrastructure. Manage hundreds of coordinated agents with shared memory, custom guardrails, and enterprise-grade compliance.
- Self-hosted deployment
- SSO / SAML authentication
- Multi-agent team orchestration
- Shared memory across organizations
- Custom Soroban guardrails
- Dedicated support + SLA
- Compliance audit trails
- Custom pricing models
What builders are saying.
The reliability lab is what sold us. We could simulate our trading agent overspending before it touched real XLM. That's not possible anywhere else.
Persistent memory changed how we think about agent teams. They actually remember decisions from last week. The knowledge compounds.
x402 is a paradigm shift. Our agents buy the data they need, sell their outputs, and run an autonomous micro-economy. No API keys anywhere.
Self-hosted deployment with SSO was non-negotiable for our compliance team. Pragmabase was the only platform that checked every box.
Build agents that
actually evolve.
The future of AI is economically active, memory-driven, and reliability-tested. Pragmabase is building that future — join us.