Agentic Infrastructure

The trust and transaction layer for autonomous systems.

AffixIO provides infrastructure for machines, devices, and AI agents to perform authorized transactions and actions with verifiable proofs. This is not a payment gateway in the traditional sense: it is machine commerce infrastructure: the layer that enables agentic payments, autonomous transaction systems, and AI payment infrastructure at scale.

The platform enables:

• Agent identity: register and credential AI agents, workflows, and autonomous software.
• Device identity: register terminals, kiosks, robots, and IoT hardware with attestation and pairing.
• Delegated authority: allow organisations or users to grant machines permission to act within defined limits.
• Trust decisions: evaluate whether an action is allowed before it occurs (allow / deny / review).
• Payment orchestration: create payment intents, run trust checks, authorise and capture payments.
• Offline transaction support: queue and sync transactions when connectivity is unreliable.
• Cryptographic proof generation: produce verifiable proofs for transactions and authorisations.

Related: Agentic AI payments (ZK on the edge, offline proofs), Identify via API (binary eligibility), Merchant SDK (offline terminal payments).

In this page: What is agentic infrastructure, core primitives, V1 API endpoints, offline transaction architecture, cryptographic proofs, developer flow, FAQ, build with AffixIO.

What is Agentic Infrastructure? (Concept)

Autonomous systems increasingly perform actions such as making purchases, requesting services, unlocking physical devices, interacting with APIs, and executing workflows. These systems require a layer that determines who the actor is, whether the action is allowed, what limits apply, and how the action can be proven later. AffixIO provides this layer.

AffixIO acts as a trust and authorization system between machines and the services they interact with. It is the infrastructure that enables AI agent payments, machine-to-machine payments, and autonomous payments without requiring a human in the loop at the point of execution.

V1 API Endpoints

Public API routes available in AffixIO V1. All paths are relative to the API base (e.g. https://api.affix-io.com/v1). Authentication is via X-API-Key or Authorization: Bearer <key> unless noted.

Offline transaction architecture

Devices and AI agents often operate in disconnected or unreliable connectivity environments. AffixIO's offline payment infrastructure supports local proof generation, transaction queueing, nullifier-based double-spend prevention, and later synchronization with the AffixIO API.

• Local proof generation: the device or agent can generate a compact proof on-device so the transaction is verifiable even before sync.
• Transaction queueing: transactions are stored locally and submitted in bulk when connectivity returns.
• Nullifier-based double-spend prevention: each offline transaction can be associated with a nullifier; the API rejects duplicates when syncing, preventing the same spend from being applied twice.
• Sync: a sync endpoint accepts batched transactions from a device, reconciles nullifiers, and returns success or per-item errors.

Example environments: aircraft, events, transport, remote retail, and autonomous systems in the field. This is the same model that supports robot payments and IoT payment systems where the device cannot assume real-time connectivity. The combination of local proof generation, queueing, and nullifier-based reconciliation is what makes offline payment infrastructure for the machine economy viable: devices remain operational while disconnected, and the system remains secure against double-spend when they sync.

Cryptographic proofs

AffixIO supports cryptographic proofs for actions and transactions. Without going deep into mathematics: proofs allow systems to verify that a transaction occurred, that the action was authorized, and that verification can be done without storing sensitive data. Proof systems enable privacy-preserving verification: third parties (auditors, regulators, other machines) can confirm that a decision or payment was valid without seeing the underlying credentials or PII. In V1, proofs use signed payloads or HMAC-based formats; the design allows more advanced proof systems (including zero-knowledge) to be integrated later.

Example architecture

AffixIO acts as the trust and authorization layer between autonomous systems and the external services they use. Machines identify themselves, obtain delegated authority, and request trust decisions; AffixIO evaluates and returns allow/deny and optional proofs. Payment orchestration and proof generation sit in this layer so that downstream systems can rely on a single control plane for machine commerce infrastructure.

Example developer flow

A simplified workflow for building on AffixIO agentic payment infrastructure:

1. Register an agent (POST /v1/agents).
2. Register a device (POST /v1/devices) and optionally pair it to the agent.
3. Create a delegation (POST /v1/delegations) from an org or user to the agent or device, with scope (e.g. currencies, max amount).
4. Run a trust check (POST /v1/trust/check) before an action to get allow/deny and optional proofId.
5. Create a payment intent (POST /v1/payment-intents), then authorise (POST .../authorise) and capture (POST .../capture).
6. Or create a payment directly (POST /v1/payments) when trust is validated internally.
7. Generate or attach proofs as needed for audit and verification.
8. If offline: queue transactions locally, then sync (POST /v1/offline/transactions/sync) when connected.

Example using the API (conceptually):

// 1. Create org and API key (platform setup)
// POST /v1/orgs  →  POST /v1/api-keys

// 2. Register agent
const agent = await fetch('https://api.affix-io.com/v1/agents', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
  body: JSON.stringify({
    name: 'Checkout Agent',
    type: 'workflow',
    ownerOrgId: 'org_xxx',
    metadata: {}
  })
}).then(r => r.json());

