For engineers

The exchange layer for recruiting agents.

ADNX sits between generic agent protocols and your application. Open standards for talent and jobs, bilateral constraint matching, audit trails, signed delivery. The delivery network ships in an afternoon.

Your application

ATS, Job Board, Talent App, Agent

Your product. Needs to discover candidates or jobs, match them, and stay compliant.

Your codeYour usersYour business logic

integrate once ↓

Domain protocol + clearance

adnx — the recruiting rail

Standardized schemas (OTP/OJP), bilateral constraint matching, immutable audit trails, signed webhook delivery.

OTPOJPClearance engineCompliance vaultWebhooks

runs on top of ↓

Agent transport

A2A, MCP, HTTP — generic protocols

How agents discover and talk. Domain-agnostic plumbing.

Google A2AMCPHTTP / gRPC

tl;dr

A2A defines how agents talk. ADNX defines what they say in recruiting — talent profiles, jobs, constraints — and how matches get cleared, logged, and settled. One shared delivery network, no bespoke integrations.

Integration

Push data in. Get webhooks back.

The exchange is an asynchronous state machine behind a schema-driven API gateway. You push structured data. Signed webhooks come back when matches are struck.

Push a supply node (candidate agent)typescript

import { ADNX } from '@adnx/sdk'

const adnx = new ADNX({ apiKey: process.env.ADNX_KEY })

const node = await adnx.supply.push({
  schema: 'otp',
  profile: {
    title: 'Senior Product Designer',
    skills: ['Figma', 'Design Systems', 'User Research'],
    experience: 6,
    location: 'Amsterdam, NL',
    remote: true,
    salary: { min: 75000, max: 95000, currency: 'EUR' }
  }
})
// → node.id = "sn_8f2a..."  status = "active"

Push a demand node (employer agent)typescript

const job = await adnx.demand.push({
  schema: 'ojp',
  posting: {
    title: 'Lead Product Designer',
    required: ['Figma', 'Design Systems'],
    preferred: ['User Research', 'Prototyping'],
    experience: { min: 5 },
    location: 'Amsterdam, NL',
    remote: true,
    compensation: { min: 80000, max: 105000, currency: 'EUR' }
  }
})
// → job.id = "dn_3c7b..."  status = "matching"

Receive a match webhookjson

{
  "event": "negotiation.matched",
  "negotiation_id": "nx_7f3a9b2e",
  "score": 0.91,
  "supply_node": "sn_8f2a...",
  "demand_node": "dn_3c7b...",
  "cleared": {
    "salary": 87000,
    "remote": true,
    "start_date": "2026-06-01"
  },
  "signature": "sha256=9f2c8b..."
}

Negotiation lifecycle

Four states. Fully deterministic.

Every negotiation moves through a fixed state machine. No LLM inference, no hallucination. Constraint overlap is calculated mathematically.

Ingest

Schema validation, edge checks

Negotiate

Constraint matching, scoring

Clear

Overlap resolved, terms agreed

Deliver

Signed webhooks to both sides

API surface

REST. Schema-driven. Predictable.

Strict OpenAPI schemas on every endpoint. Built-in idempotency. Deterministic sandbox for testing.

Method	Endpoint	Description
POST	/v1/supply	Push a supply node (candidate agent)
POST	/v1/demand	Push a demand node (employer agent)
GET	/v1/negotiations/:id	Check negotiation status + audit trail
GET	/v1/matches	List matches with filters
POST	/v1/webhooks	Register webhook endpoints
GET	/v1/compliance/:id	Fetch audit log for a negotiation

Bearer token auth

API key per environment. Sandbox and production keys are separate.

HMAC verification

Every webhook is signed with SHA-256. Verify before processing.

Idempotent by design

Safe to retry any request. Duplicate pushes are de-duped by content hash.

Rate limits

Sandbox: 100 req/min. Growth: 1,000 req/min. Enterprise: custom.

Compliance vault

Every negotiation is logged with an immutable audit trail. 7-year retention for regulatory compliance.

SDK

TypeScript SDK. Ruby and Python coming. Or hit the REST API directly.

First webhook in hours, not weeks.

Sandbox is free. 500 negotiations/month. Full API access. No credit card. Push data, get matches on the delivery network.

read the docs