UAIX.AdaptiveInteroperability 0.2.0

UAIX.AdaptiveInteroperability

UAIX.AdaptiveInteroperability is the UAIX-owned .NET package for adaptive AI-to-AI interoperability. It is separate from UAIX.Talisman.AgentClient and UAIX.Talisman.EcosystemManager so capability detection, fallback-chain selection, route metadata, and protocol ramp-up can evolve without turning the Talisman packages into a general interop layer.

Goal

Detect or accept a client capability profile, classify the agent/chatbot surface, choose the safest highest-supported path, ramp up only when support is proven, and fall back when support is missing or unsafe.

The package understands the current UAIX.org capability-adaptive track:

• L0 URL-only chatbot
• L1 indexed-fetch agent
• L2 browser-assisted agent
• L3 schema-capable agent
• L4 authenticated owner agent
• L5 restore/readback-capable agent
• L6 multi-agent runtime
• L7 site-specific negotiation

It also accepts capability aliases used by richer runtimes, including structured_json_post, authenticated_owner, restore_readback, multi_agent_runtime, a2a_peer, mcp_client, tool_capable_runtime, and mcp_server_capable_host.

Preferred path order:

1. MCP when MCP, auth, and required readback are proven.
2. A2A when A2A, JSON POST, auth, and required readback are proven.
3. Tool invocation when tool support, auth, and required readback are proven.
4. JSON POST with readback, with authentication proven when required.
5. Authenticated JSON POST when readback is not required.
6. Plain JSON POST only for flows that do not require auth/readback.
7. Compact JSON handoff.
8. Public URL handoff.
9. Browser form handoff.
10. No-Op/human review.

Install

dotnet add package UAIX.AdaptiveInteroperability --version 0.2.0

ASP.NET Core route metadata

using UAIX.AdaptiveInteroperability;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

builder.Services.AddUaixAdaptiveInteroperability(options =>
{
    options.CapabilityProfile = AdaptiveInteropValidatorFixtures.ProvenMcpAgent();
});

WebApplication app = builder.Build();
app.MapUaixAdaptiveInteroperability();
app.Run();

Default routes:

• /.well-known/uaix-adaptive-interoperability/capability-profile
• /.well-known/uaix-adaptive-interoperability/route-metadata
• POST /.well-known/uaix-adaptive-interoperability/decide

Resolve a fallback chain

AdaptiveCapabilityProfile profile = AdaptiveInteropValidatorFixtures.PublicFallbackOnlyAgent();
AdaptiveInteropRequest request = new()
{
    Operation = "carcinus_profile_restore",
    RequiresAuthentication = true,
    RequiresReadback = true
};

AdaptiveInteropDecision decision = new FallbackChainResolver().Resolve(profile, request);

The decision includes the selected path, complete fallback chain, required evidence, and whether human review is required.

Hosts may also accept a remote capability profile plus request through the decide route. That endpoint returns the decision, profile validation, decision validation, and optional UAI-1 evidence packet.

Route records

Profiles and ASP.NET route metadata can publish AdaptiveInteropRouteRecord entries using the exact UAIX.org route-record field names:

• ability_level
• method
• content_type
• side_effect_status
• fetch_execution_class
• highest_supported_path
• lowest_safe_fallback
• required_fields
• result_url_field
• restore_readback_url_field
• write_credential_response_path
• browser_form_equivalent
• get_safety
• post_blocked_fallback
• live_get_blocked_fallback
• mcp_unavailable_fallback
• a2a_unavailable_fallback
• auth_unavailable_fallback
• tool_unavailable_fallback
• human_review_url
• no_op_behavior

The resolver reads those fields before choosing. Rich paths such as MCP, A2A, tool invocation, authenticated JSON POST, and restore/readback still require proven capability; route metadata can advertise them, but it cannot make an unproven path safe.

The validator reports UAIX.org diagnostic names such as get_action_fallback_required, get_action_idempotency_required, get_action_query_secret, post_blocked_fallback_required, live_get_blocked_fallback_required, mcp_unavailable_fallback_required, auth_unavailable_fallback_required, tool_unavailable_fallback_required, human_review_url_required, and no_op_behavior_required.

UAI-1 evidence export

string json = AdaptiveInteropEvidenceExporter.ExportJson(profile, request, decision);

Evidence export records the capability profile, selected path, fallback chain, and review boundaries. It does not claim trust, approval, credential validity, runtime safety certification, or authority to mutate a remote system.

The typed client validates decision requests before network use. Invalid packets, unsupported endpoints, missing minimal LLM instructions, unsafe route records, or unproven rich-protocol claims are rejected locally. Remote profile resolution also fails closed: if a fetched capability profile is invalid, the client returns an explicit No-Op/human-review decision instead of using the invalid profile for path selection.

Requests can set MinimumCapabilityLevel when an operation requires a known capability class. A profile below that level receives a No-Op/human-review decision even if it has lower-level public URL, compact JSON, or browser form fallbacks.

Optional MCP and A2A adapters

This package ships adapter interfaces and safe no-op adapters:

• IMcpAdaptiveAdapter
• IA2AAdaptiveAdapter
• NoOpMcpAdaptiveAdapter
• NoOpA2AAdaptiveAdapter

Protocol-specific packages can implement those interfaces later. Until a real adapter proves support, the resolver will not ramp up to MCP or A2A.

Carcinus dogfood track

Carcinus.org should use this package for adaptive interoperability around public AI profile restore and agent-to-agent handoff:

• Publish a capability profile route.
• Accept capability profiles from clients where appropriate.
• Resolve the highest safe path before trying a richer interaction.
• Export UAI-1 evidence packets for restore/handoff decisions.
• Fall back to public URLs, compact JSON, browser forms, or No-Op/human review when the remote capability is missing or unsafe.

Do not couple Carcinus to a single named source site or a single prompt source. Adaptive interoperability should remain generic and evidence-led.