🤖 AI

Liquid Interfaces: A Dynamic Ontology for the Interoperability of Autonomous Systems

This paper introduces "Liquid Interfaces," a dynamic coordination paradigm and associated protocol that replaces static, deterministic system connections with ephemeral, runtime-negotiated relational events to enable adaptive interoperability among autonomous agents operating under semantic uncertainty.

Original authors: Dhiogo de Sá, Carlos Schmiedel, Carlos Pereira Lopes

Published 2026-01-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dhiogo de Sá, Carlos Schmiedel, Carlos Pereira Lopes

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to get a group of strangers to build a house together.

The Old Way (Solid Interfaces):
In the traditional world of software, this is like requiring every builder to bring a pre-fabricated wall that fits exactly into a specific hole in the foundation. Before anyone starts, you need a massive blueprint (a contract) that says, "The wall from Builder A must be 10 feet wide, 8 feet tall, and have a window on the left." If Builder B shows up with a wall that is 10.1 feet wide or has the window on the right, the whole project stops. Nothing gets built. This works great if you know exactly who is building what, but it falls apart if you have a team of AI agents that are creative, change their minds, or speak different "languages."

The New Way (Liquid Interfaces):
This paper introduces a concept called Liquid Interfaces. Instead of pre-made walls, imagine the builders meeting in the middle of the construction site and saying, "I need to cover this gap."

They don't check a blueprint. Instead, they talk it out.

The Intent: One agent says, "I need to get this package to a city 200 miles away, but the main road is closed."
The Negotiation: Another agent (a trucking AI) says, "I can't take the highway, but I can take a dirt road." A third agent (a warehouse AI) says, "I can store it overnight."
The Liquid Moment: They instantly agree on a plan. They shake hands (digitally), do the work, and then... poof. The agreement disappears.

The Core Metaphor: Water vs. Ice
The authors use the metaphor of Ice (Solid Interfaces) and Water (Liquid Interfaces).

Ice (Old Way): Rigid, permanent, and brittle. If the temperature changes (the situation changes), the ice cracks. You have to melt it down and refreeze it (rewrite code) to change the shape.
Water (New Way): Fluid and adaptable. It takes the shape of whatever container it is in right now. Once the task is done, the water evaporates. It leaves no puddle behind.

How It Works (The "Liquid Interface Protocol"):
The paper proposes a set of rules (a protocol) for how these digital agents talk to each other without needing a pre-written contract:

Intent First: You don't ask "What is your function?" You say "What is your goal?" (e.g., "Reduce costs").
Semantic Negotiation: The agents use advanced AI (like Large Language Models) to understand each other's messy, natural language goals. They figure out how to fit together on the fly, like puzzle pieces that reshape themselves to fit.
Ephemeral (Temporary): This is the most important part. The "interface" (the agreement) only exists for the time it takes to do the job. Once the job is done, the agreement is deleted. There is no "technical debt" left over. It's like a handshake that vanishes the moment you let go.

Why Do We Need This?
The paper argues that we are moving into an era where AI agents are everywhere. These agents are smart but unpredictable. They might interpret a request differently than expected.

The Problem: If you try to force these flexible, creative AI agents into rigid, "ice-like" contracts, they get stuck. They can't adapt.
The Solution: Liquid Interfaces let them flow around obstacles. If a port closes, the agent doesn't get an error message; it negotiates a new route with a different agent instantly.

The Rules of the Game:
To make sure this doesn't turn into chaos, the paper sets three main rules:

Intent is King: The interaction is only valid if it actually helps achieve the goal. If the conversation goes in circles, it stops.
No Ghosts: Once the task is finished, the connection must be broken. No lingering agreements.
No Hidden Ties: Agents shouldn't remember how they talked to each other last time in a way that forces them to talk the same way next time. Every interaction starts fresh.

Governance and Safety:
The paper also explains how to keep this safe. Instead of checking a list of "allowed actions" (like a bouncer checking a guest list), the system checks the intent.

