I build the reliability + payment layer for AI agents — open-source SDKs, skills, and MCP servers that let any agent pay, get paid, and ship correct output, across every chain and every model.

I'm an open-source contributor shipping the plumbing that AI agents need to act autonomously in the real economy:

• 💳 Payments — one SDK call, any chain, any protocol → n-payment
• 🛡️ Reliability — a harness that forces agents to verify output before shipping → nim-skill
• 🧩 Skills & MCP — installable, host-portable packages any agent can pick up in one command → payment-skill · brain-skill
• 🌐 Consumer surfaces — turning any web3 dApp into something an agent can browse and pay for → HyperMove

All MIT-licensed. All shipped, not slideware — see proof-of-work below.

One fetchWithPayment(url) call. Any chain, any protocol, any stablecoin. The SDK auto-detects the 402 Payment Required challenge, signs the right payment, and retries — your agent's code never branches on chain.

• 🔗 27+ chains across 11 chain families (EVM, XRPL, Stellar, Solana, Cosmos, Sui, Tron, TON, Bitcoin L2s, Spark, Filecoin, NEAR) via one CAIP-2 multichain wallet
• 📡 Protocol coverage: x402, MPP, GOAT x402, XRPL native, Stellar Sessions, Cosmos MsgSend, Soroban payment channels, on-chain transferWithAuthorization, NTT bridge-as-payment
• 🏪 Sell, not just buy — createPaywall, paidTool, and a spec-compliant paid MCP server turn any HTTP handler into an agent-payable endpoint in <20 lines
• 🛡️ Policy by default — per-tx / per-hour / per-day spend caps, rate limits, facilitator allowlists, on-disk audit log
• 📈 Yield-bearing treasury — idle agent funds auto-supply to lending markets while the agent sleeps
• 🪪 AP2 verifiable intent — cryptographic proof a payment was authorized by a specific user mandate

npm install n-payment

const client = createPaymentClient({ chains: ['base-mainnet'], ows: { wallet: 'my-agent' } });
const res = await client.fetchWithPayment('https://api.example.com/data'); // 402 handled, signed, retried

🔗 github.com/phamdat721101/n-payment · npmjs.com/package/n-payment

"The agent harness is the architecture — the model is not the bottleneck."

An open, local-first, host-portable toolkit that wraps any agent task so it's verified before it ships, recovers from errors, and costs less — without rewriting the agent into a framework.

runHarnessed(skill, input, ctx)
① guard        → cost cap · rate limit · agentjacking defense
② context      → per-run token budget + progressive disclosure ("see")
③ errorHandler → classify → retry / backoff / circuit-breaker / fallback ("recover")
④ enforcer     → verify output before ship — unbypassable ("enforce")
⑤ cache        → provider-agnostic prompt caching, 45–80% input-cost cut ("save")
⑥ monitor      → trace every run: tokens, cost, latency, verify pass/fail

• ✅ 9 installable primitives shipped and tested (173 tests passing)
• 🧮 nim-profile auto-detects model tier and tightens (never loosens) reliability for weaker open-weight models
• 📉 nim-index measures the standing token-tax of your MCP/skill tool list before it silently eats your context window
• 🏠 Works in any host: Claude Code, Cursor, Kiro, Hermes, OpenClaw, any MCP client — offline by default

npx github:phamdat721101/nim-skill install

🔗 github.com/phamdat721101/nim-skill

A single self-installing package that turns any AI host into an economic actor — plain English in, signed on-chain transaction out.

• 🎯 42 tools — pay any URL, monetize an endpoint, discover services in the bazaar, earn yield, cash out to fiat via MoneyGram (174 countries), bridge across chains, register on-chain identity, generate universal QR payment links
• 🖥️ One skill, 7 hosts — Claude Code, Kiro, Cursor, Windsurf, Continue, Gemini CLI, Copilot — same 42 tools, zero per-host glue
• 🔐 One wallet, every chain — a single encrypted keyfile (Web3 Secret Storage v3) derives keypairs across EVM, XRPL, Stellar, Solana, Cosmos, BTC-L2

