OJCP (Open Job Context Protocol) is a new open standard built on MCP that lets AI agents discover, evaluate, and apply to jobs in a structured, consent-first way. It defines schemas and MCP tools for job search, application, and status tracking, aiming to standardize agent-job interactions.
Author here!<p>Agents are applying to jobs for people right now, with progressively more volume, and there's nothing built for it. So they scrape career pages and fight ATS forms with Playwright/Browser Use, which breaks constantly (or they get bot blocked). Employers get buried in applications that don't fit, candidates hear nothing back, and the resume is now an AI-written thing that another AI scores (which breaks the existing model entirely, btw).<p>OJCP is MCP tools for search and apply, a manifest at /.well-known/ojcp.json so agents can find providers, and schemas that extend schema.org instead of replacing it. The playground on the site is a live MCP endpoint, so you can throw calls at it right now.<p>Why a spec at all when models keep getting better at figuring things out? Inference can't produce authorization. An agent can work out what a form wants. It can't establish that someone consented to this specific submission, and then employer has no way to verify who's calling. So TL;DR a more capable agent is also a more capable impersonator.<p>In this model, trust runs both direction. Agents sign requests using the same method that CloudFlare and OpenAI are already using, providers sign their manifests, agents can check against a JWKS, and trust tiers cap how much candidate PII can go to a given provider. Validation happens at consent, so browsing costs nothing and you only pay the verify when the interaction occurs.<p>I'm the CTO of Recruitics (job advertising) and spent time at LinkedIn before that, so I've been at the intersection of hiring and job search for a while and have felt the pain of both sides.<p>Happy to answer any questions!
# OJCP — Open Job Context Protocol
Source: [https://ojcp.dev/](https://ojcp.dev/)

## The open standard for \|
OJCP defines how AI agents discover, reason over, and act on job opportunities\. Built on MCP\. Interoperable with schema\.org\. Governed by an[independent steering committee](https://ojcp.dev/governance), and designed to compose with the broader agentic web\.
Why OJCP
## Built for the agentic web
A shared protocol so AI agents and job providers speak the same language — structured, discoverable, privacy\-respecting\.
MCP\-Native Tools
OJCP tools are valid MCP tools\. Any MCP client can call search\_jobs, get\_job\_detail, and begin\_application out of the box\.
Structured Discovery
Providers expose a manifest at /\.well\-known/ojcp\.json\. Agents discover capabilities, tools, and apply paths automatically\.
Normalized Apply Paths
A standard taxonomy of application mechanisms — from ATS\-direct to agent\-ready flows — so agents know exactly how to apply\.
Consent\-First Privacy
Candidate data is opt\-in and scoped\. Resume embeddings enable fit\-scoring without transmitting PII\. Agents self\-declare identity\.
Agent\-Aware Ranking
Pass CandidateContext for personalized results\. Providers return fit\_score and fit\_rationale alongside standard job data\.
WebMCP Ready
Browser\-native agents can access OJCP tools via navigator\.modelContext\. Same schemas, same tools, new surface\.
Specification
## Schemas & Tools
OJCP defines seven core schemas and six standard MCP tools\. Providers MUST implement`search\_jobs`; all others are recommended\. Custom tools use namespaced names \(e\.g\.,`acme:get\_referral\_link`\)\.
Discovery endpoint at /\.well\-known/ojcp\.json
- `ojcp\_version`
- `provider`
- `tools`
- `mcp\_endpoint`
- `auth`
- `rate\_limits`
Extends schema\.org/JobPosting with agent\-specific fields
- `ojcp\_id`
- `skills\_required`
- `experienceLevel`
- `apply\_paths`
- `urgency`
Consent\-scoped candidate profile for personalized results
- `consent\_scope`
- `skills`
- `experience\_years`
- `employment\_type\_preference`
Agent self\-identification for audit trails
- `agent\_id`
- `acting\_on\_behalf\_of`
- `interaction\_mode`
- `user\_consent\_token`
Identity verification action for human completion
- `step\_id`
- `type`
- `verifier\_id`
- `verification\_url`
- `human\_required`
JWS proof with required claims: iss, aud, sub, iat, exp, nonce — no PII
- `step\_id`
- `verifier\_id`
- `proof\_token \(JWS\)`
- `subject\_hash \(SHA\-256\)`
- `issued\_at`
- `expires\_at`
Discovery document hosted at /\.well\-known/ojcp\-verifier\.json
- `verifier\_id`
- `verification\_types`
- `proof\_delivery\_methods`
- `proof\_format \(jws\|jws\+jwe\)`
- `signing\_algorithms`
- `public\_keys\_url \(JWKS\)`
How It Works
## Four steps from discovery to application
Discover
Agent probes`/\.well\-known/ojcp\.json`or queries the OJCP Registry to find providers\. The manifest declares available tools, apply paths, and authentication requirements\.
Search & Evaluate
Agent calls`search\_jobs`with optional`candidate\_context`for personalized ranking\. Each result includes`fit\_score`, apply paths, and structured metadata\.
Apply
Agent calls`begin\_application`with an`agent\_declaration`and the candidate's consent token\. The provider returns required fields and a session for multi\-step flows\.
Track
Agent calls`check\_application\_status`to monitor progress\. Providers emit structured status updates throughout the hiring pipeline\.
Examples
## See it in action
From discovery to application — real OJCP payloads your agents can use today\.
Apply Paths
## Normalized application taxonomy
OJCP standardizes the fragmented landscape of application mechanisms into a taxonomy agents can reason over\.
TypeDescriptionAgent Submission`ats\_direct`Apply directly via ATS \(Workday, Greenhouse, Lever, etc\.\)Varies
`provider\_hosted`Provider controls the apply flow and delivers to ATSFull Support
`platform\_native`Third\-party platform owns the flow \(e\.g\., Indeed Apply, Easy Apply\)Limited
`email`Legacy email\-based applicationNot Supported
`external\_redirect`Redirect to opaque external pageNot Supported
`custom`Catch\-all for non\-standard apply mechanisms \(homegrown, conversational, etc\.\)Varies
Live Playground
## Try the OJCP API
This site is a live OJCP provider\. Fire real tool calls against mock data — the same endpoint MCP clients connect to\.
MCP: /api/mcp
Manifest: /\.well\-known/ojcp\.json
An MCP server that integrates async-first working practices as tools for AI assistants, allowing users to draft decision docs, convert meetings to artifacts, score status updates, and more.
A Hacker News user asks about production usage of Model Context Protocol (MCP), with comments discussing its advantages and examples from real-world applications like UI updates and open data initiatives.
Open Envelope provides an open JSON Schema for defining AI agent teams with roles, handoffs, human checkpoints, and access policies, aiming for portability across frameworks.
AOHP is an Android-based open-source OS framework that treats AI agents as first-class entities, improving task completion by 21.12% and reducing token costs by 51.55% through agent-oriented mechanisms like personalized service composition and secure information flow.