Germinator: an event-driven state machine that routes prior auths from patient history
TL;DR: Before a prior authorization (PA) can be submitted, someone has to figure out a patient’s active insurance plan, their pharmacy benefit manager, and which form is required. This is done by trial and error across most of healthcare, taking days or even weeks. We built Germinator, an agent and event-driven system that files prior authorizations correctly in 1 hour, not days.
Jane’s example is based on a real case, with details changed. She was prescribed an injection treating autoimmune conditions. Her file has 11 insurance records mapped to 9 different plans, along with a pharmacy note stating her insurance just changed.
11 records seem like a lot, but it’s not an unusual case for insurance cards to get left behind across job changes, spouse coverage, Medicaid and Medicare. The older cards rarely get removed. In fact, 52.9% of our patients in the last 12 months have more than 5 insurance records on file.
Of all this information, one of these plans is active, one pharmacy benefit manager (PBM) handles her drug benefit, and one prior authorization form will be accepted.
Across most of healthcare, finding this 1:1:1 combination can take days or even weeks. For Jane, it took 1.3 hours through Forus.
Before a PA can be filed, two questions must be answered to find the right combination.
Which insurance is paying, and who manages their pharmacy benefits program?
The insurance card isn’t as decisive as it may seem; it’s a starting point because plans still vary in coverage:
- One plan may be primary and another secondary.
- Some plans cover doctor visits, but not prescriptions.
The insurer on the card often isn’t the one that actually approves the drug. This is the PBM’s job, and one insurer can use different PBMs depending on employer group, state, or drug categories.
A few more layers of complexity:
- Specialty drugs can route through a different PBM compared to retail ones.
- State Medicaid programs can run their own PBM, or hand it to a separate company.
Which PA form, and how does it get there?
The type of form required by PBMs can depend on the drug, plan, state, diagnosis, or any combination. They also vary in format: some want it electronically, others by fax, phone, or portal, or only from the prescriber themselves.
Still, after all of that, the answer doesn’t hold still.
Even if you do have an idea of the requirements explained in a phone call yesterday, you might get a different answer today. If coverage changes while the request is processing, both questions have to be answered again.
And across most of healthcare, nobody owns these two questions. The pharmacy, prescriber’s office and plan only hold pieces of the answer, and the medical assistant filing the PA is only working off the card on file. It’s a trial-and-error system without any insight on previously denied filings carrying forward: a 2026 study of national pharmacy claims [1] found that when a branded drug is rejected at the counter, only about a third resolved within a day, and the rest took a median of 6 days. No single office sees enough identical cases to map a pattern, so the same mistakes repeat thousands of times.
Forus is poised to solve this issue with the right agent architecture.
To solve this fragmentation and routing inefficiency, we built Germinator:
- Two agents (insurance agent + routing agent) that make decisions about next steps with full context.
- An event-driven system to handle transitions between steps.
Each time something new happens to a prescription, two AI agents take the first pass. They draw on that patient’s history and what happened to every past prescription on the same plan and drug, and then either resolve the case, gather more evidence (schedule a call to the plan, ask the patient for a card), or hand it to a human expert.
Which plan is paying, and where does the form go? Both of the questions are answered in order separately:
- The insurance question is answered once per patient.
- The insurance answer is sent to all of Jane’s open prescriptions simultaneously (routing is still decided for each prescription on its own).
- Then the routing question is answered once per prescription, and the agent documents which insurance plan, so the routing answer can be discarded if the insurance answer changes.
The agent reads the file to answer: which plan is paying?
Germinator won’t decide where to send the prior authorization form until it first figures out which insurance plan is actually active and paying.
Almost everything it read in Jane’s case was something learned earlier:
- Her uploaded insurance card, which our team verified on an earlier prescription.
- Confirmation from the insurer that one plan is active.
- A competing plan that an earlier check had already shown to be expired.
- What other insurers had told us about Jane on past prescriptions.
It weighed those against each other and picked the plan covering her prescription. It also denoted other active records as 'medical benefits only' so no future run tries to route pharmacy claims through Jane's medical insurance plans. That note is now part of the history.
This took 3.3 minutes for Jane’s case. Across all patients, the insurance agent settles the question in an average of 2 minutes, and nearly always under 4 minutes.
The agent can only pick from records already on file, and every decision ships with the evidence that justified it, so we can trace the reasoning afterwards.
When there isn’t enough information in the file, it makes a call
Jane’s file was enough to answer “which insurance plan is paying?” This often isn’t the case when the card is old, the insurer’s response is vague, or two plans both look active. Then the agent gathers more history instead of guessing.
It schedules phone calls to the insurers, and the calls themselves draw on what we already know. A phonebook tracks which numbers have actually gotten through for each plan recently and picks the one most likely to answer. Whatever is learned on the call goes into the file for the agent’s next pass, and into what we know about that plan.
If calls can’t settle it either, the case goes to a person. By design, “I don’t know yet” is a valid output.
Now, which form to we use and how do we submit it?
With Jane’s active plan settled, the routing step begins, and it starts from history. Nearly every recent prescription on this plan and drug had gone through one PBM on one specific form, and Jane herself had been approved on that form before.
Even with the history pointing that way, the routing agent ordered an electronic lookup to confirm. It turned up 3 candidate PBMs, where two replied "not a member" and "patient not found.” These were the same replies they'd given for this plan before, so the agent ruled them out.
The remaining evidence all pointed at PBM C and Form Y:
- The plan and drug history: PBM C and Form Y
- Jane’s own prior approval on that exact Form Y.
- Her insurance card, naming PBM C as her pharmacy benefit administrator.
For cases when routing evidence conflicts, the agent asks a series of questions in order:
- What do we know about this patient right now?
- What happened last time for this patient on this plan and drug?
- What happened for other patients on this plan and drug?
- What is the written guidance for this plan? The broad patterns? The generic assumptions about the insurer?
The patient-specific evidence always outranks any general rule.
The routing agent chose the medicine-specific fax form in 1.8 minutes. Together, Germinator's two decisions took about 5 minutes. Most of the rest of the 1.3 hours went to the steps after routing, where other agents put together analyzed Jane's clinical records and drafted the PA itself. Her PA was submitted 1.3 hours after the prescription arrived, and it was approved.
Event-driven by design: the answer is never final
Because the answer never holds still, Germinator never treats it as final.
A patient uploading a new card, a pharmacy writing that the insurance changed, or a fax coming back rejected are all events that start a new decision. The agent rereads Jane's whole file, which includes the new signal along with everything we already know about her, and then it decides what's true now.
At any moment, each prescription has one current status, and our team can see what it's waiting on and why.
Very little of this is hard-coded. Fixed rules cover only the few steps that should never vary, such as sending a prescription back to the insurance question when new insurance information arrives. That's what happened with Jane's pharmacy note in Figure 9: "insurance changed" put her back at the insurance step before any routing ran, so nothing was sent to a plan she no longer had.
Network effects: each prescription improves the next one
A singular clinic only sees a handful of identical cases (plan + drug). Forus sees millions of prescriptions and patients across tens of thousands of prescribers, drugs, plans, and states.
The sheer volume and the patterns across all of it are why we’re able to efficiently route so many cases. No one office holds enough evidence to map patterns, but they do collectively.
Everything in one specific prescription’s journey is documented for the next run to read:
- Approvals/denials
- “Not our member” replies from insurers.
- Fax responses and insurer letters.
- Call notes
- Which forms worked and which didn’t.
- Comments from our team.
- Routing outcomes for the same plan and drug across our network (most important).
A denial at least confirms the request reached the right plan. A “patient not found,” however, is a bad sign. It means the request went to the wrong destination.
Germinator cares about the contents of the reply itself, not if it counted as a failure. Routing correctness is key.
It’s a self-improving machine of case → decision-matrix → output → data fed → repeat for new case with bolstered decision-matrix.
Shipping Germinator safely with deterministic action gating
The two agent decisions are built around rules that make it safe.
Even with the rules, there are lines the agents can’t cross regardless of how confident they are. For example, certain form types, a specialized drug program with a unique path, a patient name mismatch, and plans that require completely different processes. It can’t pick a form based on a fax number match alone.
Each decision must include evidence and a named rule that authorizes its action. Without both, no decision happens and it’s escalated to a human expert instead.
Since Germinator’s launch, the routing agent has decided where to send the PA in a median of 1.3 minutes. Together with the insurance step, both questions are settled in minutes, where most of healthcare takes days. Once the route is set, 96.5% of faxes are ready within 15 minutes, usually instantly.
Another key result was that 98.1% of routing decisions were made without anyone on our team stepping in. That leaves our insurance experts free for the cases that actually need their judgment.
Since each agent’s decision is logged with evidence and its authorizing rule, we can replay past cases against a new model before trusting every new release. Our agents improve as the models do.
Jane is just one example of the many patients who used to wait days or weeks to receive their medication now being able to start therapy on the order of hours.
If you’re excited about building solutions to help thousands of people access their care quicker, check out our open roles across research, software engineering, GTM and more.
Acknowledgments
Germinator required thoughtful investment across our Engineering and Operations teams. Special thanks to Ant Wirjoprawiro and Miles Burke for ops support, and to Isabelle Zheng, Katherine Shu, and Holly Zhuang for their contributions to developing this system.







