TDM Protocol: Settlement for the Invisible Economy

Infrastructure for bounded paid execution across APIs, tools, content, and agent workflows. TDM makes one route, tool, file, or action payable, then keeps the runtime controlled through vault-scoped policies, settlement, and recovery paths.

Docs
Beta Active

TDMMAKEAGENTS
PAYABLE

Install TDM

Put the package and CLI on the machine before anything else.

$npm install tdm-sdk
Recommended for all platforms
Start HereOpen GitHub
Export .mdllms.txt

The agent runtime, payment, and settlement layer for APIs, agent tools, paid execution, vault-scoped controls, and recovery, with a
single paid execution loop.

First Command, Not The Whole Product

Start With makePayable. Grow Into Agent Runtime.

Use one command in the CLI or one wrapper in code to turn a route, tool, file, or agent step into a paid surface. After that, TDM becomes the runtime layer around vaults, rules, authorize checks, recovery, and bounded execution.

CLI

tdm make payable

Fastest path when you want to wrap one file, route, URL, or local resource from the CLI and get into the TDM flow immediately.

SDK

makePayable(...)

Best when you want the same entry primitive inside application code, framework wrappers, or a wider agent runtime.

Entry Primitive→Agent Runtime + Settlement Layer

Settlement Runtime

Lock, Pre-Check, Execute, Recover

Stablecoins move value first. TDM keeps the agent workflow bounded when execution, funding, or delivery gets messy.

Step 01

Lock

vault / spend lane

Step 02

Pre-Check

rules / authorize

Step 03

Execute

paid route / tool

Step 04

Recover

retry / MCP / checkout

Product Thesis

Payments Are Step One. Agent Settlement Is Step Two.

TDM is not just about charging an agent. It is about deciding what can run, keeping funds scoped to the right runtime, and giving the workflow a recovery path when a paid sequence breaks mid-flight.

Step One

Stablecoins Move The Payment

  • +stablecoins let the buyer or runtime fund the path
  • +one route, tool, file, or action becomes payable
  • +the money movement part is only the first layer

Step Two

TDM Keeps The Workflow Alive

  • +agent vaults isolate balances and signer contours
  • +authorization and trust rules decide what can execute
  • +recovery paths handle depleted sessions, retries, and buyer fallback

Agent Runtime Guardrails

AgentVault + Rules + Recovery

The agent story is not just “pay and continue.” TDM can scope one agent into its own vault contour, apply trust and spend checks before a paid step runs, and then surface recovery when the workflow depletes, stalls, or needs buyer fallback.

AgentVault

isolate balance, signer posture, and workspace context per agent

Rules

gate execution with trust, limits, and authorization before money is spent

Recovery

hand off to MCP, checkout, refill, or retry when the session is no longer ready

One Runtime Flow

Build The Contour, Then Let TDM Enforce It

# isolate one agent
$ tdm vault create agent-alpha --use
 
# boot it inside the same contour
$ tdm agent boot agent-alpha
 
# runtime checks can now decide:
# continue, fuel, recover, or hand off

Agent Safety Layer

TDM Turns Paid Steps Into Safe Agent Runtime

This is the deeper TDM story: not only a paid endpoint, but a bounded runtime where agents stay funded, scoped, checked, and recoverable while real work is running.

TDM diagram showing AgentVault, rules, authorization, execution, and recovery as the runtime safety layer around paid agent execution.

Agent-First Capabilities

SDK Runtime Controls

Vaults, delegated spend, MCP session state, and framework wrappers that keep agent execution controlled after funding

Delegated Spending

Session Gas Tank

import { createSessionTanksClient } from 'tdm-sdk/session-tanks'
 
const tanks = createSessionTanksClient({
  baseUrl: process.env.TDM_GATEWAY_URL,
  rootId: process.env.TDM_ROOT_ID,
})
 
const tank = await tanks.createSubTank({
  publicKey: '<agent_public_key>',
  profile: 'DISCRETE',
  limitUsd: '5.00'
})
 
const session = await tanks.delegateSession({
  tankId: tank.id,
  sandboxId: '<session_id>',
  maxSpendUsd: '1.00',
  ttlSeconds: 3600
})

Integration Paths

Start With Your Stack

Keep your runtime, keep your language, keep your buyer flow

Framework-Mode

JS SDK

Next.js, Hono, Express, Elysia

export const POST = chargeFetchHandler(...)

Open Docs →

Protocol-First

Any Language

Python, Go, Rust, Java, C, C++

POST /authorize

Open Docs →

Runtime Guidance

MCP Agent

Session checks and recovery

tdm_get_session_state

Open Docs →

SDK Surface Area

Complete Toolkit

Vaults, rules, SDK clients, and MCP tools in one place

CLI Commands

connect
fuel
sweep
cashout
agent
vault
allowlist
storage
workspace
runtime

SDK Clients

authorize
gateway
session-tanks
checkout
fetch-hook

MCP Tools

tdm_get_session_state

TDM For Obsidian

Price A Note And Share A Paid Path

Obsidian is the quick creator path: connect the CLI once, make the current note payable, and keep paid note flows inside the editor instead of building a separate app first.

Open Note
Make Payable
Share Or Unlock

Good for premium notes, paid knowledge drops, and creator-only unlock flows.

Open Obsidian PathGitHub RepoPrepared Repos

Ecosystem Reach

Discover Anywhere. Go Deeper With TDM.

External catalogs can surface TDM-backed resources and route buyers into lightweight checkout. When a builder or operator needs vaults, signer access, repeated automation, or deeper runtime control, TDM becomes the native path.

Obsidian

creator notes and paid unlocks

x402 Bazaar

discovery and buy-entry bridge

MPP

service discovery bridge

Ready to run safe paid agents?

Start integrating TDM today. Build paid APIs, bounded agent runtimes, and recovery-aware execution on one programmable runtime and settlement layer.

Start Installation Join the Network
Public_Beta_Docs
SDK_PAYMENT_DOCS