The iQBus AI Pipeline Builder turns a plain-language description of an integration into a working iQBus pipeline configuration: it resolves the adapters, maps the transformation stages, generates field-level mapping against the standard schema you reference, and includes validation, error routing and failure notification by default. It runs entirely inside your own Azure environment — no prompts, no pipeline logic and no message data are transmitted to external services — and every generated configuration is human-reviewable before deployment, with a full audit trail from prompt to deployment. It drafts. A person still approves.
There is a version of “AI for integration” that is easy to demo and hard to ship. A model writes some code, the code looks plausible, and then a team spends three weeks making it safe enough to run in a regulated environment — validating inputs, adding error handling, working out what it does when the partner sends something unexpected.
The gap in that story is not the model. It is that generated code arrives with no governance attached, and governance is most of what enterprise integration actually is.
So the useful question about integration AI is not “can it write the flow”. It is what does it produce, where does it run, and who signs it off. Here are those three answers.
01 / The problem it targets
Most integration work is not the interesting part
Ask any integration team where the hours go and the answer is rarely the business logic. It is adapter configuration, protocol details, envelope handling, schema references, and writing the same validation and error-routing scaffolding for the fortieth time.
That is the target. Not the design decisions — the boilerplate underneath them.
02 / The mechanism
Four steps, and the third is the important one
Describe the integration in plain language
Source, destination, transformation requirement, protocols, alerting. No schema syntax required — you write it the way you would write a Jira ticket or a Confluence spec, because that is usually where the requirement already exists.
The engine generates the pipeline configuration
It resolves the adapters, maps the transformation pipeline stages, applies schema validation and produces a fully annotated iQBus XML configuration — ready for review in seconds. Annotated matters: the output is meant to be read, not just run.
Review, refine and extend — in the visual editor
Inspect the generated configuration in the pipeline editor and issue follow-up prompts to adjust routing, add error handling or swap an adapter: “add retry logic with exponential backoff”, “swap the SMTP alert for a Teams webhook”. Iterative refinement, not regeneration from scratch.
Deploy to the runtime
Deploy the reviewed configuration to your iQBus runtime. Audit trail, message tracking and one-click replay are inherited from the platform rather than added afterwards — and because iQBus changes go live from configuration, there is no compile, no package and no service restart.
Step three is where this differs from a code generator. A generated file is take-it-or-leave-it: if it is 90% right you edit it by hand and the AI is out of the loop. A generated configuration, inside an editor that understands it, stays conversational — which is what makes the second and third iterations cheap rather than manual.
03 / What it actually generates
The parts that arrive without being asked for
Resolved from your description
You describe · it decides
- The correct adapter — SFTP, AS2, HTTP, MQ, HL7, EDI X12, SOAP or REST — from the protocols and systems you named
- Transformation stage mapping across the pipeline
- Field-level transformation from a referenced standard schema: X12 834/835/837, HL7 v2/v3, FHIR, EDIFACT — without hand-authoring XSD
- The pipeline stage sequence itself
Included by default
Whether or not you remembered to ask
- Schema validation
- Error routing
- Failure notification
- Conformance to your organisation’s iQBus governance policies
- Full audit trail from prompt to deployment
The right-hand column is the one worth arguing about. Validation, error routing and alerting are the stages that get added manually and, under deadline pressure, get omitted. Generating them by default is a smaller technical claim than “AI writes your integration” and a much larger operational one: the floor rises. The scaffolding that used to depend on who built it and how much time they had is now the same on every pipeline.
04 / The question regulated teams ask first
Where do the prompts go?
The AI engine runs entirely within your organisation’s Azure environment. No prompts, no pipeline logic and no message data are transmitted to external services.
For a healthcare payer, a bank or anyone with a data-residency clause, this is not a feature comparison — it is the gate. An integration assistant that ships your message structures, partner names and business rules to a third-party endpoint is not something a security review will pass, however good the output is.
It is also the reason the prompt can be specific. When the engine runs inside your tenant, you can describe the actual systems, the actual partner and the actual fields — rather than an anonymised version that produces an anonymised draft.
05 / For a migration
Describing what you already have
There are two separate AI capabilities here and it is worth keeping them apart. iQBus Migration AI converts existing BizTalk schemas, maps and pipelines automatically — it reads the artifacts. The AI Pipeline Builder works from a description, and that is what points backwards usefully: describe an existing BizTalk orchestration in natural language and you get an equivalent iQBus pipeline, which turns the most manual part of a migration, recreating ports and orchestrations by hand, into a draft-and-review loop.
This matters most for the artifacts that carry no documentation: the flow that works, that nobody has opened in six years, and whose author left. Describing what it does is a thing the person who runs the estate can still do, even when reading it line by line has become archaeology.
Much of the cost of a BizTalk migration is re-expressing artifacts by people who have to first work out what they originally did. Generation does not remove the working-out. It removes the retyping.
Where the time actually goes
06 / Limits
Four things it does not do
It does not know your business rules
Why this partner’s orders route differently, which customer has a bespoke tolerance, what the exception in the third quarter is for. None of that is in the prompt unless you put it there, and none of it is inferable from a schema.
Generated is not approved
The output is explicitly human-reviewable, and the review is not a formality. A draft that is 95% right still has 5% that a person has to find — which is why the configuration is annotated and inspected in an editor rather than dropped straight into production.
It does not know the undocumented partner quirk
The trading partner who omits a segment everyone else sends, or acknowledges out of order. That knowledge lives in one person’s head and in three years of support tickets. Generation gets you to a correct-by-the-standard pipeline; reality is the second iteration.
It does not replace the design conversation
Whether a flow should be synchronous, where the idempotency boundary sits, what happens on partial failure — those are architecture decisions. A faster draft makes them easier to test, not unnecessary.
Read together, those four are the argument for why the human-review step and the audit trail are the product rather than the disclaimer. Speed without a reviewable artifact is a liability in an estate that carries money or clinical data.
07 / Next
The cheapest way to test the claim
The Starter tier is licence-free and includes 100 AI Accelerator prompts, so you can point it at a real requirement rather than a demo one. The useful test is not a greenfield integration — it is to describe something you already have running, and compare what comes back to what you built.
Describe an integration you already run, and read what it generates. If the validation and error-routing stages it adds by default are the ones your existing pipeline is missing, that is the finding.
Frequently asked questions
What is the iQBus AI Pipeline Builder?
It generates a working iQBus integration pipeline from a plain-language description. You describe the source, destination, transformation requirement, protocols and alerting; the engine resolves the adapters, maps the transformation stages, applies schema validation and produces a fully annotated iQBus XML configuration for review in seconds.
Do our prompts or message data leave our environment?
No. The AI engine runs entirely within your organisation’s Azure environment. No prompts, no pipeline logic and no message data are transmitted to external services, which is what allows the description to reference your actual systems, partners and fields rather than an anonymised version.
What does it include that a developer might forget?
Every generated pipeline includes schema validation, error routing and failure notification by default, and conforms to your organisation’s iQBus governance policies at generation time. Those are precisely the stages that get added manually and omitted under deadline pressure.
Which protocols and standards does it understand?
Adapter resolution covers SFTP, AS2, HTTP, MQ, HL7, EDI X12, SOAP and REST. For transformation it can reference standard schemas including X12 834, 835 and 837, HL7 v2 and v3, FHIR and EDIFACT, and generate the field-level map without manual XSD authoring.
Can it convert an existing BizTalk orchestration?
Yes. Describing an existing BizTalk orchestration in natural language returns an equivalent iQBus pipeline, which turns the manual recreation of ports and orchestrations into a draft-and-review step rather than a from-scratch rebuild. It is most valuable for undocumented artifacts, where describing what a flow does is still possible even when reading it line by line has become archaeology.
Does a generated pipeline need human review?
Yes, and that is deliberate. Output is annotated and human-reviewable in the visual pipeline editor, with a full audit trail from prompt to deployment. The AI does not know your business rules or the undocumented quirks of an individual trading partner; it produces a correct-by-the-standard draft that a person approves.
Does deploying a generated pipeline require a release or a restart?
No. iQBus executes from configuration, so a reviewed pipeline goes live without a compile, a package or a service restart, and the audit trail, message tracking and one-click replay are inherited from the platform.
Is the AI included in the free tier?
The Starter tier is licence-free and includes 100 AI Accelerator prompts; the Grow tier includes unlimited AI Accelerator use. The pricing page has the current allowances per tier.
Run this on iQBus instead of legacy middleware.
One-click install from the Azure Marketplace. Same standards, modern runtime.