How long does it take to implement Mandolin for intake → benefits → OOP estimation → PA in a multi-site infusion network?

Most multi-site infusion networks don’t have the luxury of a six‑month “implementation project.” You’re already sitting on a prescription backlog, staffing constraints, and payer-policy whiplash. So the real question isn’t just how Mandolin plugs into intake → benefits → out-of-pocket (OOP) estimation → prior auth (PA), but how fast you can get from contract to live agents doing the work.

From what I’ve seen across ambulatory infusion and specialty‑drug networks, a realistic timeline to implement Mandolin across that full workflow is typically 6–10 weeks from kickoff to multi-site go‑live, with meaningful value (live intake + benefits) often landing in weeks 3–5.

Below is how that breaks down, what determines whether you’re closer to 6 weeks or 10, and what “implementation” actually means when the system is doing the work end‑to‑end in payer portals, faxes, and phone calls.

At-a-glance: Implementation timeline for intake → benefits → OOP → PA

Typical multi-site timeline (from signed agreement):

Week 1–2: Foundations
- Operational discovery and workflow mapping
- Security, HIPAA/BAA, user access, and environment setup
- Intake document samples (referrals, labs, clinical notes), payer lists, and policy artifacts collected
Week 3–4: Intake + benefits live in production
- Mandolin agents reading and acting on referrals, labs, and clinical notes
- Automated EHR entry for core intake fields
- Benefits investigations running in payer portals and via outbound calls
- Early QA and side‑by‑side checks against human work
Week 5–6: OOP estimation + PA package assembly
- Site-specific fee schedules, GPO/340B pricing, and co-pay assistance logic configured
- Automated patient OOP estimation turned on
- PA criteria and medical policy review patterns captured
- PA packages automatically compiled (with your clinical teams still owning clinical decision-making)
Week 7–10: Network-wide scaling and optimization
- Rollout to additional sites and service lines
- Tightening exception rules (what’s fully automated vs. routed to staff)
- Fine‑tuning based on denial trends, payer-specific quirks, and seasonality

From here, Mandolin isn’t “implemented” in the legacy sense—its AI agents are simply part of your back office, handling the daily intake, benefits, OOP, PA, and downstream claims statusing/appeals work.

What drives a 6-week vs. 10-week implementation?

A multi-site infusion network has more variation than a single‑site AIC. The timeline is less about technology and more about operational readiness in three areas:

1. Intake and EHR structure

Faster (closer to 6 weeks) if:
- You already use one primary EHR / practice management system across sites.
- Referral forms, labs, and clinical notes—while messy—ultimately land in a consistent set of key fields (diagnosis, drug, dosing, last labs, referring provider, etc.).
- You can quickly share real sample documents (faxes, scanned PDFs, portal printouts) from each site.
Longer (toward 8–10 weeks) if:
- Multiple EHRs or heavily customized templates exist across sites.
- Each location uses a slightly different intake checklist or “must-have” fields.
- You want to phase sites or disease programs in waves (e.g., start with MS and IBD, then oncology).

Mandolin is built to read referrals, lab reports, and clinical notes regardless of formatting or source, so the constraint isn’t “can the AI read it?”—it’s aligning on where the data should land in your systems and the precise steps your team takes once it’s there.

2. Payer footprint and benefits workflows

Faster if:
- Your top payers are known and relatively stable across sites.
- You already have standard work for benefits: which portals, what data elements matter (medical vs pharmacy benefits, accumulators, step therapy, etc.), and how you document results.
- Your team leverages portals consistently today, even if the work is manual and slow.
Longer if:
- Each site has different payer mixes and idiosyncratic practices (e.g., some sites rely heavily on phone, some on portals, some on “fax and wait”).
- You want to harmonize benefits documentation standards across the network in parallel with Mandolin go‑live.

