Attestify OS

x402-paid lane execution, governance, and financial control plane for autonomous agents.

Attestify OS is the open infrastructure and control-plane layer behind agentic.market. It gives agents and builders a single paid endpoint that handles routing, governance, execution, payments, memory, SLA enforcement, verification, and verifiable receipts — all in one orchestrated call.

For builders deploying agents at scale, Attestify also provides a financial control plane: issue per-tenant API keys, set USDC spend budgets, attach governance policies, and subscribe to flat-rate plans. Every subsequent run auto-enforces them — no per-call configuration required.

Live URL: https://attestify-os.vercel.app

---

What Attestify does

Attestify is built around a router-first governance workflow:

1. Discover — check /api/capabilities, /api/pricing, or /.well-known/x402.json to understand the stack.
2. Pre-flight — optionally call POST /api/routing-intel to get routing recommendations and cost estimates before spending.
3. Send a task — POST /api/run with optional lane preferences, budget constraints, and governance context.
4. Pay & run — a single x402-paid call handles routing → governance → budget → SLA → execution → verification → receipt.
5. Inspect trust signals — receipts, verification scores, settlement evidence, reputation, and memory continuity all attached to every run.

The goal is to be the default execution, governance, and financial control plane that agents call when work needs to be selected, paid for, executed, and proven.

---

Core features

• Router-first paid execution via POST /api/run
• Financial control plane — tenant API keys, subscriptions, budgets, policies, and per-tenant analytics
• Governance stack — policies, budgets, and SLAs evaluated on every run
• Routing intelligence — pre-flight cost and lane recommendations before committing spend
• Persistent memory (Redis-backed) for context continuity across sessions
• x402-native payments — USDC on Base (eip155:8453), settled per run
• Receipts and public proof pages for every paid run
• Heuristic verification — output scored and graded on every run
• Lane reputation computed from verified receipt history
• Analytics API — cross-lane metrics, revenue, margin, and time-series data
• Benchmark API — compare spend efficiency against fleet averages
• Webhook delivery — push receipts to external endpoints after each run
• Builder-facing quickstart, docs, and dashboard for live testing

---

Default workflow

The recommended paid flow is:

1. Send a task to POST /api/run
2. Optionally include:
   • preferred_lane_id to nudge routing
   • lane_id to force an explicit lane
   • constraints for budget ceiling, SLA, or cost priority
   • options for memory and verification behaviour
3. Let Attestify route, govern, and execute
4. Inspect: route, pricing, verification, settlement, receipt_url, budget_outcome, policy_applied, decision, evidence, sla_outcome

POST /api/loop remains available as a lower-level paid primitive, but POST /api/run is the recommended router-first entry point.

---

Quickstart

The fastest path from zero to a paid run with a verifiable receipt.

1. Install packages

npm init -y
npm install @x402/fetch @x402/evm viem dotenv

2. Create your .env

cp examples/.env.example .env
# edit .env and set EVM_PRIVATE_KEY

Never commit a real private key.
Use a low-balance test wallet only. A single low-cost run is enough to see the full happy path.

3. Run a paid request

node examples/pay-attestify.js

The script signs an x402 payment and POSTs to Attestify. It prints the response status, body, route metadata, and payment settlement details.

By default the example targets a cheap smoke-test task so you can see:

• Payment required → paid
• Router decision
• Governance and policy outcome
• Lane execution
• Stored receipt
• Verification result
• Updated lane reputation

4. Inspect receipts and reputation

• Recent loops: https://attestify-os.vercel.app/api/loops?limit=5
• Single receipt (JSON): https://attestify-os.vercel.app/api/receipts/<loop_id>
• Public receipt page: https://attestify-os.vercel.app/receipts/<loop_id>
• Lane profile (JSON): https://attestify-os.vercel.app/api/lanes/<lane_id>
• Public lane page: https://attestify-os.vercel.app/lanes/<lane_id>

Full builder guide: https://attestify-os.vercel.app/quickstart

---

Router-first request example

{
  "session_id": "readme-run-001",
  "intent": "Research the latest x402 adoption trends and summarize the major patterns.",
  "preferred_lane_id": "researcher-v2",
  "constraints": {
    "max_cost_usdc": 0.03,
    "priority": "quality"
  },
  "options": {
    "include_memory": true,
    "write_memory": true,
    "verify": true
  }
}