Old way: "Can you access the database?" (Yes/No).
Liquid way: "Are you trying to do something that violates our safety rules?" (If the answer is yes, the negotiation stops before it starts).
It also keeps a "semantic log," meaning it records why the agents agreed to do something, not just what they did. This makes it easier to understand what happened later.

The Limitations:
The authors are honest: This isn't a magic wand for everything.

If you need something to happen in a split second (like stopping a car to avoid a crash), this "talk it out" method is too slow.
If you are in a very stable environment where nothing ever changes, the old "ice" method is still faster and cheaper.
Liquid Interfaces are specifically for when things are messy, changing, and full of uncertainty.

In Summary:
This paper suggests we stop building software like a rigid factory assembly line and start building it like a fluid conversation. Instead of forcing AI agents to fit into pre-made boxes, we let them negotiate a temporary, custom fit for the job at hand, and then let that fit dissolve, leaving no mess behind. It's a shift from static contracts to dynamic relationships.

Technical Summary: Liquid Interfaces: A Dynamic Ontology for the Interoperability of Autonomous Systems

1. Problem Statement

Contemporary software architectures rely on static interfaces, deterministic contracts, and pre-defined schemas (e.g., REST, GraphQL, RPC) to ensure security and efficiency. While effective for stable, closed systems, this paradigm creates a fundamental "ontological dissonance" when integrating Large Language Models (LLMs) and autonomous agents. These agents operate probabilistically, interpret natural language, and pursue high-level, context-dependent objectives (e.g., "reduce logistics costs by 15%").

The friction arises because "liquid" agents cannot effectively interact with "solid" APIs that demand rigid syntax and predefined structures. This mismatch forces human intervention to translate fluid intent into rigid form, creating a bottleneck for intelligent automation. Furthermore, the maintenance of connectors, schema synchronization, and breaking changes generates significant technical debt that scales exponentially with system complexity. Existing solutions, such as global ontologies or static service meshes, fail in open ecosystems where capabilities evolve dynamically, participants are unknown at design-time, and meaning must be negotiated during execution.

2. Methodology and Formalization

The paper proposes Liquid Interfaces, a coordination paradigm where interfaces are not persistent artifacts but ephemeral relational events that emerge through intention articulation and semantic negotiation at runtime.

2.1 Theoretical Shift: From Object to Event

The authors formalize a transition from the "Solid Paradigm" to the "Liquid Paradigm":

Solid Interface ( $I_{solid}$ ): Defined as a static tuple $(\Sigma, F, \lambda)$ enforcing strict structural compliance. Validity is binary ($0$ or $1$) based on whether input matches a fixed schema $\Sigma$ . Deviations cause system exceptions.
Liquid Interface ( $I_{liquid}$ ): Defined as a time-bounded generative function $N(A_{emitter}, A_{receiver}, \Phi, C_t)$ executed at time $t_0$ . It seeks Semantic Equivalence rather than structural equality. The negotiation function $N$ minimizes Semantic Entropy $H(S)$ between agents' horizons to generate a temporary protocol $\pi$ .

2.2 The Liquid Interface Protocol (LIP)

The paper details the Liquid Interface Protocol (LIP), a coordination model governing how interfaces emerge, stabilize, and dissolve.

Message Semantics: LIP uses structured JSON messages as performative acts rather than simple data transfers. Core types include intent (articulating objectives), offer (declaring capabilities), accept/reject, execute, complete, and dissolve.
Lifecycle: An interface is instantiated upon intent articulation, stabilizes through negotiation, executes under agreed terms, and is mandatorily dissolved upon completion or abandonment. No residual state persists.
Semantic Adjudication: Capability matching is treated as a decision problem under uncertainty. An LLM-based adjudicator evaluates the suitability of candidate agents against an intention $\Phi$ and context $C_t$ , producing a suitability score $s_i$ and a justification trace $r_i$ . This is augmented by outcome-informed priors $\rho_i$ based on historical performance, balancing semantic alignment with empirical reliability.
Failure Handling: Failure is treated as an informative coordination signal rather than an exception. It triggers renegotiation (revising constraints or offers) rather than immediate termination. If renegotiation fails, the interaction is dissolved.

