Every healthcare operator running on a twenty-year practice monolith arrives at the same fork. The vendor demo on Monday says replatform, an eighteen-month rebuild onto a modern stack, with data migration, retraining, parallel billing, and a go-live weekend that everyone pretends will be quiet. The consultant on Tuesday says do nothing, harden the integrations, hire another biller, and live with the compliance debt. Both answers are wrong, and they fail in opposite directions.
The replatform fails on calendar and political risk. By month nine the original sponsor has moved on, the data model has drifted twice, and the new system is asked to absorb every workflow the old one ever did, including the four that nobody documented because they only run on the third Tuesday of the month. Do nothing fails on the integration tax: each new payer, each new referral source, each new compliance regime adds another brittle seam, and the staff who hold the seams together start leaving.
There is a third option, and it is the only one we recommend to operators running practice-shaped systems like AdvancedMD, Epic community connect installs, Cerner Millennium, Athenahealth, eClinicalWorks, NextGen, or the long tail of specialty PM/EHRs. We call it a brownfield wedge: a minimal, agent-native overlay that does one workflow end-to-end, on top of the existing system, without touching its write path until it has earned the right.
A wedge is not a project to replace the monolith. It is a runway built next to the monolith, on which one workflow at a time can land safely. The monolith keeps flying.
What a wedge actually is
A wedge is a thin vertical slice. It picks one workflow that the legacy system performs badly or expensively, and it implements that workflow on a separate, modern, agent-native plane. The wedge reads from the legacy system through whatever interface exists (HL7, FHIR, a direct read replica, a screen-scrape if it must), and it writes back only through the legacy system's sanctioned interfaces, only after a deterministic policy gate has said the write is allowed.
The wedge does not own the source of truth. The legacy system still owns the chart, the schedule, the ledger. The wedge owns the workflow logic for the slice it covers, and a complete audit trail of every decision it made and every action it took.
The pattern, in five components
- Read plane. A typed, cached view of the legacy state the wedge needs. Pulled from FHIR, HL7 v2 feeds, a read-only DB replica, or vendor APIs. Never written.
- Agent layer. The reasoning. Models propose candidate actions (a claim correction, a prior-auth packet, a follow-up message, a recall list). Models never authorize.
- Policy gate. A deterministic function that decides whether the candidate action is allowed to flow to the legacy write path. Action classes are a finite enum.
- Write adapter. The narrow seam that performs the allowed action through the legacy system's sanctioned interface. One function per action class. Fully logged.
- Evaluation plane. Parity tests against the legacy behavior, shadow runs on live traffic, canary cohorts, fail-closed reverts, and a control dashboard everyone can read.
None of this requires the legacy vendor's permission, and none of it requires the legacy system to change. That is the entire point.
How a wedge earns the right to act
Earning the right is a sequence, not a switch. A wedge moves through four states, and it cannot skip one.
- Parity. The wedge runs against historical data and reproduces the legacy system's behavior to within a measured tolerance on a locked test set. If it cannot match the legacy output on cases the legacy system already handled, it does not get to handle live cases.
- Shadow. The wedge runs on live traffic in parallel with the legacy path. It produces candidate actions; the legacy path executes. Disagreements are logged, triaged, labeled. The wedge never reaches the write adapter.
- Canary. A bounded cohort (one provider, one location, one payer, one CPT family) is routed through the wedge for real. The legacy path is the fallback. Fail-closed reverts trigger on any policy violation, any error, any latency breach.
- Absorb. The wedge becomes the primary path for the slice it covers. The legacy system retains the data of record, but no longer runs the workflow logic for that slice.
Each state has an exit gate that a human signs. Each state can be reverted in minutes, not weeks, because the wedge never owned the source of truth and the legacy system never stopped working.
The parity test is the contract
The parity test is what makes the whole pattern honest. It is a simple idea with a strict signature.
type ParityCase = {
caseId,
legacyInput, // exact payload the legacy system saw
legacyOutput, // what the legacy system did
wedgeOutput, // what the wedge would have done
diff, // structured comparison
classification, // match | benign_drift | regression | improvement
reviewer, // who labeled it
policyVersion,
modelVersion,
}A wedge does not move from parity to shadow until the regression count on the locked suite is zero and the benign-drift cases are explained. A wedge does not move from shadow to canary until the live disagreement rate has stabilized and every disagreement has a classification. The labels are produced by clinical or operations staff, not by the model that produced the output.
The agent overlay sits on read, not write
The reason an agent-native wedge is materially safer than a classic rewrite is that the agent never holds the pen. The agent reads the typed view of the world, reasons over it, proposes an action with a confidence and a justification, and hands the proposal to the policy gate. The policy gate is deterministic code, versioned and signed, that decides whether the proposed action is in the allowed set for this case, this cohort, this canary stage.
If the action is allowed, the write adapter performs it through the legacy system's real interface, the same one a human user would use. If the action is not allowed, the wedge logs the proposal, surfaces it for human review, and the legacy path runs unchanged. The model is never the rule engine, and the wedge is never the system of record.
A wedge that touches the legacy write path before it has earned the right is not a wedge. It is a second, less-tested production system, racing the first.
Why this works on AdvancedMD-shaped systems
Practice management monoliths like AdvancedMD have three properties that make wedges unusually effective. First, they expose enough read surface (reports, exports, a queryable schema, sometimes an HL7 feed) that a typed read plane is tractable in weeks, not quarters. Second, their write paths are narrow and well-known: claim submission, charge entry, demo updates, scheduling, task creation. A write adapter that covers the slice is a small, auditable surface. Third, their workflow logic is brittle in concentrated, expensive places (denials management, prior auth, eligibility, recall, A/R follow-up), which means a single wedge on a single workflow can pay for itself before the next quarterly board meeting.
This is the shape of work our embedded teams do every week. It is the core of our forward-deployed engineering practice, and it is why our healthcare data work almost always starts on the read side, with a typed view of the legacy world, before anyone proposes to write a single byte back.
What a real first wedge looks like
We will not name customers in a public post, but the shape is familiar. A multi-site practice running on a long-tenured AdvancedMD instance, an A/R aged trial balance that has crept past acceptable, a denials team that spends most of its day re-keying the same six fixes. The wedge: read claims and ERAs from the existing exports, classify each denial against a policy bundle of known remediations, propose the corrected claim, gate the proposal through deterministic eligibility and payer-rule checks, and submit the corrected claim through the sanctioned write path. Parity for two weeks against already-worked denials. Shadow for two weeks on live. Canary on one payer and one CPT family. Absorb when the metrics hold.
What ships is not a new RCM platform. What ships is a wedge that takes one expensive workflow off the staff, runs it cleaner and faster than the legacy path ever did, and leaves the legacy system exactly as the operator found it. The proof set lives in our healthtech RCM case study.
The honest tradeoff
Wedges accumulate. After the first three or four workflows have absorbed, the operator has a parallel plane that owns real logic, while the legacy system still owns the data of record and still owns the workflows nobody has gotten to. This is a real architecture, and it has to be managed like one. Cross-wedge consistency, a shared policy bundle, a common evaluation plane, and a clear ownership map all become work that did not exist on day one.
You cannot wedge forever. At some point the parallel plane is doing enough of the work that the right next move is either to absorb the legacy system function by function (the data plane being the last thing to migrate, not the first) or to commit to a real migration with the wedges as the de-risked target architecture. The wedge strategy is a runway, not a destination. The point of the runway is to get the operator from a place where every move is expensive and risky to a place where each next move is small, reversible, and clearly justified by the evidence the wedges have already produced.
The principle
The right answer on top of a twenty-year monolith is almost never a rewrite, and it is never nothing. It is a wedge: one workflow, agent-native, read-first, parity-tested, shadowed, canaried, fail-closed, and quietly absorbing the work the legacy system was never going to do well. The legacy system keeps running. The staff keeps working. The compliance posture does not move. And every quarter, one more expensive workflow comes off the monolith and onto rails that someone can actually reason about.
That is the only kind of modernization we have ever seen finish on a healthcare operator's clock.
- Forward-deployed engineering, the embedded model we use to ship wedges inside healthcare operators.
- Healthtech RCM case study, a brownfield wedge on top of AdvancedMD, in production.