The Last Mile That Never Connects
Why out-of-the-box integrations barely move the needle, and what semantic interoperability changes.

No enterprise legal platform lives alone. It has to talk to the document system, the accounts payable system, the firm's billing, and the matter data sitting in a dozen other places. Integration is where a lot of the value is supposed to come from. It is also where most of it quietly leaks away.
Here is what integration actually is in an incumbent platform. Two systems, each with its own fixed schema, and a human-built map between them. Your side calls it matter_id. Their side calls it MatterRef. Someone sits down and wires one to the other, field by field, and writes the transformation rules in the middle. For a while it works.
Then something changes. A firm updates its billing system. A field gets renamed upstream. A new matter type appears that the mapping never anticipated. And the map breaks, quietly or loudly, because it was a rigid translation between two things that were both frozen in place. Every change on either side becomes a re-mapping project. This is why the out-of-the-box connectors these platforms sell as modules so rarely move the needle. They are not starting points. They are brittle assumptions about data that does not hold still.
I watched this play out on implementation after implementation. The integration was never the hard part conceptually. Everyone knew what needed to connect to what. The hard part was that the connection was only ever as stable as the two schemas on either end, and schemas change.

Native-AI approaches the last mile differently, because it does not depend on the other system holding a fixed shape. It reads the incoming data the way a person would. Hand a capable person an invoice as a PDF, a rate feed from an API, and a messy CSV export, and they understand all three, because they are reading for meaning, not for field position. A native-AI system can do the same. It interprets the source instead of requiring the source to match a pre-defined map.
That one difference changes the economics of integration. The brittle part, the hand-wired mapping that breaks when either side moves, is the part that goes away. When the other system changes, the system adapts instead of failing. Integration stops being a standing maintenance burden and starts being something that mostly just works, and keeps working.
To be fair, this is not magic, and it is not an excuse to skip governance. Reading data by meaning still has to be validated, especially for anything that touches billing or spend, where a wrong interpretation has a dollar cost. A serious native-AI platform shows you what it mapped and lets you confirm it, which is the trust question this series ends on. But validating an interpretation is a different kind of work than rebuilding a broken map, and a far cheaper one.
This is the integration face of the same architecture gap I described in the first piece of this series. In an incumbent platform the connector is a translation between two frozen schemas, and it is only ever as reliable as the day it was built. In a native-AI platform the connection is a system that reads meaning, and it bends where the old one breaks.