The universal MCP layer for legacy systems

Every Fortune 500 runs on systems nobody wants to touch.

SAP. Guidewire. Duck Creek. Oracle EBS. Mainframe rails older than the analysts maintaining them. Today every AI vendor builds a bespoke, throwaway connector per client. Conduit normalizes these systems into clean, typed MCP tools once, and every agent built on top inherits the integration for free. Stripe-for-payments, applied to enterprise legacy access.

See the operating surface How the layer works

Core verbs

uniform across every backend

Write path

Gated

no silent commits, ever

First wedge

Claims

insurance policy & claims admin

One abstraction, not N

Conduit normalizes them once.

Into one typed surface every agent can share, the way nobody rewrites the Stripe integration from scratch anymore.

00% resolved · keep scrolling

Architecture

Four layers between an agent and a system it was never meant to touch.

The core verbs stay uniform no matter which backend sits behind them. Vendor-specific tools layer on top where a system genuinely needs them, but an agent written once keeps working when the backend changes.

Adapter layer

One adapter per backend system.

Guidewire, Duck Creek, SAP, a custom mainframe, each adapter translates vendor-specific APIs, RFC calls, and screen-scrape into a common internal schema. The mess is contained here, once, so nothing above it has to know how the record was really fetched.

MCP surface

A consistent set of tools, whatever sits behind them.

Five verbs cover the shape of almost every enterprise interaction. Reads are open; writes are drafted, never direct.

→get_record →search_records propose_change commit_changegated →get_audit_trail

Policy & permission layer

Every write routes through an approval gate.

Configurable per org, because it mirrors a real compliance requirement: no agent silently commits a change in a regulated environment. This is the layer that makes an enterprise buyer trust the thing, the difference between a demo and something legal will sign off on.

Audit layer

Every call logged, with the reasoning attached.

Not just what the agent did, but what it saw and why it decided that, because that is the first question every compliance officer asks. The trace is the product, as much as the write is.

Why this compounds

A layer, not a feature, and layers win slowly, then all at once.

STRUCTURAL

The pain isn't seasonal.

Legacy-system friction isn't going away, it's getting worse as more of the org wants agent access to systems that were never designed to give it. Demand grows against a supply that doesn't.

DEFAULT

First mover captures the default.

Whoever ships the "good enough" abstraction becomes the layer everyone else builds agents on top of, the way nobody rewrites Stripe from scratch. The second-best abstraction doesn't get built.

MOAT

Compliance is the moat.

Regulated industries get good tooling last, because the bar is high. Which is exactly why being first and credibly compliant is defensible, not a checkbox a fast follower ships in a sprint.

From the pitch to the work

Everything above is the argument. This is what an agent working inside those systems actually looks like.

The operating surface

A case file, not a dashboard of widgets.

Source documents left. The agent's live reasoning trace down the middle, rendered as ledger entries, not chat bubbles. The draft decision on the right, waiting for a human with authority to sign. Read it top to bottom, then commit the write.

⌘K commands · adjust the value · switch signer · watch the gate decide →

Queue

Source read-only

Reasoning trace

Decision draft

The universal claim

You just watched one backend. The verbs don't change for the next.

What changes stays sealed inside the adapter, a REST endpoint, a SOAP envelope, an RFC/BAPI call, a screen-scraped green-screen. The agent above is written once, against the surface. The further back the rail, the more a capability is reconstructed rather than native, and the matrix says so honestly.

Coverage illustrates the abstraction model, not a shipping matrix. Native = the adapter speaks it directly; derived = reconstructed from logs or scraped state; planned = on the adapter roadmap.
	Guidewire ClaimCenter	Duck Creek Policy	SAP FS-CD	Oracle EBS	Custom AS/400
how it's reached	REST · v10	SOAP	RFC / BAPI	REST + PL/SQL	screen-scrape
get_record	✓	✓	✓	✓	✓
search_records	✓	✓	✓	✓	◑derived
propose_change	✓	✓	✓	✓	◑derived
commit_change gated	✓	✓	✓	◑derived	○planned
get_audit_trail	✓	✓	◑derived	◑derived	◑derived

✓ native, adapter speaks it directly ◑ derived, reconstructed from logs / scraped state ○ planned, on the adapter roadmap

Go-to-market · honestly

Design partner first. Category-definer second.

The "universal" framing is earned, not claimed. Here's what has to be true before it's said out loud.

01
Land where the pain is sharpest.
Insurance claims and policy admin, Guidewire and Duck Creek integration is universally painful and the buyer is reachable. One vertical, done credibly, beats five done thinly.
02
One real adapter before any "universal" claim.
At least one production-grade adapter, not mocked, running against a sandboxed, non-production instance of a regulated FSP. Credibility externally starts there.
03
A permission model a compliance function reviewed.
Not assumed. The gate has to survive contact with an actual legal and compliance team before it's a selling point.

Private development

Be the FSP the "universal" claim is built on.

Conduit is in private, design-partner development. We're looking for one regulated financial-services partner willing to run a real adapter against a sandboxed instance, before any of this is said publicly.

Design-partner enquiries only · sandboxed, non-production first