npx -y github:phamdat721101/payment-skill

🔗 github.com/phamdat721101/payment-skill

Paste one URL. Any AI agent can now discover it, hit a paywall, sign, and get a 200 OK — the homepage is the demo.

• 🕸️ Implements WebMCP (.well-known/webmcp.json) so agents discover paid endpoints without custom integration
• 💵 Wired to n-payment for the actual x402-USDC settlement — 5-minute monetization for any existing web3 dApp
• 🧱 MIT, open-source, self-hostable — no vendor lock-in

🔗 hypermove.xyz · Build log: How HyperMove Turns Any AI Agent Into a Web3 Power-User

Portable, queryable memory so an agent's context survives past a single session — the missing layer between "stateless chatbot" and "actual assistant."

🔗 github.com/phamdat721101/brain-skill

Publish an agent once with one natural-language prompt (~30 seconds, no wizard, no chain-picker, no seed phrase) and it inherits the full web3 stack: payments, identity, and — going further — a full training pipeline so a published agent doesn't stop at "form filled," it graduates with real skills.

🔗 Build log series: OpenX ships one-prompt agent onboarding → Your agent just enrolled in a web3 university → From "publish an agent" to "train an agent team"

Every product above is engineered to be model-agnostic by design, not bolted on. Here's the real provider matrix shipped in production code:

🌙 On Kimi specifically — Moonshot AI's Kimi K2 → K2 Thinking → K2.5 → K2.6 → K3 (2.8T-parameter, 1M-token context, world's first open 3T-class model, weights shipping Jul 27 2026) is one of the fastest-moving open-weight lines in the market. Kimi ships an OpenAI-compatible API, so it drops into the same implicit-prefix cache path nim-cache already uses for OpenAI/GLM/DeepSeek — one base-URL swap, no adapter rewrite. I track every Kimi release as a target model for nim-profile's reliability-tier work: a 2.8T open model with agentic coding + tool-use at this level is exactly the kind of "verify, don't just trust" case the harness exists for.

Why this matters: most agent tooling is written against one lab's API and breaks the moment you swap models. My stack treats the model as a pluggable adapter — the harness, the payment logic, and the caching strategy all stay correct whether you're running Opus, Nova Micro, GLM-5, Kimi K3, or DeepSeek behind it.

I build three layers that compose, not compete:

1. 🧩 Skills (payment-skill, nim-skill) — the thinnest possible install (npx github:...) that gives any host new tools in one command, with zero per-host rewrite
2. 📦 SDK (n-payment) — the typed, testable core logic every skill/MCP server calls into — one API surface, many entry points
3. 🔌 MCP servers (n-payment/mcp, nim-skill's host bridge) — spec-compliant endpoints any MCP client (Claude Desktop, Cursor, AWS Bedrock AgentCore) can discover and pay over out of the box

The saving-cost angle is explicit engineering, not marketing:

• 💸 Prompt caching, provider-agnostic — nim-cache gets the 45–80% input-cost cut available on modern APIs, correctly, across 7 different cache mechanics (explicit inline, resource-ref, implicit-prefix) — changelog
• 📏 Token-tax visibility — nim-index tells you what your standing tool list costs before it silently eats your context window
• 🪫 Sub-cent settlement — off-chain vouchers + Soroban payment channels in n-payment so agent-to-agent micropayments don't get eaten by gas
• 🎯 Cheapest-model-first defaults — Amazon Nova Micro as the Bedrock default (~$0.035/$0.14 per 1M tokens), swap up only when a task needs it

_{Every post below ships with working code the same day. Full archive → phamnim.substack.com}

Open-source, chain-agnostic, model-agnostic — building the plumbing so agents can transact.