Nexus Pay

Nexus Pay enables AI agents to securely automate digital payments with programmable spending limits and blockchain-based settlement.

Comment

NEXUS PAY

Intelligent Payments. Built for Web3.

Nexus Pay is a next-generation programmable Web3 payment experience designed for the emerging agentic economy. It bridges autonomous AI agents and decentralized finance by providing a secure, bounded execution layer for Web3 payments—combining conversational AI interfaces, multi-chain payment instruments, programmable spending allowances, HTTP 402 payment protocol integration, and AWS Bedrock AgentCore payment infrastructure.

THE PROBLEM WE SOLVE

As autonomous AI agents evolve from conversational assistants to economic actors, they face critical bottlenecks:

THE FRICTION POINTS

Fragmented & Manual Web3 Payments

  • Manual wallet confirmations break autonomous execution
  • Seed phrase exposures create security risks
  • Complex network-specific signing workflows slow transactions

Unbounded Agent Risk

  • Unrestricted private key access = catastrophic financial exposure
  • Hallucinating or compromised agents can drain entire treasuries
  • Zero programmatic constraints on spending

OUR SOLUTION

Nexus Pay introduces bounded payment sessions and scoped payment instruments. Users delegate strictly defined spending limits, token budgets, and time-based expiries to AI agents, enabling autonomous pay-per-use commerce while guaranteeing cryptographic control and financial safety.

WHAT WE BUILT

A complete, end-to-end interface and runtime architecture for agent-driven Web3 commerce:

Core Components

Unified Web3 Payment Portal

Responsive single-page application featuring:

  • Embedded wallet management
  • Live balance monitoring across EVM and Solana
  • Spending allowance configuration
  • Transaction history inspection
  • Direct payment simulation

Conversational AI Payment Agent

Autonomous assistant powered by:

  • Anthropic Claude and Amazon Nova via Bedrock AgentCore
  • Merchant catalog browsing
  • Paid digital asset generation
  • Autonomous purchase execution within session limits

x402 Micropayment Protocol

Native HTTP 402 Payment Required header handling:

  • Price negotiation in USDC
  • Signed payment authorization generation (EIP-3009 on EVM, SPL on Solana)
  • Settlement via x402 facilitator
  • Automatic gated resource delivery

Dual-Mode Architecture

  • Local Demo Mode: Immediate evaluation without cloud dependencies
  • Connected AWS Mode: Full serverless and AgentCore infrastructure integration

KEY FEATURES

Feature Description
AI Payment Agent Real-time streaming text & voice interactions with specialized tools (check_balance, list_products, buy_product, generate_image, list_orders, cancel_order)
Web3 Wallets Multi-chain support: Base Sepolia (EVM/EIP-3009) & Solana Devnet (SPL tokens) via Coinbase CDP & Privy embedded credentials
Nexus Allowances Programmable spending caps with maximum USDC limits and time-based session expiries (15-480 minutes)
Payment Dashboard Real-time overview of active instruments, allowance utilization, recent transactions, and quick actions
Interactive Payments Test payment workflows with recipient addressing, amount inputs, and transaction confirmations
Transaction Audit Log Full history with status badges (COMPLETED, PENDING, REFUNDED), network IDs, and order references
x402 Infrastructure Automated HTTP 402 interception & proof injection for pay-per-request APIs (image generation, digital storefronts)
AWS AgentCore Serverless architecture: Bedrock AgentCore Runtime, Cognito auth, API Gateway, DynamoDB, S3, Secrets Manager
Local Demo Mode Instant out-of-box testing with mock wallets, active sessions, and simulated state—no AWS credentials needed

HOW IT WORKS

Nexus Pay operates in two distinct modes: Local Demo Mode (client-side) and Connected AWS Mode (cloud/on-chain).

HIGH-LEVEL PAYMENT LIFECYCLE

1. User defines allowance & payment intent
   ↓
2. UI passes intent + session context to AI Agent
   ↓
3. Agent requests resource from x402-enabled merchant
   ↓
4. Merchant responds: HTTP 402 Payment Required
   ↓
5. Agent sends payment request to AgentCore Payments
   ↓
6. Token Vault validates against session & spending limit
   ↓
7. AgentCore Payments returns signed authorization proof
   ↓
8. Agent retries merchant request with payment proof
   ↓
9. x402 Facilitator verifies payment & coordinates settlement
   ↓
10. Payment settles on Base Sepolia or Solana Devnet
    ↓
11. Merchant delivers asset/service
    ↓
12. Nexus Pay returns result + confirmation to UI

LOCAL DEMO MODE

