The seven parts of the system

It helps to be explicit that “the system” is not the model. A workflow that survives contact with an organization has seven parts, and integration work touches all of them.

People. Who performs the work today, who will operate the workflow, and who is accountable for its output being correct.

Process. The actual sequence of steps, including the informal ones. The trigger that starts it and the condition that ends it.

Data. What the workflow reads and writes, where it lives, its classification, and the obligations attached to it.

Applications. The systems of record already in use: CRM, case management, ticketing, finance, document storage, analytics. These are constraints, not choices.

Models. The AI capability itself, along with its provider, version, retention posture, and cost per unit of work.

Controls. Permissions, approval gates, logging, evaluation, and rollback. The part most often deferred and most often regretted.

Measurement. The baseline, the instrumented outcome, and the review cadence.

A governed workflow, end to end

Governed AI workflow architectureA three-tier diagram. The middle tier is the workflow: intake and trigger, then retrieval of relevant context, then the model or agent step, then a human approval gate, then writing the result back to the system of record. The top tier is controls (permissions and access, logging and audit, evaluation, and rollback), which govern the model step and the approval gate. The bottom tier is systems and data (CRM, records, knowledge base, and analytics), which feed retrieval and receive the write-back. A feedback loop returns from the final step to intake, measuring against baseline.ControlsPermissions & accessLogging & auditEvaluationRollbackWorkflowIntakeor triggerRetrievalrelevant contextModel or agentdrafts the outputHuman approvalrequired to proceedWrite backto system of recordSystemsand dataCRMRecordsKnowledge baseAnalyticsMeasure against baseline, then improve

A single governed AI workflow. The middle tier is the operational path: a trigger, retrieval of relevant context, a model or agent step, a human approval gate, then a write back to the system of record. Controls sit above and govern the model step and the gate. Systems and data sit below, feeding retrieval and receiving the write-back. The dashed return path is measurement against the baseline. Original diagram; reuse with attribution to martinzialcita.com.

Principle

If a person still has to copy the output from one window into another, the integration is not finished; it has simply been moved onto a human.

Five integration patterns

Nearly every implementation uses one or a combination of these. They differ mainly in how much autonomy the system holds and therefore how much oversight it needs.

PatternHow it worksSuitsOversight needed
Direct APIYour application calls the model provider and handles the response in your own codeProduct features; high-volume, well-defined tasksAutomated evaluation and logging in your codebase
Automation layerA workflow tool orchestrates steps between systems, with the model as one stepMost first implementations; connecting existing SaaSRun history, failure alerts, a named owner
RetrievalThe model answers from your own documented material, with citations to sourcePolicy, product, and knowledge questionsSource freshness review; citation spot checks
AgentThe model plans and executes a multi-step sequence across systems within set boundariesVariable-path work that resists fixed rulesScoped permissions, approval gates, full action logs, rollback
Human approval gateAny of the above, with a person authorizing before the output takes effectAnything client-facing or consequentialA named reviewer and a recorded decision

The patterns compose. A common production shape is retrieval feeding a draft, orchestrated by an automation layer, released through a human approval gate.

Where this lands in practice

Concrete shapes these integrations take in ordinary operations.

  • CRM. An inbound inquiry is summarized, classified, and written to the correct record with a suggested next action, so the follow-up queue reflects reality without manual triage.
  • Intake. Forms, email, and attachments become structured fields on a case record, with missing-information prompts generated for the applicant.
  • Content. A first draft is produced from an approved brief and source material, then routed to a named reviewer before release. The reviewer edits rather than originates.
  • Analytics. Recurring reporting narratives are drafted from the actual figures, with the numbers pulled rather than restated, and flagged where a variance exceeds a threshold.
  • Knowledge. Staff questions are answered from current internal documentation with citations, and unanswerable questions are logged as documentation gaps.
  • Follow-up. Time-based sequences draft context-aware messages from the record, held for approval where the relationship warrants it.

Data handling and permissions

Two questions determine most of the integration design, and both should be settled before any connection is built.

What is this data, and what obligations attach to it? Classify before selecting a tool, not after. Donor records, student records, health information, and client confidential material each carry constraints that may rule out a provider entirely or require a specific contractual posture. Retention and training-use terms matter here: whether a provider retains prompts, for how long, and whether your content can be used to improve their models.

Whose identity is the system acting under? An integration running on an individual’s credentials inherits everything that person can see, which is almost never what the workflow needs. Service accounts with narrowly scoped, role-limited permissions are the correct default. Access should be revocable by the client without a support ticket, and reviewed on a schedule.

The arrangement worth insisting on: accounts owned by the client, with the practitioner granted role-limited access that can be removed at any time. That keeps continuity with the organization rather than the consultant, and it means an engagement ending does not put a workflow at risk.

Build versus buy

The honest default is buy, then integrate. Build when a specific condition holds, not because building signals seriousness.

