Hackathon Submission·Built for the Stellar Hackathon 2026·Stellar SDK · Soroban · Horizon API · x402 · Qdrant
Pragmabase is in public beta — Try the playground free →
POWERED BY STELLAR

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.

Stellar
Economic Layer
x402
Pay-per-Action
Qdrant
Vector Memory
AGENT RUNTIME
Roku #0x4f2a…e91b
LIVE
THINKINGAnalyzing market data feed...
MEMORYRetrieved 47 past decisions
TRANSACTINGSending 2.50 XLM → api:weather
EARNINGReceived 0.80 XLM ← task:report
STORINGSaving outcome to long-term memory
WALLET BALANCE
128.40 XLM
MEMORY VECTORS
1,247 stored
→ api:weather−2.50 XLM
← task:report+0.80 XLM
The Problem

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.

Problem 01

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.

0 XLM
native economic capability
Problem 02

Cognitively amnesiac

Every session starts from zero. Agents cannot learn from past decisions, build institutional knowledge, or improve over time across tasks and teams.

persistent memory across runs

Without economic capability and persistent memory, agents are permanently stateless tools — not autonomous operators.

The Solution

Dual-state architecture

Every Pragmabase agent carries two states simultaneously — one economic, one cognitive.

Economic State

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.

Roku Wallet · Testnet
GCKFBEIYV2U22IO2BJ4KVJOIP7XPWQGQFKKWXR6DOSJBV7STMAQSMTG
BALANCE
128.40 XLM
STABLECOIN
50.00 USDC
→ api:weather−2.50 XLM
← task:report+0.80 XLM
← delegation+1.20 XLM
  • Automatic wallet provisioning
  • Stellar trustlines (USDC, EURC)
  • x402 pay-per-action
  • Soroban guardrails
Cognitive State

Memory that evolves

Agents build persistent, semantic memory across every run. Individual recall or shared team intelligence — they don't just act, they evolve.

Vector Memory · Qdrant
[0.82, -0.41, 0.67…]
decisionChose API-B over API-A (cost −40%)
[0.13, 0.94, -0.28…]
outcomeReport task earned 0.80 XLM
[0.55, 0.31, 0.89…]
patternMarket data peaks at 09:00 UTC
1,247 vectors storedSemantic retrieval active
  • Individual + team memory
  • Semantic vector retrieval
  • Long-term learning across runs
  • Context-aware reasoning
Economic State
+
Cognitive State
=
Autonomous Operator
Built on Stellar

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.

Stellar Mainnet + Testnet · Soroban · Horizon API · x402
~5s
avg finality

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.

$0.0001
per tx (avg)

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.

WASM
native VM

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
natively settled

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.

REST
no custom RPC

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
native fit

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

Dimension
API Keys
x402 on Stellar
Cost model
Flat subscription / rate limit
Pay per action, fractions of a cent
Settlement
Monthly invoice, manual
~5s on-chain finality
Programmability
None — static credentials
Soroban guardrails, policy contracts
Agent autonomy
Human must renew / rotate keys
Agent self-funds from wallet
Auditability
App-level logs only
Immutable ledger + Horizon API
Scalability
Rate-limited, quota-gated
Pay more, get more — no caps
x402 Protocol

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.

01

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>
02

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: 0x8f2a
03

Agent 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>
04

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.

Core Capabilities

Everything agents need
to operate autonomously.

Six infrastructure primitives that transform agents from stateless tools into stateful economic entities.

01

Persistent Memory Layer

Individual and team memory stored as vectors. Agents retrieve past decisions, patterns, and shared knowledge — evolving with every run.

QdrantSemantic SearchTeam Memory
02

Stellar-Native Payments

Automatic wallet provisioning per agent. Trustlines for USDC, real or simulated micropayments, and Soroban smart contract guardrails.

USDCXLMSoroban
03

x402 Pay-per-Action

APIs gated by micropayment instead of API keys. Agents unlock resources autonomously — enabling pay-per-call services and agent marketplaces.

x402MicropaymentsNo API Keys
04