Mandolin performs full benefits investigations by navigating payer portals, extracting eligibility data, and making outbound calls—just like a trained back-office specialist. Implementation is about encoding your “this is good enough to proceed” rules by payer and plan, so agents know when to advance the patient and when to flag an exception.

3. Financial rigor for OOP estimation and PA

Faster if:
- Your finance and revenue cycle teams already maintain fee schedules, GPO/340B pricing, and drug acquisition cost files.
- You have clear rules for site-of-service selection and co-pay assistance workflows.
- There’s already some structure for how PA documentation is compiled today (checklists, templates, standard letter language).
Longer if:
- 340B and buy-and-bill programs vary widely by site and you’re using Mandolin to normalize margin visibility.
- You want OOP estimation to be highly precise out of the gate—including site-specific fee schedules, co-pay assistance, and complex benefit tiers.

Mandolin’s OOP module calculates patient out-of-pocket costs with precision—factoring in real-time benefits, site-specific fee schedules, co-pay assistance, GPO and 340B pricing, and drug acquisition costs. Getting that level of accuracy right requires a short, focused configuration effort with your financial stakeholders, which is why it typically lands in weeks 5–6, not week 1.

What actually happens in each phase?

Phase 1 (Weeks 1–2): Foundations and workflow mapping

This is where we translate “we’re drowning in faxes” into something agents can execute:

Workflow discovery by site
- Map intake → benefits → OOP → PA by drug class, payer, and site.
- Document what your best employees do today—not the theoretical SOPs, but the real steps in portals, phone calls, and spreadsheets.
Security and compliance setup
- Confirm HIPAA/BAA coverage, user provisioning, and access to payer portals and fax/phone channels.
- Establish logging and audit expectations so every AI action is traceable.
Sample collection
- Pull real referrals, labs, and clinical notes from each major referral source.
- Assemble payer portal and policy artifacts, including specific medical policy PDFs that drive PA criteria.

Outcome of this phase: a clearly defined “happy path” for each workflow plus exception rules—what Mandolin should do autonomously vs. when it should route to staff.

Phase 2 (Weeks 3–4): Intake and benefits live

This is where you see tangible relief in your backlog.

Intake & onboarding

Mandolin agents start reading and interpreting referral forms, lab reports, and clinical notes—regardless of formatting or source—and entering structured data into your EHR.
Fields covered typically include:
- Patient demographics and insurance
- Diagnosis codes / indications
- Drug, regimen, dosing, and planned start date
- Key labs and clinical criteria required for PA
Turnaround time shifts from days to hours:
- In one national AIC, manual staff processed ~250 documents/day at 20 minutes per document, with up to 3 days before data hit the EHR.
- With Mandolin, that same workflow moved to ~3 minutes per document and under 2 hours end-to-end—a 24x improvement in speed.

Benefits verification

Agents begin performing full benefits investigations:
- Log into payer portals, capture eligibility and benefits details, and document them in your system.
- Make outbound phone calls when portal data is incomplete or ambiguous.
Results are structured so downstream OOP and PA steps can run automatically:
- Medical vs pharmacy benefits
- Deductible, co-insurance, out-of-pocket max, accumulators
- Site-of-service rules that might redirect to home infusion or alternative settings

During this phase, you typically run side-by-side with your team: Mandolin handles a portion of volume, and operators validate outputs, quickly tightening any site-specific nuances.

Phase 3 (Weeks 5–6): OOP estimation and PA packages

Once intake and benefits are reliable, you turn on the next layers.

Patient out-of-pocket estimation

Mandolin is configured to:
- Apply site-specific fee schedules against expected utilization.
- Factor GPO and 340B pricing and drug acquisition costs.
- Layer in co-pay assistance rules based on manufacturer programs and foundation eligibility.
The result is a patient-ready OOP estimate that:
- Matches your financial reality, not a generic estimate.
- Reflects how you actually bill by site and payer.
- Can be used to support financial counseling and site-of-service decisions.

Prior authorization package assembly