Buy and integrate when

  • A credible vendor already covers the workflow
  • The task is common across organizations like yours
  • Speed to a working system matters more than differentiation
  • You lack the capacity to maintain software long-term
  • The data can lawfully and safely leave your environment

Build when

  • The workflow is genuinely specific to how you compete
  • No vendor covers it, and the gap is not a roadmap item
  • Data cannot leave your environment for legal or contractual reasons
  • Per-unit vendor cost at your volume exceeds the build and maintenance cost
  • You have, and will keep, someone to maintain it

Failure modes

The last-mile gap. Everything works up to the point where output must enter the system of record, and that final step stays manual. The workflow appears complete in a demo and delivers little in practice.

Brittle selectors and unofficial interfaces. An integration built against a screen layout or an undocumented endpoint works until the vendor ships a change. Prefer supported APIs; where none exists, treat the integration as temporary and monitor it accordingly.

Silent failure. The automation stops running and nobody notices for weeks, because success was invisible and failure is equally quiet. Every integration needs a failure alert with a named recipient.

Permission creep. Scopes get widened during troubleshooting and never narrowed again. Six months later the integration can read far more than its purpose requires.

Retry storms and duplicate writes. A transient error triggers a retry that writes a second record. Idempotency is unglamorous and prevents a category of embarrassing data problems.

Cost surprise. Per-call pricing behaves acceptably in testing and unacceptably at production volume, particularly with retrieval over large documents. Model the cost at real volume before launch.

Evaluation and monitoring

Evaluation before launch and monitoring after are different activities, and both are commonly skipped.

Before launch, assemble a set of real cases with known good outcomes, thirty to fifty is usually enough to be informative, and run the workflow against them. Include the awkward ones: the incomplete record, the unusual request, the case that a person got wrong. This set becomes a regression check for later changes.

After launch, watch four things. Volume, so you notice when it stops. Failure and retry rates. Override rate, meaning how often a reviewer materially changes the output, and whether that is trending down. And cost per unit against the model you built beforehand.

Log enough to reconstruct any single decision: the input, the retrieved context, the model and version, the output, who approved it, and when. That record is what makes an incident investigable rather than speculative.

Integration checklist

Worth confirming before an integration is treated as production.

  • Supported interface

    The integration uses a documented, supported API rather than a screen layout or undocumented endpoint.

  • Scoped service identity

    It runs under a service account with least-privilege scopes, not an individual’s full access.

  • Client-owned accounts

    The organization owns every account and can revoke third-party access without assistance.

  • Data classification recorded

    What the workflow touches is classified, and the provider’s retention and training terms are documented.

  • Defined write path

    Output lands in a specific field or record, with the approving person and timestamp captured.

  • Approval gate matched to consequence

    The review requirement reflects the risk tier of the use case, and the tier is written down.

  • Idempotent writes

    A retry cannot create a duplicate record.

  • Failure alerting

    Failures and silent stops notify a named person, not a shared inbox nobody reads.

  • Evaluation set retained

    Real cases with known outcomes exist and can be re-run after any change.

  • Cost modeled at volume

    Per-unit cost has been projected at realistic production volume, not test volume.

  • Rollback path

    The workflow can be disabled and the prior process resumed without data loss.

  • Documented for a successor

    Someone other than the builder could operate and explain it.

Limitations of this page

This describes integration in organizations running commercial business systems, without dedicated platform engineering teams. It does not address model training or fine-tuning infrastructure, real-time or safety-critical control systems, or deployments where a named regulatory regime dictates the architecture.

The security guidance here is operational rather than complete. A deployment touching regulated data needs review by qualified security and legal practitioners. See responsible AI governance and AI data practices.

Frequently asked questions

What is the difference between AI implementation and AI systems integration?

Implementation is the whole arc: choosing the workflow, deploying it, governing it, training people, and measuring it. Integration is the specific engineering that connects the capability to your systems, identities, and data.

Integration is a component of implementation, and usually the largest single component. A project can be well integrated and still fail implementation if nobody adopts it.

Do we need an API for every system we want to connect?

A supported API is strongly preferable. Where one does not exist, options are an intermediate export or file drop, an automation platform with an existing connector, or accepting a manual step at that boundary.

Integrating against a screen layout is possible and occasionally the only route, but treat it as temporary infrastructure with active monitoring; it will break on a vendor update, not if.

Should the AI have write access to our system of record?

It depends on the risk tier. Writing a draft, a note, or a classification to a record is commonly acceptable with logging. Writing something that triggers an external consequence, such as a payment, a client communication, or a status change affecting eligibility, should pass a human approval gate.

A useful default: the system may write anything a person can easily see and reverse. Anything it cannot easily reverse needs a person to authorize.

How do we stop this becoming dependent on one consultant?

Insist on client-owned accounts, documentation written for a successor, at least two trained operators, and a rollback path to the prior process.

These are reasonable things to require of anyone doing the work, and a practitioner who resists them is telling you something useful.

Author:
Martin Zialcita
Published:
Last reviewed:
Corrections:
Editorial policy