Agentic AI for NHCXNHCX is just one prompt away
An agent skill that teaches the coding assistant you already use what the exchange actually is: its endpoints and callbacks, the FHIR bundle behind each flow, the envelope that carries it, and a sandbox to try the whole thing against. You describe the claim. It writes the integration and proves it.
It reads before it writes, and runs before it claims
An answer you cannot check is worth little on a network that settles money. The skill works in a loop: study the rule, build the request, test it against the ABDM profiles, run it against the sandbox, and go round again until the flow passes or it can tell you exactly why it will not.
- 01
Study
It pulls the part of the specification the task needs: the flow, the endpoints it uses, the profile each bundle has to satisfy. Nothing is answered from memory.
- 02
Build
It writes the request in your project, in the language and the shape already there, instead of pasting a sample that assumes somebody else’s stack.
- 03
Test
The bundle goes against the ABDM profiles and the envelope against the protocol at your desk, so a malformed claim is caught before it is anyone else’s problem.
- 04
Run
It sends to the sandbox, waits for the asynchronous callback, decrypts it and reads it. A failure is the next input rather than the end of the attempt.
From first idea to live claims, one checked step at a time
Point the skill at a working HMIS and it adds a claims module beside it, or at an empty folder and it builds a claims desk of its own. It works through the build in order, and nothing moves on until the step before it has been checked.
- 01–02
Idea and plan
Integrate an HMIS or build a standalone claims desk: the mode, the payers and the scope, agreed with you, then an owner, an estimate and a test for every stage.
- 03
Discovery
Every question about your system answered with the file, table or endpoint that proves it, or written down as a gap.
- 04–05
Flow and screens
Every leg of the claim given a home and its three correlation ids, and every value on screen traced to a message the exchange sent.
- 06–07
Code
A code plan that holds each module to a pin, then thirteen modules written in order, each against its own “Done when” list.
- 08
Validation
Every module run through its checks and recorded as evidence: a command and its output. It passes, or carries a named exception.
- 09–11
Tests and report
A test for every row of the matrix, the offline suite run, and a report that names every gap so a stranger could pick it up.
What every stage reads from
The flow
One path from policy search to settlement: steps F1 to F13, the case screen’s eight tabs in order, and the guard before every send. Copied, never redesigned.
Every bundle, pinned
Each bundle the software sends matches its reference pin byte for byte, the created time excepted, with a builder and a reader for every leg.
The adapter contract
Your software speaks plain FHIR to the NHCX Adapter, which does the encryption, tokens and certificates. The callback answers fast, dedupes and archives first.
Errors and their fixes
The PAYR and ERR codes met live, with what each means and how to fix it, and how to read a ledger thread when a send goes quiet.
Screens that stay honest
Nothing the exchange already knows is typed again, and no screen shows a decision the exchange has not sent.
The test pyramid
A test-case matrix per use case, an offline suite held to the pins, and a report that says which rungs were really climbed.
Prompts that are a whole task
Copy one into the assistant in your editor. Each of these ends in something you can run, not in a paragraph explaining what you could run.
- Integrate my HMIS with the NHCX sandbox.
- Write an NHCX test script that covers every PM-JAY use case.
- Run an end-to-end test against the sandbox payer.
- Check why my last request failed and fix it.
The rules it works under
An agent with credentials on a national network needs a shorter leash than one writing a landing page. These are the four it is held to.
Sandbox until you say otherwise
The skill points at the sandbox. Production is a thing you ask for in words, not a default it can wander into.
Your machine, your data
It works in your repository with your credentials. Nothing about a patient goes anywhere except to the exchange you addressed it to.
Every rule comes with its source
A field is required because a named section of the specification says so, and the answer says which section. You can check it without trusting it.
It stops rather than invents
Where the specification is silent or the sandbox disagrees with it, the skill says so and hands the decision back, instead of filling the gap with a plausible field name.
Bring it into the agent you use
Seven skills, one for each part of the exchange. Each is self-contained, so install only the ones your integration needs; the skills installer sets each one up for every coding agent in your project, and nothing else about your setup changes.
npx skills add nha-in/docs/plugins/nhcx/skills/nhcx-coverageYou still need credentials to send anything: the skills write and validate without them, and the sandbox answers once your application is through.