Skip to content

Provider APIs change. Engineering intent shouldn't have to.

November 7, 2026 · Kishore Babu Gutta

A provider changes an endpoint, request shape, authentication requirement or response format. Why should every AI assistant, CI job and engineering script have to relearn how to achieve the same result?

The engineering intent might be unchanged: make repositories conform to an approved ruleset. What changed is the provider-specific way to express that intent.

Engineering Runtime (ENGRT) is designed to separate those concerns.

Without a shared contract, change propagates to every caller

Imagine a GitHub ruleset operation whose REST request shape changes. This is an illustrative scenario, not a claim that a particular GitHub endpoint has just changed.

Provider API change
    ├── agent A's generated REST code needs updating
    ├── agent B's custom tool needs updating
    ├── team scripts need updating
    └── CI integration needs updating

A model may know the old endpoint or schema from earlier training or context. That knowledge becomes stale. Prompts, documentation, tools, scripts and tests all need attention.

Put the provider-specific adaptation behind a stable engineering contract

In a capability-first model, callers depend on a declared operation rather than constructing each provider request themselves.

Human / CI / AI agent
    |
    | "converge repository ruleset"
    v
Versioned ENGRT capability contract
    |
    v
ENGRT supported provider operation
    |
    | provider-specific request and response handling
    v
GitHub API

When the external API changes, maintainers can update the lowest suitable shared layer:

  • If multiple capabilities rely on one provider operation, update the shared provider operation or adapter once.
  • If a workflow's steps or interpretation change, update the affected capability.
  • If the user-visible intent or required inputs change, revise or version the capability contract.

Once the new implementation has been qualified, compatible callers can keep invoking the same declared capability with the same inputs. They do not need to regenerate provider API code, and an AI model does not need to be retrained merely to learn a revised request shape.

That does not mean the model will never need current information. It still needs to discover the current capabilities, choose the right one, pass valid inputs and interpret results.

Versioned capabilities preserve outcomes as providers evolve

Versioning is a mechanism for controlled compatibility and rollout, not an automatic provider-update service.

Consider a reviewed capability whose intent is converge a GitHub repository ruleset to the organisation's approved standard. If GitHub later changes the REST representation of that ruleset:

  1. Detect the provider change and determine whether the existing operation still achieves the declared outcome.
  2. Update the shared ENGRT provider implementation when the change is common to several capabilities, or update the affected capability steps when the change is workflow-specific.
  3. Validate policy admission, authentication/context, execution, results, and authoritative state verification wherever the operation supports it.
  4. Qualify and release the compatible implementation or a new capability version, with a migration path if the public contract must change.
  5. Let approved human, CI and AI callers continue using the same stable interface only when compatibility has been demonstrated.

The capability represents the desired engineering outcome; the underlying provider integration is allowed to evolve to keep achieving that outcome. If the provider's semantics or required inputs change, that boundary must be reviewed rather than silently claiming compatibility.

No new model training is required solely to learn a changed provider API when the model invokes a current, compatible capability instead of constructing provider requests. The model still needs access to the latest self-description or capability catalog and may need refreshed context or instructions if the capability's published contract changes.

This is a forward-looking compatibility model. Versioned capability evolution and provider-change qualification are not universal guarantees of ENGRT's currently released GitHub integration.

Stable contracts require compatibility discipline

A provider update is not automatically safe just because it is hidden behind an interface.

Consider three cases:

Provider change Likely ENGRT response Caller impact
An endpoint URL or response field changes without changing behavior Adapt provider operation and qualification tests Potentially none for compatible capability callers
Authentication or authorization requirements change Update supported auth/context handling and requalify Additional setup or permission may be needed
Operation semantics or required business inputs change Review intent, capability steps and compatibility version Callers may need to migrate

A contract must not silently reinterpret a request. A ruleset convergence capability must still converge the intended standard and verify the outcome where its operation supports verification.

This also reduces model dependency on provider API training

An agent need not memorize every GitHub REST route to use a well-described ENGRT capability. The agent needs to understand its declared intent, inputs, preconditions and outcomes. Runtime and the reviewed capability carry the provider-specific execution details.

This gives enterprises a maintenance boundary shared by humans, AI tools and CI:

Changing provider implementation
                !=
Changing engineering intent

That is the intended abstraction, not a promise that any untested future GitHub API change will be automatically supported.

What would prove this benefit?

A reproducible compatibility demonstration could:

  1. Define a GitHub ruleset capability and record its public input/output contract.
  2. Use a fixture or mock provider with an initial API schema.
  3. Introduce a controlled provider-side request/response schema change.
  4. Update only the required ENGRT provider adapter or capability implementation.
  5. Run the same unchanged external callers and capability inputs.
  6. Assert the intended provider state, admitted execution, verification where supported and consistent sanitized evidence.
  7. Report which changes required a capability version bump, caller change or additional permissions.

This would demonstrate whether callers remained independent of provider protocol changes. It would not by itself prove universal compatibility with arbitrary future APIs.

ENGRT's current scope and direction

ENGRT's GitHub-first implementation provides provider operations, multiple supported engines, declared capabilities and the Runtime admission boundary. Broader provider registration, versioned compatibility guarantees and full multi-provider parity require additional implementation and qualification.

The point is an architectural principle with a practical test path:

Let models reason about engineering outcomes. Let reviewed contracts capture how to achieve them. Change provider-specific implementation in one controlled place where the contract can remain stable.

Related reading: Agents should reuse capabilities, not rewrite shell scripts, Capabilities are executable contracts, One provider can have many execution transports, and Versioned capabilities and compatibility.