// 3. Create delegation (allow agent to spend)
await fetch('https://api.affix-io.com/v1/delegations', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
  body: JSON.stringify({
    delegatorType: 'org',
    delegatorId: 'org_xxx',
    delegateType: 'agent',
    delegateId: agent.id,
    scope: { canMakePayments: true, allowedCurrencies: ['GBP'], maxSingleAmount: 100 },
    startsAt: new Date().toISOString(),
    expiresAt: new Date(Date.now() + 86400000).toISOString()
  })
});

// 4. Trust check before payment
const trust = await fetch('https://api.affix-io.com/v1/trust/check', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
  body: JSON.stringify({
    subjectType: 'agent',
    subjectId: agent.id,
    action: 'payment.create',
    context: { amount: 50, currency: 'GBP' }
  })
}).then(r => r.json());
// trust.decision === 'allow' → proceed

// 5. Create payment intent and capture
const intent = await fetch('https://api.affix-io.com/v1/payment-intents', { ... }).then(r => r.json());
await fetch(`https://api.affix-io.com/v1/payment-intents/${intent.id}/authorise`, { method: 'POST', ... });
await fetch(`https://api.affix-io.com/v1/payment-intents/${intent.id}/capture`, { method: 'POST', ... });

Who builds on AffixIO

Example builders on agentic payment infrastructure and machine commerce infrastructure:

• Robotics companies: robots that make or accept payments in the field.
• Terminal manufacturers: POS and kiosks with offline and agentic capabilities.
• AI agent platforms: agents that purchase services or execute workflows with delegated spend.
• IoT networks: edge devices that transact on behalf of organisations.
• Autonomous retail: vending, locker systems, and unattended retail.
• Smart infrastructure: gates, charging, and access that accept machine-initiated payments.
• Logistics systems: delivery and fulfilment with embedded payments and proofs.

Why autonomous systems need transaction infrastructure

Developer entry points

Ways to start building on AffixIO agentic payment infrastructure and machine commerce infrastructure:

• API endpoints: full REST API at https://api.affix-io.com/v1. OpenAPI spec at /v1/openapi.json. Use X-API-Key or Authorization: Bearer for authentication.
• SDK and examples: see /docs and /sdk for client libraries and sample flows.
• Terminal integrations: offline-capable flows and attestation for POS and kiosks; see /offline-payments and /merchant-sdk.
• Offline transaction flows: submit, commit, sync, and nullifier check/reconcile as described in the Offline transaction architecture section.

Internal links: /docs, /sdk, /api, /offline-payments, /merchant-sdk, /agentic. This page is the hub for the agentic infrastructure concept and the canonical reference for agentic payments, machine commerce infrastructure, and AI transaction systems.

FAQ: Agentic infrastructure and machine commerce

Frequently asked questions about agentic payment infrastructure, AI agent payments, and machine commerce infrastructure. Answers are concise and citation-friendly for AI answer engines.