2.3 Architectural Invariants

The paper defines four coordination invariants that a system must satisfy to be classified as implementing Liquid Interfaces:

Intentional Primacy: Validity is determined by the reduction of semantic uncertainty ( $\Delta H(S) > 0$ ) relative to a declared intention, not syntactic compliance.
Mandatory Temporal Dissolution: Interfaces are strictly bound to the interaction window $[t_{start}, t_{ack}]$ . Persistence beyond this window violates the protocol.
Bounded Residual Coupling: Residual coupling $R_c(A, B)$ between agents must be zero post-execution. No previously negotiated structures can be reused as binding assumptions.
Composable Intent Resolution: Intentions can be resolved through the composition of partial capabilities from multiple agents, provided the ordered execution reduces semantic entropy.

2.4 Governance and Security

Intention-Based Access Control (IBAC): Authorization is decoupled from concrete execution paths and evaluated against the expressed intent and organizational policies.
Semantic Auditability: The protocol preserves the semantic context and rationale of coordination decisions, enabling post-hoc reconstruction of why an outcome was reached.
Security Model: Relies on cryptographic identity binding (enrollment and challenge-response), message-level integrity for binding messages, and claim-based authorization scopes limited to the interaction context.

3. Key Contributions

Conceptual Framework: Introduces "Liquid Interfaces" as a dynamic ontology where interfaces are transient relational events rather than static contracts.
Formal Definition: Provides a mathematical formalization of the transition from static isomorphism to probabilistic semantic negotiation, defining the Liquid Interface as a function minimizing semantic entropy.
Protocol Specification (LIP): Defines a concrete protocol for intention-driven interaction, including message types, lifecycle management, and semantic adjudication mechanisms.
Governance Model: Proposes a shift from static perimeter security to intention-based governance and semantic auditability, aligning control mechanisms with the fluid nature of autonomous agents.
Differentiation: Explicitly distinguishes LIP from existing paradigms (Semantic Web, Microservices, ACLs, Smart Contracts, MCP) by highlighting its focus on runtime negotiation, ephemerality, and probabilistic reasoning over static agreement and determinism.

4. Results and Claims

The paper is a theoretical and architectural proposal; it does not present empirical performance benchmarks, experimental implementations, or case study results.

Feasibility: The authors present a reference architecture and protocol specification to demonstrate practical feasibility, explicitly stating that concrete implementations and performance trade-offs are subjects of ongoing and future work.
Theoretical Bounds: The paper defines the "boundary of liquidity," identifying conditions (e.g., entropy thresholds) where semantic negotiation fails to converge, necessitating a fallback to deterministic "solid" protocols or recursive simplification.
Limitations: The authors acknowledge that Liquid Interfaces are not suitable for domains requiring strict real-time constraints, bounded worst-case latency, or hard safety guarantees enforced through static verification. They also note the challenge of verifying agent capabilities in an open, trustless environment without reintroducing rigid hierarchies.

5. Significance

The paper argues that Liquid Interfaces provide a principled foundation for adaptive coordination in agent-based systems. By shifting the focus from "integration as infrastructure" (static connectors) to "coordination as a semantic process," the paradigm addresses the ontological mismatch between probabilistic agents and deterministic systems.

The significance lies in enabling autonomous systems to operate in open, heterogeneous environments without the accumulation of technical debt associated with static integration. It offers a mechanism for governance to emerge from coordination, allowing organizations to maintain accountability and control through intention-based policies and semantic auditability, even as execution plans and participating agents vary dynamically. The work challenges the software engineering assumption that reliability requires rigidity, proposing instead that reliability in the age of autonomous agents requires adaptability and enforced ephemerality.