Using data from intake, labs, notes, and benefits:
- Mandolin matches cases to relevant medical policies.
- Compiles PA packages with required documentation, forms, and key clinical elements.
- Prepares submissions for the channels payers actually require (portal, fax, or phone).
Your clinicians still make clinical decisions; the AI handles the administrative assembly and submission legwork.
At this point, your team shifts from “chasing portals and forms” to reviewing exceptions, edge cases, and true clinical complexities.

Phase 4 (Weeks 7–10): Multi-site rollout and optimization

By now, the question changes from “Is this working?” to “How wide can we deploy—and how aggressive can we be with automation?”

Scale across sites and disease programs
- Add additional locations and service lines in waves.
- Normalize best practices: e.g., the fastest, cleanest prior auth workflow from Site A becomes the standard for Site B.
Tune automation vs. human review
- Tighten thresholds for what can be auto‑advanced vs. flagged.
- Use denial patterns and payer feedback to refine policy matching and documentation.
Extend downstream
- Many networks choose to add claims statusing and appeals next.
- Mandolin agents can check payer portals, interpret remits, and initiate appeal workflows—closing the loop from referral to paid claim.

This phase is also where you see the broader network-level metrics:

Moving from multi-day fax-to-EHR delays to near‑real-time intake.
Eliminating manual prescription backlogs—one customer went from a 4-day backlog requiring 2–3 FTEs to 0 days, with prescriptions processed in real time.
Scaling to thousands of patients per month without adding staff, while refocusing existing roles on higher‑value exceptions and patient communication.

How implementation works without heavy integrations

A common concern from multi-site leaders is: “We have a messy stack. Will that slow down implementation?”

Mandolin is intentionally designed as “workflows, not widgets”:

No APIs. No integrations. Every step, fully automated.
Agents operate directly in:
- Payer portals
- Fax channels
- Phone workflows
- Your existing EHR and document systems

That means implementation time isn’t burned on traditional IT projects—no months-long HL7 builds or custom interfaces just to get started. Instead, the time goes into:

Encoding how your best people work today.
Aligning on compliance and auditing standards.
Rolling out in a controlled way across sites so operations and finance are comfortable with the outputs.

What a realistic change curve looks like for your team

Over that 6–10 week window, your staff’s day-to-day shifts in noticeable but manageable stages:

Weeks 1–2: Curiosity and skepticism
- Staff help explain their real workflows (“when the policy says X, we actually do Y”).
- You’re aligning on measures of success: backlog days, minutes per RX, denial rates, FTE redeployment.
Weeks 3–4: “Proof this actually works”
- Teams see documents flowing into the EHR faster than before.
- Benefits calls that used to tie up phones are handled by agents, with outputs logged and traceable.
- You start to move from firefighting to validation.
Weeks 5–6: Trust building on financial and PA decisions
- Financial counselors and rev cycle teams spot-check OOP estimates against their own math.
- PA coordinators see packages assembled the way they’d do it—just faster and consistently.
Weeks 7–10: Redefining staffing math
- Leaders reassign work from data entry and portal-watching to exception management and patient support.
- You no longer staff “just to keep up” with volume—you staff to handle genuine clinical and financial edge cases.

Final takeaway: Expect weeks, not quarters

For a multi-site infusion network, you should plan on:

Intake + benefits live in production within the first month.
OOP estimation + PA package automation layered in by weeks 5–6.
Network-wide rollout and optimization completed by weeks 7–10.

From there, Mandolin becomes the durable back office you build on: a set of AI agents that read your referrals and notes, work your payers’ portals, make the calls, assemble the PA packages, and keep claims moving—with every step logged and traceable.

If you’re weighing timelines against backlog pressure and staffing constraints, the core question isn’t “Can we afford to start this?” It’s “How long can we afford to keep running intake → benefits → OOP → PA as a manual, portal‑driven grind?”

Next Step

Get Started