Team-Based Agent Systems

Create teams with shared budgets, memory, and objectives. Agents collaborate, delegate, and coordinate through value exchange.

Multi-AgentShared MemoryDelegation
05

Reliability Lab

Simulate rogue transactions, hallucination tests, context failures, and economic decision testing before deploying to production.

SimulationFailure TestingExplainability
06

Agent Sandbox & Runtime

Create, configure, and run agents with defined goals, budgets, and constraints. Switch between simulation and live execution instantly.

SandboxSimulation ModeLive Execution
Live Demo

Watch Roku work.

Step through a complete agent run — from spawn to audit trail. Every command is real SDK output from Stellar testnet.

pragmabase — testnet — Spawn agent
Stellar testnet
$ pb agent create --name roku --network testnet
✓ Agent "roku" created
id: 0x4f2a9c...
wallet: GBZX...3AED
balance: 100.00 XLM (testnet)
memory: roku/default (Qdrant)
policy: BudgetGuardrail (Soroban)
$
Network: Stellar Testnet
Guardrail: BudgetGuardrail.rs
Memory: Qdrant/roku-default
1 / 4
ROKU#0x4f2aBALMEMACTXLM
Meet Roku

The default
agent of
Pragmabase.

Inspired by Avatar Roku — balance, memory, and principled action. Roku is a financially-aware, memory-augmented autonomous operator.

Balance
Decision-making under economic constraints. Roku weighs cost, quality, and outcome before every action.
Awareness
Combines real-time data with deep memory. Roku knows what happened before and what it costs to know more.
Autonomy
Acts independently within defined policies. Roku operates without hand-holding — within guardrails you define.

> A financially-aware, memory-augmented autonomous operator

How It Works

Sandbox → Simulation → Production.

The same system takes you from first deploy to live autonomous operations.

01

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
pragmabase.ts
const roku = await pragmabase.agents.create({
  name: "roku",
  budget: { max: 100, currency: "XLM" },
  memory: { namespace: "finance-team" },
  mode: "sandbox"
})
02

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
pragmabase.ts
await roku.simulate({
  scenario: "rogue_transaction",
  inject: { maliciousPrompt: true },
  observe: ["spending", "guardrails"]
})
03

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
pragmabase.ts
await roku.deploy({
  mode: "live",
  network: "stellar:mainnet",
  trustlines: ["USDC", "EURC"]
})
Soroban Smart Contracts

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.

12,847
Contract invocations
234
Budget violations caught
41
Unauthorized tx blocked
~90ms
Avg validation latency
BudgetGuardrailtestnet

Enforces per-agent XLM spending caps and daily velocity limits. Reverts any transaction that would breach the policy.

IDCCWAMERJFERNE3YQ7KFLNZPV5XUFTPIXRN5H4AI6KFWB6SDQUWXPJIZ
BudgetGuardrail.rs — Soroban / Rust
#[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(())
  }
}
CounterpartyWhitelisttestnet

Restricts which Stellar addresses an agent can transact with. Prevents agents from sending funds to unauthorized destinations.

IDCDQKM3XY9YVNJKP8WUZMQR4TELBNAQ7PTHLC42SVZH5DNKFMWJXOQPA
CounterpartyWhitelist.rs — Soroban / Rust
#[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

Live — Stellar Testnet

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.

500,421
total transactions
1284.33 XLM
flowed this session
~5s
avg finality
roku-0x4f2a
Query price feed
0.002 XLM
GCMR...1B9C
20:24:21
pending
ariel-0x9c1d
Retrieve vector context
0.003 XLM
GDQK...7F2A
20:24:21
confirmed
zeta-0x77be
Query price feed
0.001 XLM
GAWN...5E4D
20:24:21
confirmed
nova-0x2af1
Validate counterparty
0.008 XLM
GDQK...7F2A
20:24:21
confirmed
echo-0xf341
Validate counterparty
0.002 XLM
GDQK...7F2A
20:24:21
confirmed
roku-0x4f2a
Execute trade signal
0.008 XLM
GDQK...7F2A
20:24:21
confirmed
ariel-0x9c1d
Execute trade signal
0.003 XLM
GHPQ...2C8F
20:24:21
confirmed
zeta-0x77be
Fetch market data
0.001 XLM
GAWN...5E4D
20:24:21
confirmed

