📦

Agentic Recruitment Protocol

An open standard for AI-powered recruitment that enables seamless integration between candidates, their AI agents, employers, and recruitment services. Provides REST APIs and MCP procedures for the complete recruitment lifecycle from job discovery to contract execution.

0 installs

Trust: 34 — Low

Agents

Ask AI about Agentic Recruitment Protocol

I know everything about Agentic Recruitment Protocol. Ask me about installation, configuration, usage, or troubleshooting.

0/500

Loading tools...

Reviews

Documentation

Agentic Recruitment Protocol (ARP)

The Agentic Recruitment Protocol (ARP) is an interaction model and open standard for connecting candidates, their AI agents, employers, and recruitment services to complete hiring processes seamlessly.

The specification is currently maintained by JINZ.AI (@jinzaix) and is currently in draft.

For employers — Reach more qualified candidates. Hire top talent by making your job postings available for discovery and application through AI agents—all while using your existing ATS infrastructure.
For AI Agents — Embed recruitment into your application. Let your users discover and apply to jobs directly in your application, without being the employer of record.
For ATS providers — Grow your volume. Process agentic applications by passing secure candidate data between candidates and employers through AI agents.

Learn more at agenticrecruitment.dev.

📦 Repo Structure

<repo-root>/
├── rfcs/
│   └── rfc.*.md
│
├── spec/
│   ├── openapi/
│   │   ├── openapi.arp_rest.yaml
│   │   └── openapi.arp_mcp.yaml
│   │
│   └── json-schema/
│       └── schema.*.json
│
├── examples/
│   ├── rest/
│   └── mcp/
│
├── changelog/
│   └── *.md
│
├── mock_server/
│   └── server.js
│
├── MAINTAINERS.md
├── CONTRIBUTING.md
├── LICENSE
└── README.md

🔗 Quick Links

Spec Type	Latest Version	Description
RFC (Markdown)	rfcs/	Human-readable design doc with rationale, flows, and rollout plan.
OpenAPI (YAML)	spec/openapi/	Machine-readable HTTP API spec for integrating recruitment endpoints.
JSON Schema	spec/json-schema/	Data models for payloads, events, and reusable objects.
Examples	examples/	Sample requests, responses.
Changelog	changelog/	API version history and breaking changes.
RFCs	rfcs/	Design documents and compatibility guides.

🛠 Getting Started

ARP has been first implemented as a mock server, providing a development-ready reference implementation for developers and integrators:

Mock Server: Complete reference implementation with all endpoints
OpenAPI Specs: Machine-readable API documentation
JSON Schemas: Comprehensive data model definitions
Examples: Ready-to-use request/response samples

To start building with ARP:

Review this repo's OpenAPI specs and JSON Schemas.
Use the mock server for development and testing.
Follow the guides provided in the linked documentation.
Test using the examples provided in this repo.

Quick Start

# Clone the repository
git clone https://github.com/jinzaix/agentic-recruitment-protocol.git
cd agentic-recruitment-protocol

# Start the mock server
cd mock_server
npm install
npm start
# Server runs on http://localhost:8787

Try REST Examples

# List job postings
curl -s http://localhost:8787/job_postings | jq

# Create an application
curl -s -X POST http://localhost:8787/applications \
  -H 'Content-Type: application/json' \
  -d @../examples/rest/create-application.json | jq

# Create an offer
curl -s -X POST http://localhost:8787/offers \
  -H 'Content-Type: application/json' \
  -d @../examples/rest/create-offer.json | jq

Try MCP Examples

# Search jobs using MCP
curl -s -X POST http://localhost:8787/mcp \
  -H 'Content-Type: application/json' \
  -d @../examples/mcp/searchJobs.json | jq

# Create application using MCP
curl -s -X POST http://localhost:8787/mcp \
  -H 'Content-Type: application/json' \
  -d @../examples/mcp/createApplication.json | jq

📚 Documentation

Area	Resource
REST API Spec	spec/openapi/openapi.arp_rest.yaml
MCP API Spec	spec/openapi/openapi.arp_mcp.yaml
JSON Schemas	spec/json-schema/
RFCs	rfcs/
Examples	examples/
Search Engine Compatibility	RFC 0002

🚀 Key Features

Dual Protocol Support

REST API: Traditional HTTP endpoints for web applications
MCP Procedures: JSON-RPC 2.0 for AI agent integration
Unified Data Models: Consistent schemas across both protocols

Comprehensive Workflow

Job Discovery: Search and filter job postings
Application Management: Submit and track applications
Interview Scheduling: Book and manage interviews
Offer Negotiation: Create, accept, decline, or counter offers
Contract Generation: Automated contract creation
Consent Management: Granular data sharing permissions

AI Agent Integration

Intelligent Job Matching: AI-powered candidate-job matching
Automated Applications: Streamlined application submission
Smart Scheduling: Intelligent interview coordination
Credential Verification: Automated credential validation
Negotiation Support: AI-assisted offer negotiations

Security & Privacy

Consent Framework: Granular permission system
Data Minimization: Share only necessary information
Audit Trail: Complete activity logging
Secure Transmission: Encrypted data exchange

SEO & Discoverability

Search Engine Compatible: Built with Schema.org structured data standards
Search Engine Optimized: Job postings appear in search engine results
Rich Snippets: Enhanced visibility with structured data markup
Industry Standard: Aligns with widely adopted Schema.org vocabulary

🏗 Architecture

Core Components

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Candidate     │    │   Employer      │    │  Recruitment    │
│   AI Agent      │◄──►│   AI Agent      │◄──►│   Service       │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────────────────────────────────────────────────────┐
│                    ARP Protocol Layer                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│  │   REST API  │  │   MCP API   │  │   Events    │              │
│  └─────────────┘  └─────────────┘  └─────────────┘              │
└─────────────────────────────────────────────────────────────────┘

Data Flow

Discovery: AI agents search for relevant job postings
Application: Candidates apply through AI agents with consent
Screening: Automated credential verification and matching
Interview: Intelligent scheduling and coordination
Offer: AI-assisted negotiation and decision making
Contract: Automated contract generation and execution

📝 Contributing

We welcome contributions! See CONTRIBUTING.md for:

Branching model
Pull request guidelines
Spec versioning and review process

All changes must include:

Updated OpenAPI / JSON Schemas
New or updated examples
Changelog entry in changelog/unreleased.md

📜 License

Licensed under the Apache 2.0 License. See LICENSE for details.

About

The Agentic Recruitment Protocol (ARP) is an interaction model and open standard for connecting candidates, their AI agents, employers, and recruitment services to complete hiring processes seamlessly. The specification is currently maintained by Kamol Mavlonov (@kamoljan) and JINZ.AI (@jinzaix).

agenticrecruitment.dev