Client-side, zero-dependency evaluation:

  • Nexus Pay React UI
  • Zustand in-memory state
  • Seeded payment instruments & sessions
  • Simulated payment progression
  • No real funds, no AWS credentials required

CONNECTED AWS MODE

Full production cloud execution:

  • Nexus Pay React UI + Amazon Cognito auth
  • Amazon API Gateway + serverless Lambda
  • Amazon Bedrock AgentCore Runtime
  • Containerized Payment Agent
  • Real x402 Settlement on Base Sepolia / Solana Devnet

SYSTEM ARCHITECTURE

Nexus Pay spans five modular layers: presentation, orchestration, serverless backend, agent runtime, and settlement rails.

ARCHITECTURE LAYERS

[1] Presentation Layer — frontend/

  • Framework: React 19 with Vite, TypeScript, Tailwind CSS, Radix UI, Zustand
  • Features: Authentication, wallet management, allowances, AI interaction, transactions, analytics

[2] Serverless Cloud Layer — backend/

  • Infrastructure: AWS CDK provisions Cognito, API Gateway, DynamoDB, S3, Secrets Manager
  • Runtime: Python Lambda
  • Workflows: User, administration, and seller workflows

[3] Agent Runtime Layer — payment-agent/

  • Stack: Containerized Python service (FastAPI + Strands Agents)
  • Hosting: Amazon Bedrock AgentCore Runtime
  • Capabilities: Conversational interactions, payment tools, x402-gated transactions

[4] Settlement & Web3 Layer

  • AgentCore Payments: Authorization & signing
  • x402 Facilitator: Verification & settlement
  • Networks: Base Sepolia & Solana Devnet

END-TO-END FLOW

React Frontend 
    ↓
API Gateway / AgentCore Runtime 
    ↓
Lambda & Payment Agent 
    ↓
AgentCore Payments 
    ↓
x402 Facilitator 
    ↓
Base Sepolia / Solana Devnet

SUPPORTING INFRASTRUCTURE

  • Amazon Cognito — Authentication & RBAC (admin/user)
  • Amazon DynamoDB — Orders, catalog, seller configs
  • Amazon S3 — Media & digital assets
  • AWS Secrets Manager — Credential protection
  • AgentCore Payments — Authorization & signing
  • x402 Facilitator — Verification & settlement

SECURITY & TRUST MODEL

Defense-in-depth architecture ensuring safe autonomous agent operations:

① BOUNDED EXECUTION

Agent can only spend within explicit currency, maximum spend cap, and time expiration of active PaymentSession

② KEY VAULT ISOLATION

Private keys remain in secure credential vaults (AWS Secrets Manager / Coinbase CDP / Privy). Neither browser nor LLM touches raw keys.

③ ROLE-BASED ACCESS CONTROL