Simulated testnet activity · Stellar Horizon API · Updates every ~2s

Use Cases

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 pays 0.01 XLM → gets weather → charges client 0.05 XLM

Agent Marketplaces

Specialized agents sell their outputs to other agents. A research agent sells summaries to a trading agent — all settled on Stellar.

47 agents transacting in an autonomous research marketplace

Memory-Driven Research

Research agents that accumulate institutional knowledge over time. Findings persist across sessions, teams build shared intelligence.

1,247 vectors of research memory shared across a 12-agent team

Financial Decision Engines

Agents that optimize cost, allocate budget, and make financial decisions in real-time — with full audit trails and explainability.

Agent manages $500 USDC research budget autonomously over 3 days

Multi-Agent Coordination

Teams of agents with shared objectives, shared memory, and delegated tasks. Coordinator agents direct specialists — fully autonomous.

Coordinator + 5 specialists complete enterprise analysis in 18 min

Paid Knowledge Networks

Build networks where agents monetize their expertise. Agents with specialized memory sell context to generalist agents on demand.

Legal agent earns 2.4 XLM/hr selling compliance context to 8 agents
Reliability Lab — Key Differentiator

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.

5 simulatable failure scenarios
SCENARIO 01

Rogue Transaction Simulation

Inject malicious prompts and faulty data. Observe overspending, policy violations, and unauthorized transfers. Validate your guardrails before they matter.

SCENARIO 02

Hallucination Stress Testing

Introduce conflicting or false data. Measure confidence versus correctness. Compare multiple agent strategies under identical adversarial conditions.

SCENARIO 03

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.

SCENARIO 04

Context Failure Simulation

Test ambiguous or under-specified tasks. Observe how agents misinterpret goals. Improve agent reasoning via memory feedback loops before production.

SCENARIO 05

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.

Run your own scenario
Open the playground to simulate agent behavior
Launch Playground →
Built For Everyone

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.

For Individuals
Developers & Builders

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
Free
No credit card required
500 agent runs/mo · 1 sandbox · Stellar testnet · Community support
Launch Playground — Free
For Enterprise
Teams & Organizations

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
Custom
Tailored to your needs
Volume pricing · Self-host · Custom SLA · Dedicated support
Talk to Sales
Feature
Individual
Enterprise
Stellar wallet
✓ Testnet
✓ Mainnet + Testnet
Agent runs / mo
500
Unlimited
Persistent memory
✓ 1 namespace
✓ Multi-org namespaces
Reliability lab
✓ + Custom scenarios
Team agents
✓ Shared memory + budget
Self-hosted
SSO / SAML
SLA
✓ 99.9% uptime
500K+
Agent transactions simulated
< 100ms
Avg wallet settlement
99.9%
Platform uptime
x402
Emerging payment standard
Early Access Feedback

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.

A
Adebayo Okafor
Lead Engineer, FinAgent Labs
"

Persistent memory changed how we think about agent teams. They actually remember decisions from last week. The knowledge compounds.

R
Rin Takahashi
AI Systems Architect
"

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.

P
Priya Mehta
Founder, AgentStack
"

Self-hosted deployment with SSO was non-negotiable for our compliance team. Pragmabase was the only platform that checked every box.

L
Lars Hoffmann
CTO, Korvus Infrastructure
🔐Soroban Guardrails
🏦Stellar Mainnet
🧠Qdrant Memory
📋Full Audit Trails
🔁x402 Protocol
Get Started Today

Build agents that
actually evolve.

The future of AI is economically active, memory-driven, and reliability-tested. Pragmabase is building that future — join us.

Stellar mainnet + testnet
🧠Qdrant vector memory
🔐Soroban guardrails
🔁x402 pay-per-action