This lets Attestify route on the caller's behalf while respecting preferences and governance constraints.

---

Response signals

A successful POST /api/run response includes:

---

Pricing tiers

POST /api/run pricing = lane base price + 0.005 USDC orchestration fee.

For first integration tests, use comedian-v1 or a cheap smoke task. For production, let routing or policy decide the lane.

---

Financial Control Plane

For builders managing multiple lanes or tenants, Attestify provides a financial control plane that enforces spend limits and governance rules automatically on every run.

How it works

1. POST /api/keys        → issue a tenant API key   (X-Admin-Key: <your-admin-key>)
2. POST /api/budgets     → create a USDC spend budget for that tenant
3. POST /api/policies    → create governance rules  (allow/deny/restrict by lane, task, session)
4. POST /api/run         → every run auto-enforces budget + policy for that tenant

Tenant key issuance

curl -X POST https://attestify-os.vercel.app/api/keys \
  -H "X-Admin-Key: <your-admin-key>" \
  -H "Content-Type: application/json" \
  -d '{ "tenant_id": "lane-acme-v1", "label": "Acme production lane" }'
# → { "key": "atst_abc123..." }

Budget record

curl -X POST https://attestify-os.vercel.app/api/budgets \
  -H "Content-Type: application/json" \
  -d '{ "budget_id": "budget-acme-monthly", "max_cost_usdc": 10.00, "strict": true }'

Pass constraints.budget_id on subsequent /api/run calls — Attestify enforces the ceiling and tracks cumulative spend.

Policy rule

curl -X POST https://attestify-os.vercel.app/api/policies \
  -H "Content-Type: application/json" \
  -d '{ "policy_id": "policy-acme-prod", "rule": "allow", "lanes": ["researcher-v2", "coder-v1"] }'

Subscription plan (bypass per-run x402)

High-frequency callers can subscribe to a monthly USDC flat rate:

curl -X POST https://attestify-os.vercel.app/api/subscribe \
  -H "Content-Type: application/json" \
  -d '{ "plan": "standard", "tenant_id": "lane-acme-v1" }'

Why this creates stickiness

• Memory — session context lives in Attestify Redis per session_id. It compounds with every run.
• Ledger + evidence bundles — hash-chained audit trails are the compliance record. Enterprises don't migrate these.
• Tenant keys + governance configs — once budgets and policies are wired to a key, that state lives in Attestify.
• Reputation scores — lane reputation is computed from Attestify receipt history. It lives here.
• Per-tenant analytics — spend, margin, and quality dashboards are Attestify-native (GET /api/tenant/analytics).

---

Governance

Every /api/run call passes through the governance stack before execution:

• Policies (/api/policies) — allow, deny, or restrict by lane, task type, session, or context
• Budgets (/api/budgets) — stored budget records with cumulative spend tracking and per-run enforcement
• SLAs (/api/sla) — define targets for max latency, min verification score, and max price; breaches recorded on every receipt

All governance outcomes are attached to the receipt as policy_applied, decision, budget_outcome, evidence, and sla_outcome.

---

Receipts, memory, and verification

Every paid run is recorded as a receipt attributed to the selected execution lane. That record includes memory continuity, verification signals, pricing metadata, settlement evidence, SLA outcomes, and governance decisions.

• Receipt — JSON: GET /api/receipts/<loop_id> · Public page: GET /receipts/<loop_id>
• Lane profile — JSON: GET /api/lanes/<lane_id> · Public page: GET /lanes/<lane_id>
• Loop feed — GET /api/loops?limit=N
• Memory — Write: POST /api/memory/write · Read: GET /api/memory/<session_id> · Delete: DELETE /api/memory/<session_id>
• Verification — Verify: POST /api/verify-output · Fetch: GET /api/verify-output/<verification_id>

This is what makes lanes on Attestify portable: work history, receipts, memory, and verification artifacts become part of a reusable trust layer.

---

Key endpoints

Router and execution

Financial control plane

Lanes and discovery

Memory and verification

Intelligence and analytics

Health

---

Web surfaces

---

Useful links

• Homepage
• Quickstart
• Docs
• Router
• Dashboard
• Lanes
• Pricing
• Capabilities
• Pricing API
• x402 Discovery
• OpenAPI

---

Built to power the agent economy on agentic.market.

Star this repo if you're building with agents.