Cognito enforces strict separation between admin (/admin/*) and user (/user/*) workflows

④ IDEMPOTENT VERIFICATION

Merchant orders & refunds require strict verify-before-fulfill & nonce checks to prevent replays and double-spending

⑤ CLEAR DEMO SEPARATION

Local mode runs on mock client state only—zero accidental calls to live payment rails without explicit configuration

TECH STACK

Frontend Application

Core

  • React 19
  • TypeScript
  • Vite

UI

  • Tailwind CSS
  • Radix Primitives
  • Lucide Icons
  • Recharts

State

  • Zustand with local persistence

Web3

  • @privy-io/react-auth
  • amazon-cognito-identity-js

Payment Agent

Runtime

  • Python 3.11+
  • FastAPI
  • Uvicorn

Orchestration

  • Strands Agents

Models

  • Claude 3.5 Sonnet
  • Amazon Nova Sonic
  • Amazon Nova Canvas

Protocol

  • AgentCorePaymentsPlugin
  • httpx

Cloud & Backend

Infrastructure as Code

  • AWS CDK v2 (TypeScript)

Compute

  • AWS Lambda (Python 3.11)

Databases

  • Amazon DynamoDB
  • Amazon S3

Security

  • Amazon Cognito
  • AWS Secrets Manager
  • IAM

Web3 & Settlement

Networks

  • Base Sepolia (EVM testnet)
  • Solana Devnet

Currency

  • Testnet USDC

Protocol

  • x402 open payment standard

Signatures

  • EIP-3009 (ReceiveWithAuthorization)
  • SPL Token Transfer

INNOVATION SECTION

Breakthrough Innovations in Nexus Pay

Nexus Pay introduces several groundbreaking innovations that address fundamental challenges in agentic finance and autonomous payments:

1. Bounded Payment Sessions for Autonomous Agents

Innovation: First-class payment sessions with cryptographically enforced spending limits, time expiries, and currency scoping.

Impact: Solves the "unbounded agent risk" problem by enabling users to safely grant payment authority without risking complete fund drainage. Unlike traditional authorization systems, Nexus Pay sessions are:

  • Cryptographically bound to specific tokens and time windows
  • Non-delegatable — agents cannot grant authority to other entities
  • Verifiable on-chain for audit and compliance

Technical Achievement: Implemented a novel session-based payment authorization layer that sits between the UI and blockchain settlement, providing application-level constraints that complement on-chain protections.

2. Conversational Agent-Driven Web3 Commerce

Innovation: First integration of LLM-based conversational agents with bounded Web3 payments using Anthropic Claude and Amazon Nova via Bedrock AgentCore.

Key Features:

  • Real-time voice and text streaming with agents that have direct payment execution capabilities
  • Specialized payment-aware tools (check_balance, list_products, buy_product, generate_image)
  • Stateful multi-turn conversations where agents autonomously negotiate, authorize, and settle payments
  • Built-in safety guardrails preventing agents from exceeding session limits

Impact: Enables natural language commerce workflows where users simply converse with an agent to purchase goods, services, and digital assets—no manual wallet confirmations or complex signing workflows.

3. HTTP 402 Payment Protocol Implementation

Innovation: Native integration of the HTTP 402 "Payment Required" standard for machine-payable APIs—the first production implementation combining 402 with LLM agents and bounded sessions.

Technical Approach:

  • Automatic interception of HTTP 402 responses from x402-enabled merchants
  • Transparent payment proof injection (EIP-3009 on Base, SPL on Solana)
  • Merchant-agnostic settlement through x402 facilitators
  • Zero additional UX friction—payments happen transparently during conversational flows

Impact: Unlocks true pay-per-request commerce for:

  • AI image generation APIs
  • Digital asset storefronts
  • Micropayment-gated data services
  • On-demand computation markets

4. Dual-Mode Architecture (Local + Connected)

Innovation: Hybrid runtime architecture enabling zero-dependency local evaluation with seamless migration to production cloud infrastructure.

Architecture:

  • Local Demo Mode: Zustand-based in-memory state, mock wallets, and simulated payments—runs instantly in browser
  • Connected AWS Mode: Full AWS CDK infrastructure with Cognito, Lambda, DynamoDB, and real blockchain settlement
  • Same UI/UX in both modes — no code changes required to switch between demo and production

Impact:

  • Dramatically accelerates evaluation and onboarding (no AWS setup for initial exploration)
  • Reduces dependency risk during development
  • Enables true separation of concerns between presentation and backend
  • Facilitates testing and user research in isolated environments

5. Multi-Chain Payment Instruments

Innovation: First unified payment interface supporting heterogeneous blockchain networks (EVM + Solana) with automatic network detection and cross-network settlement coordination.

Technical Innovation:

  • Abstract payment instrument layer supporting different blockchain APIs (Coinbase CDP for EVM, Privy for Solana)
  • Automatic network-specific signature generation (EIP-3009 vs SPL Transfer)
  • Unified session validation across networks
  • Single ledger view across Base Sepolia and Solana Devnet

Impact: Enables agents to dynamically choose settlement networks based on:

  • Liquidity availability
  • Transaction costs
  • Settlement speed
  • User preferences

6. Key Vault Isolation for Agent-Controlled Funds

Innovation: Novel architecture ensuring private keys never touch the LLM or browser, even when agents execute autonomous payments.

Security Design:

  • Private keys stored exclusively in AWS Secrets Manager / Coinbase CDP / Privy
  • Agent-generated payment requests validated by AWS Lambda before key access
  • Cryptographic proofs (signatures) returned to agent without exposing keys
  • Deterministic nonce generation preventing replay attacks

Impact: Eliminates the fundamental security contradiction in autonomous agent payments: agents can transact autonomously while users maintain complete key custody.

7. Programmable Spending Allowances

Innovation: First implementation of time-scoped, amount-capped, token-specific allowances that agents can operate within transparently.

Features:

  • Configurable maximum USDC limits per session
  • Time-based expiries (15-480 minute windows)
  • Real-time utilization tracking on dashboard
  • Automatic refusal of payments exceeding limits (application-level, verified by backend)

Impact: Enables users to grant targeted payment authority with predictable, bounded risk—fundamental for mainstream adoption of agentic payments.

8. Real-Time Audit Logging for Financial Compliance

Innovation: Comprehensive transaction audit trail with full Web3 settlement tracking and agent decision logging.

Features:

  • Complete transaction history with status badges (COMPLETED, PENDING, REFUNDED)
  • Network and order references for cross-chain verification
  • Agent interaction logs (what was requested, what was approved, why)
  • Settlement proof integration (blockchain transaction IDs, signatures)

Impact: Enables:

  • Regulatory compliance and fraud investigation
  • Agent behavior transparency for users
  • On-chain verification of payment claims
  • Dispute resolution with cryptographic evidence

9. Containerized AI Payment Agent with Strands Agents

Innovation: Production-grade containerized FastAPI service hosting payment-aware LLM agents with tool calling, state management, and payment orchestration.

Architecture:

  • Strands Agents framework for reliable tool calling and recovery
  • WebSocket support for real-time streaming interactions
  • Stateful payment context maintained across conversation turns
  • Automatic tool error handling and user notification

Impact:

  • Enables scalable, multi-user agent hosting
  • Supports voice and text modalities simultaneously
  • Handles edge cases (failed payments, merchant errors) gracefully
  • Integrates seamlessly with AWS Bedrock infrastructure

10. x402 Facilitator Protocol Integration

Innovation: Custom implementation of merchant-neutral, decentralized x402 facilitator for payment verification and settlement coordination.

How It Works:

  • Merchants list payment requirements (price, required networks)
  • Agents request facilitator to verify payments against merchant criteria
  • Facilitator confirms on-chain settlement before releasing access
  • Supports atomic payment-for-resource delivery

Impact: Enables a permissionless marketplace of x402-compatible merchants without central trust or intermediaries.

Cumulative Innovation: Agentic Finance as a Platform

The combination of these innovations creates a new category—agentic finance infrastructure—that addresses the core contradiction in autonomous agent economies:

Problem: Users want autonomous agents (for efficiency) but cannot trust them with unrestricted fund access (for safety).

Nexus Pay's Solution:

  1. Agents operate autonomously within cryptographically bounded sessions
  2. Users maintain control through programmable allowances and key isolation
  3. Payments settle transparently via HTTP 402 protocol and blockchain settlement
  4. Everything is auditable through comprehensive logging and settlement verification

This represents a fundamental shift in how financial authority is delegated to non-human actors, applicable beyond Web3 to traditional finance, SaaS automation, and supply chain commerce.

DOCUMENTATION

Comprehensive technical deep-dives into each subsystem:

Document Focus Area Description
Architecture System Design High-level overview, frontend/backend separation, deployment boundaries
System Design Technical Design Multi-tier design, state management, connection handling
Agent Flow Orchestration WebSocket protocol, tool definitions, context updates, voice streaming
Payment Flow Mechanics x402 payment loop, session bounding, settlement details
Data Schema Data Contracts Credential Providers, Payment Managers, Instruments, Sessions
API Reference Catalog Admin, User, Storefront, Seller endpoints (REST & WebSocket)

CURRENT STATUS

✓ Local Demo Mode

  • Status: Fully functional & interactive
  • Launch Vite application, sign in with demo credentials
  • Explore all dashboard metrics, create allowances, simulate payments
  • Inspect complete UI/UX without AWS setup

✓ Connected Cloud Capabilities

  • Status: Production-ready in repository
  • CDK infrastructure, Lambda handlers, FastAPI services, x402 settlement logic
  • Ready to deploy to AWS with Coinbase CDP / Privy credentials

ROADMAP

Completed ✓

  • Responsive Web3 Payment Dashboard & Allowances Manager (React 19)
  • Multi-chain payment instruments (Base Sepolia & Solana Devnet)
  • Containerized AI Payment Agent with Strands Agents & x402 interception
  • AWS CDK serverless backend & Cognito authentication
  • Local Demo Mode with mock state for instant evaluation

Planned ○

  • Multi-token support beyond USDC (native ETH, SOL, ERC-20)
  • Decentralized session policy registry via smart contract hooks
  • Subscriptions & automated allowance refills for long-running agents

TEAM

Built with ❤️ by Team Titans

EXPLORE NEXUS PAY

Experience the Platform

KEY INSIGHT

Autonomy without giving up control.

Nexus Pay demonstrates a production-oriented blueprint for agentic Web3 payments. By enforcing explicit spending allowances and payment boundaries, we enable autonomous agents to execute payment actions while keeping users in complete control of how, when, and how much an agent can spend.

Built With

agentcore · agents · amazon · amazon-web-services · anthropic · base · bedrock · claude · css · fastapi · nova · python · react · solana · strands · tailwind · typescript · usdc · vite · web3 · x402 · zustand

© 2026 Team Titans · Nexus Pay

Autonomy without giving up control.

Built With

Share this project:

Updates