The intelligence layer for
reimbursement operations.
Converus keeps the policies, contracts, fee schedules, mandates, and rules that drive reimbursement up to date, then makes that logic usable across your teams, systems, and AI workflows.
From policy to execution.
Converus does not just show you what a policy says. It turns policies, contracts, mandates, and fee schedules into rules your teams, systems, and agents can use.
Centralize the source material.
Bring payer policies, LCDs/NCDs, mandates, fee schedules, and contracts into one place.
- ✓Payer policies, LCDs/NCDs, MolDX
- ✓State and federal mandates
- ✓Fee schedules and contracted rates
- ✓Your contracts and internal billing guidance
Translate sources into logic.
Convert source documents into billing rules, PA requirements, documentation logic, appeal support, and coding guidance.
- ✓Coverage and medical necessity rules
- ✓Prior auth, submission, and routing logic
- ✓Documentation and appeal support
- ✓Rate rules tied to contract terms
Connect logic to the tools you use.
Push those rules into RCM tools, claim scrubbers, prior auth workflows, APIs, MCP, and AI agents.
- ✓API and MCP access for downstream systems
- ✓Billing, PA, claims, and appeal workflows
- ✓RCM tools and claim scrubbers
- ✓Internal dashboards and AI agents
The rules that drive reimbursement are scattered everywhere.
Policy PDFs. LCDs/NCDs. Fee schedules. Contracts. Portals. Spreadsheets. None of them update together. Teams end up billing from stale rules and learning about changes only after denials show up.
Stale rules become denials, rework, and missed reimbursement.
Centralize every source that affects reimbursement.
Converus structures payer policies, LCDs/NCDs, MolDX, state and federal mandates, fee schedules, coverage and documentation requirements, prior auth requirements, and your contracts into one reimbursement rule layer. Search by payer, test, CPT, indication, diagnosis, state, or rule type. See the source behind each rule and how it affects billing, prior auth, appeals, coding, and claims.
Use it the way your team works.
Load your contracts, dossiers, coding guidance, internal billing logic, and appeal templates. They sit next to the payer policies, fee schedules, and rules they affect, so contract terms become usable instead of trapped in a folder.
Billing rules your team can control, and your systems can use.
Manage reimbursement rules in one place instead of scattered spreadsheets, PDFs, and tribal knowledge. Converus keeps rules tied to the source policies and contracts behind them, then makes that logic available to your teams, systems, and agents.
Govern the logic that governs reimbursement.
Turn payer requirements into billing rules your team can use.
Converus does not stop at organizing documents. It translates payer requirements into rules your team can act on: is this test covered for this payer, is prior auth required, what documentation is needed, which CPTs apply, which diagnoses support medical necessity, which contract terms affect reimbursement, which rules changed recently, and which workflows or systems need to update.
Coverage is available when ALL of the following are met:
Covered, not covered, limited, excluded, or PA required by payer, test, CPT, indication, diagnosis, and state.
Required diagnoses, clinical criteria, medical necessity evidence, provider attestations, therapy history, prior labs.
Whether PA is required, what evidence is needed, which form or portal to use, and what exceptions apply.
Payer-specific logic for claims, coding, documentation, routing, submission, and reimbursement.
Published fee schedules, contracted rates, CPT-level rates, state variations, and payer-specific reimbursement terms.
Policy-backed arguments, missing evidence, denial root causes, and appeal language tied to the rule or policy that caused the denial.
One rule layer for market access and revenue cycle.
The same current logic supports market access, revenue cycle, payer relations, and the software and AI teams building on top.
Turn payer strategy into operational rules. Track payer coverage, mandates, rates, LCDs/NCDs, and contract terms across your menu. When coverage changes or contracts improve, Converus helps turn those wins into rules billing teams and systems can actually use.
Catch stale rules before they hit claims. See current PA requirements, documentation rules, coding logic, fee schedules, and payer-specific billing rules by test, CPT, indication, state, and payer. When denials happen, trace them back to the source rule, policy, or contract term.
Keep payer knowledge from getting trapped in people's heads. Store payer-specific notes, contract details, operational requirements, and escalation learnings beside the policies and rules they affect.
Give systems and agents current reimbursement logic. Use API, MCP, or custom integrations to connect billing systems, internal tools, and AI agents to current payer rules without maintaining the logic manually.
Update billing rules before stale logic creates denials.
Most teams find out a reimbursement rule is stale after claims start denying. Converus tracks payer policy, mandate, fee schedule, LCD/NCD, and contract changes, then maps those changes to the rules, tests, CPTs, indications, and workflows they affect. Your team can see what changed, review the affected rules, and push updated logic into the places where work happens.
Know which rules changed
Payer requirements, fee schedules, mandates, LCDs/NCDs, and contract terms move constantly. Converus tracks the source change and flags every rule, test, and workflow it touches.
Review source evidence before updating
Every rule update links back to the policy section, contract term, or bulletin that triggered it, so your team can review the source before approving.
Push approved changes into work
Updated rules can flow into billing systems, work queues, agents, and internal tools, so teams act on current logic instead of yesterday's spreadsheet.
Capture payer rules that are not cleanly published
Not every requirement lives in a policy PDF. Converus can capture authorization windows, filing limits, appeal deadlines, portal-specific requirements, required forms, payer IDs, rep-confirmed rules, and operational notes from payer calls, then structure them into the same rule layer.
AI agents grounded in your reimbursement logic.
Converus can support AI agents for prior auth, coding, appeals, claim review, and reimbursement operations. Each agent can use the same policy, contract, and billing rule logic your team controls in Converus.
Your agents should not guess from PDFs. They should act from approved reimbursement logic.
Prior auth, appeals, coding, scrubbing, and custom capture.
Already building your own agents?
Connect them to Converus through MCP so they can query current payer policies, contracts, fee schedules, and billing rules without your team maintaining that logic by hand.
Why reimbursement teams need a rule layer now.
Payer requirements keep changing, contracts are becoming more complex, and teams are trying to automate more of the revenue cycle. Automation breaks if the rules behind it are stale. Converus gives teams a current rule layer before those rules are used by billing systems, agents, and workflows.
Payer rules keep changing
Coverage criteria, PA rules, documentation requirements, and medical necessity standards keep moving.
Denials are too late
By the time a denial spike appears, stale logic has already reached claims.
Contracts need to become usable
Contract terms do not create value if they stay trapped in PDFs, folders, or decks.
Teams cannot scale this with spreadsheets
More payers, tests, CPTs, indications, and contracts mean more places for logic to break.
Agents need current rules
AI agents are only useful if they are running on current reimbursement logic.
Not another policy library.
Converus is not just a place to search payer policies. It is the control layer that turns policies, contracts, fee schedules, and mandates into executable reimbursement logic.
Every billing rule traces back to the policy, contract, mandate, or fee schedule it came from. No floating logic, no orphaned PDFs.
When a payer policy, mandate, or contract term shifts, Converus surfaces which rules are affected and what needs to change.
Reimbursement, billing, and market access review and approve rule changes before they reach claims, agents, or systems.
API, MCP, and custom integrations expose the exact same approved logic to billing platforms, scrubbers, and internal AI agents.
Stop relying on tribal memory and spreadsheets. The logic that drives reimbursement becomes a managed layer your organization owns.
Connect reimbursement logic to the tools you already use.
Converus makes reimbursement rules available where work actually happens.
Use APIs, MCP, or custom integrations to connect rules into your billing systems, prior auth workflows, claim scrubbers, internal dashboards, and AI agents.
API, MCP, or custom integrations
Plug Converus into billing systems, internal tools, or AI agents. Access current reimbursement rules without building and maintaining them yourself.
Rules updated as requirements change
Payer policies, fee schedules, mandates, and contract terms structured into queryable rules and updated as the source changes.
Coverage and billing rules by test, indication, and payer
Structured rules for diagnostics, genetic testing, and molecular oncology, ready for systems and agents to query.
Already building your own agents?
Connect them to Converus through MCP so they can query current payer policies, contracts, fee schedules, and billing rules without your team maintaining that logic by hand.
Common questions.
What does Converus do?
Converus centralizes payer policies, LCDs/NCDs, mandates, fee schedules, coverage requirements, and your contracts, then turns them into reimbursement rules your teams, systems, and agents can use.
What do you mean by reimbursement rules?
Rules are structured logic that tells your team or systems how reimbursement should work for a payer, test, CPT, indication, diagnosis, state, documentation scenario, or contract term.
Can we add our own contracts?
Yes. Contracts can be loaded into Converus and mapped beside the payer policies, fee schedules, and rules they affect.
How current is the data?
Converus tracks changes to payer policies, LCDs/NCDs, mandates, fee schedules, and contracts, then maps those changes to affected rules, tests, and workflows.
Do rules update automatically?
Converus identifies the source change and the rules affected by it. Depending on your setup, your team can review, approve, and push updated rules into downstream systems, agents, or workflows.
Can our systems use the rules?
Yes. Rules can be accessed through the app, API, MCP, or custom integrations.
Can our AI agents use Converus?
Yes. Internal agents can connect to Converus through MCP or API to query current reimbursement logic.
What if a payer rule is not published?
Converus can help capture payer-specific operational requirements from portals, provider calls, internal workflows, or other sources, then structure that data into your rule layer.
Do you support prior auth and appeals?
Yes. Converus can support prior auth, appeals, coding, claim scrubbing, denial triage, and custom payer data capture through co-pilot services.
Is this only for genetic testing?
The product is built first for diagnostics and genetic testing, where payer policy, medical necessity, CPT logic, LCDs/NCDs, MolDX, and documentation requirements are especially complex.
Turn your payer policy into billing logic your systems can execute.
See how Converus turns payer policy, contracts, and fee schedules into reimbursement logic your team can manage and your systems can execute.
Built for diagnostics, genetic testing, and specialty labs.