Infinitus Silences the Hold Music: How Graph-Powered AI Cut Prescription Coverage Data Turnaround from Days to Seconds

The American healthcare system runs on hold music. Before prescribing treatment, doctors must call to verify insurance coverage. Before scheduling appointments, staff must confirm in-network status. Before processing medications, pharmacies must check authorization requirements. Each verification requires a phone call to an insurance company, where hold times stretch into hours. For the patient waiting for treatment, this administrative friction is measured in days, sometimes weeks.

Infinitus set out to solve this by building AI agents capable of making these calls. Its voice AI navigates complex phone trees, waits on hold, and speaks with insurance representatives to gather data. It works. The company has automated over 100 million minutes of conversation – 190 years and 8 months’ worth – processing benefits verifications that previously required human staff.

But for Co-founder and CTO of Infinitus Shyam Rajagopalan, automating the call was only step one. The ultimate goal wasn’t a faster phone call. It was no phone call at all.

“The value is the information, not the communication,” says Rajagopalan. “If we have already verified that a specific plan in California covers a specific treatment for ten previous patients, why do we need to call the insurance company for the eleventh patient? We should just know.”

This shift from helping the AI speak to knowing the answer instantly required a change in how Infinitus managed data. It meant moving from a system that stored records to one that understood relationships, built on Neo4j.

The JSON Bottleneck

Infinitus built its rule engine on PostgreSQL. As the AI agents completed calls, the system stored the findings – payer rules, state-specific mandates, operational hours – inside the relational database.

This setup worked for simple queries. But healthcare logic is rarely simple. A benefits check is a conditional logic tree: a treatment might be covered, but only if the patient is over 18, lives in a specific state, and visits a specific provider network.

The Infinitus engineering team began stuffing complex logic into JSON blobs within Postgres to accommodate this variability.

“We were embedding all this rule-mined information inside JSON blobs,” explains Gurudutta Ramanathaiah, Engineering Lead at Infinitus. “For a small set of rules, it worked. But as our knowledge grew, the latency spiked. We had to parse massive objects and perform multiple hops into a database that isn’t designed for N-hop queries.”

The system reached its limit. The database had to execute complex logic chains to determine if a call could be avoided. In a relational environment, checking these nested conditions required multiple database calls or expensive table scans. The team realized they needed a database that could understand relationships and quickly find connections in the data. Without it, the entire AI initiative would stall.

“We realized we were using the wrong technology to solve the right problem,” says Ramanathaiah.

The latency threatened the user experience. Infinitus aims to provide a humanlike experience, whether the AI is speaking to a payer or a provider. If the system takes twenty seconds to respond to a user question, the experience suffers.

The Solution: A Brain for the AI Agent

The team needed a solution that could model the complex, interconnected reality of healthcare data. They chose Neo4j AuraDB on Google Cloud.

The move to a graph database allowed Infinitus to treat healthcare rules as a network of connected nodes rather than rows in a table. A “Payer” node connects to a “Plan” node, which connects to “Treatment” nodes, each with specific “State” or “Age” constraints.

Instead of parsing a JSON blob to find a rule, the system traverses the graph.

“We can now construct a query in one shot,” says Ramanathaiah. “We can add operators like ‘starts with,’ ‘contains,’ or check array elements – things that are impossible to support efficiently in an RDBMS. Even the most complex query comes back within a second.”

Infinitus operates as a Google Cloud shop, a decision driven by the low latency of Google’s speech-to-text API, a critical factor for conversational AI. Today, the architecture relies on a tight integration between their AI agents and the graph database.

When a request comes in – for example, a provider asking about benefits for a patient – the workflow follows a logic path:

1. Check the Graph: The system queries Neo4j via a tool call.

2. Traverse the Rules: The query checks if this specific combination of Payer + Plan + Treatment + Patient Demographics has a known, verified answer.

3. Deflect or Dial:  Deflect:  If the graph holds a high-confidence answer (e.g., “We verified this exact scenario 20 times this week”), the system returns the data instantly. No phone call occurs. Dial: If the data is missing or stale, the AI agent initiates the phone call to the payer, gathers the new data, and updates the graph for next time.

This creates a flywheel effect. Every phone call the AI makes enriches the knowledge graph, increasing the probability that the next request can be avoided.

“We are moving from a data warehouse to a graph intelligence platform,” Rajagopalan notes. “We rule-mine our own calls. If we see that a drug is always covered in 49 states but never in Hawaii, the graph captures that exception. The next time a request comes in for Hawaii, we know the answer immediately.”

Impact: Time to Therapy

Moving logic from Postgres to Neo4j reduced query latency for complex rules from multiple seconds to sub-second responses. This speed is vital for the agentic experience as the AI must think as fast as a human. By using the graph to avoid calls, Infinitus has moved a double-digit percentage of its volume to instant verification.

“When a human has to make these calls, the average turnaround time is often four to five days because of the sheer backlog of work,” says Rajagopalan. “With our AI agents making the calls, we brought that down to one or two days. But when we use the knowledge graph to avoid the call entirely, we reduce that turnaround time to seconds.”

For a patient waiting for a prior authorization on a critical medication, that speed difference is profound. It removes the anxiety of the unknown and allows treatment to begin days sooner.

Infinitus plans to extend its use of Neo4j as it expands into inbound call handling. Unlike outbound calls where the AI agent drives the conversation, inbound calls can arrive about any topic. A scheduling line might receive questions about medications, coverage, or symptoms. These open-ended conversations require broader knowledge retrieval capabilities.

“The moment you open up inbound phone numbers, people can call about anything,” notes Rajagopalan. “You need to pull in large knowledge bases to answer those questions effectively.”

Vector search and retrieval-augmented generation are on the roadmap, extending the graph’s capabilities while maintaining the speed and accuracy that healthcare demands.

“The onboarding experience makes or breaks most new technology adoption,” reflects Ramanathaiah. “Neo4j has been pretty smooth. You don’t need to rack your brain figuring out how the product works.”

For patients caught between their doctors and their insurance companies, that smoothness translates into something more tangible: getting the care they need, when they need it, without days of uncertainty in between.