Services · 8–16 weeks typical
The substrate AI needs: your systems of record, reachable and reconciled.
The unglamorous engineering that determines whether everything downstream is possible. Reaching the systems that hold the evidence, joining them to a common key, and making the result fast and safe to query.
AI programmes rarely fail at the model. They fail two layers below it.
The evidence an enterprise needs is almost always present somewhere. It is also almost always behind an integration surface that was never designed to be integrated with — a platform whose REST API is disabled by policy, a warehouse nobody has documented since the person who built it left, an application that only speaks to a browser holding a single sign-on session.
The usual response is to declare those systems out of scope, which quietly removes the most valuable evidence from the analysis. What remains is the data that was easy to get, which is rarely the data that answers the question.
We have built production integrations against all three of those cases. It is genuinely harder than reading a documented API, and it is frequently the difference between a system that answers the real question and one that answers an adjacent, easier question nobody asked.
What we build
What this work involves
Difficult-surface integration
Where a supported API exists, we use it. Where it does not, we build resilient browser-session automation against the interface your own staff use — carefully, within policy, and with the operational reality of session expiry and rate limits designed in rather than discovered later.
Warehouse and database access
Direct connections to the enterprise data stores that hold inventory, telemetry and control data, with query patterns tuned for tables that are large, unindexed for your access pattern, and shared with production reporting.
Entity reconciliation
The genuinely difficult part: deciding that a host in one inventory and a virtual machine in another are the same thing, normalising the naming conventions that disagree, and surfacing rather than hiding the cases where two sources contradict each other.
Caching and freshness
A local cache with explicit refresh semantics, so analysis is fast and repeatable, does not hammer production systems, and can run when a source is briefly unreachable. Every record carries when it was last seen.
Write-back where it matters
Findings become tickets, tasks and records in the systems your teams already work in — queued, batched and reconciled, so that a transient outage does not lose work or create duplicates.
Operational instrumentation
Sync health, record counts, staleness and failures visible in the product itself, because an integration nobody can see the state of is one nobody will trust after its first bad week.
What changes
What this changes
The valuable systems come back into scope
The evidence that was previously "not accessible" becomes available to every downstream question, which usually reshapes what the analysis is capable of concluding.
Contradictions become visible
Once sources are reconciled to a common key, the disagreements between them surface — and the disagreements are consistently the most useful output of the whole exercise.
The next question gets cheap
This layer is built once and reused. The second and third analytical questions cost a fraction of the first, which is what makes an incremental programme financially sensible.
AI becomes a reasonable next step
With reconciled, provenance-tagged data in place, grounding a model is a modest piece of work. Without it, no amount of prompt engineering compensates.
Which system is currently out of scope because it is too hard to reach?
That is usually the one holding the evidence that would settle the argument.