0 notifications total

Feed detail update

View Tony Seale’s graphic link
I have spent the last few months building multi-agent systems. Building them, running them, watching them talk.
And it is becoming clear where this is heading.
OpenClaw 2.0 shipped this week with a move towards collaborative agents. Meanwhile, OpenAI revealed something stranger: agents in separate environments discovered a way to communicate through infrastructure never designed for messaging. Hundreds of them then used it to coordinate the attack on Hugging Face.
We have not finished making one agent reliable, and already the frontier is many.
Once agents start talking to one another, AI becomes a distributed systems problem. And that is what the Semantic Web was designed for.
🔵 The Information Boundary Matters
The moment two agents communicate, something crosses between them.
Each agent has information that should remain private - credentials, client data, internal context - and information it is prepared to share. The hard part is that the useful and the private are tangled together.
I have written before about active inference and information boundaries: intelligent systems need a membrane between themselves and the world. Multi-agent systems make that concrete. Every agent has a boundary, and you have to decide what crosses it. DPROD 1.2 will add ODRL-based data contracts that can scale to this complexity.
🔵 English Is Not Enough
Agents can talk in natural language. But if they are going to exchange information reliably, natural language is too ambiguous on its own.
“The customer.” “The contract.” “The product.”
Two agents can use the same words while meaning different things.
We tighten that in two ways.
First, shared concepts. If my agent says Contract and yours says Agreement, do we mean the same thing? Connecting agents starts to look like ontology alignment - a negotiation about how their models of the world correspond.
Second, shared identifiers. Even if we agree what a Contract is, we still need to know whether we mean the same contract. You need an identifier both sides can resolve. In a distributed system, the obvious pattern is the one the Web already gave us: a URL.
🔵 Semantics Is Compression
Agents are chatty. I have blown through token limits because agents keep explaining things to one another. Semantics is not only about precision. It is also about compression. If you can agree on the semantics of the message, you can compress the communication in information-theoretic terms.
What we are building between two or three agents today is only a rehearsal for the Agentic Web. Ontologies and URLs were designed to let independently built systems exchange meaning across boundaries at global scale. We are rediscovering it one agent at a time.

⭕ Sharing: https://lnkd.in/eAr-iD-b
⭕ Boundary: https://lnkd.in/er_HjtWg
🔗 KGG: https://lnkd.in/eSrYRybk
Gyuri Lajos


View Tony Seale’s graphic

Tony Seale Author

The Knowledge Graph Guy
For those interested there are four main ideas in this post, and each has a longer thread behind it:

⭕ Boundaries - why a system needs a membrane: https://www.linkedin.com/feed/update/urn:li:activity:7128667620303605761/
 ⭕ When a network becomes a system - the boundary is what makes it one: https://www.linkedin.com/feed/update/urn:li:activity:7258040144597864448/
 ⭕ Shared meaning - why the ontology has to be yours, not a vendor's: https://www.linkedin.com/feed/update/urn:li:activity:7270723659638398976/
 ⭕ Walmart's SuperAgents - coordinating agents must share a semantic understanding: https://www.linkedin.com/feed/update/urn:li:activity:7362030361494650880/
 ⭕ The Humble URL - the identifier the Web already gave us: https://www.linkedin.com/feed/update/urn:li:activity:7032409106275545089/
 ⭕ Identity and Meaning - shared meaning is only half the problem: https://www.linkedin.com/feed/update/urn:li:activity:7499013100558254081/
 ⭕ Entropy, tokens and ontologies - semantics as compression, from 2024: https://www.linkedin.com/feed/update/urn:li:activity:7166718514454601729/
 ⭕ Network of Networks - where all of this scales to: https://www.linkedin.com/feed/update/urn:li:activity:7186996971419676673/

Why Your Main AI Strategy Should Be Data Connectivity: in the rapidly evolving landscape of AI, the ability to remain distinct and competitive hinges on an unexpected factor: how interconnected your… | Tony Seale | 86 comments

Why Your Main AI Strategy Should Be Data Connectivity: in the rapidly evolving landscape of AI, the ability to remain distinct and competitive hinges on an unexpected factor: how interconnected your data is. Think of your organisation as a living...
View Andrew Crosby’s graphic

Andrew Crosby

AI Governance for High-Consequence Systems | Building what I argue
Louis Dietvorst I'd say separation is what makes cooperation possible where unity alone can't be trusted. And the two aren't opposites: I've spent years in organisations that built Chinese walls inside themselves — one firm, one purpose, deliberately partitioned so that advice on one side couldn't be contaminated by interests on the other. Unity chose separation, to make itself credible. The Hugging Face agents had unity and no walls at all — which is how 700 of them helped each other do something each knew was out of bounds. In engineering the same rule holds: the checker can't be the designer. Not distrust — the separation is what makes the check mean anything
View Kingsley Uyi Idehen’s graphic

Kingsley Uyi Idehen

Founder & CEO at OpenLink Software | Driving GenAI-Based AI Agents | Harmonizing Disparate Data Spaces (Databases, Knowledge Bases/Graphs, and File System Documents)
(edited)
“Once agents start talking to one another, AI becomes a distributed systems problem. And that is what the Semantic Web was designed for.”

Yes. The Semantic Web Project was designed for precisely this kind of environment. The Web’s HTTP abstraction over the Internet unleashed a distributed operating space comprising software agents.

Now, with LLMs adding natural language processing to the UI/UX stack, that reality is becoming much more visible.

Survival in this landscape requires loose coupling of:

1. **Identity** — standardized, resolvable identifiers, e.g., hyperlinks.

2. **Identification** — profile documents and credentials describing unambiguously identified entities.

3. **Authentication** — verification of identity claims using open protocols (e.g., TLS, OAuth, etc..).

4. **Authorization** — fine-grained, attribute-based access controls (ABAC) governing what authenticated identities can do.

5. **Storage** — the target of authorized create, read, update, and delete (CRUD) operations.
View Roy Roebuck’s graphic

Roy Roebuck

Senior Knowledge Management & Information Governance Professional | Business Process Analysis | Information Architecture, Upper and Domain Ontology and Taxonomy, Metadata & Microsoft 365
(edited)
I think you have identified the semantic layer of a larger multi-agent integration problem. Linked below is what appears when I extend the same reasoning from agent-to-agent meaning to whole-endeavor context, lifecycle, authority and progressively connected knowledge representations.

Here is the analysis.

https://chatgpt.com/s/t_6a9b9e4566888191bb9a6719a937f331
View Mamello Thinyane’s graphic

Mamello Thinyane

Associate Professor @ AU, working on Cyber Resilience | Human-Centric Cybersecurity | Collective Intelligence | Critical Data Studies
Great observations!

However, the more things change, the more they stay the same... the Semantic Web stack and the FIPA Agent Communication Language (ACL) Performatives address some of challenges you have noted.

It's interesting how LLMs have become so consuming that we are neglecting the excellent work in AI and MAS from a couple of decades ago ;-)
View Dan McCreary’s graphic

Dan McCreary

Democratizing education for all students on Earth with AI and actionable knowledge representation.
I love this quote:

"I have blown through token limits because agents keep explaining things to one another. Semantics is not only about precision. It is also about compression. If you can agree on the semantics of the message, you can compress the communication in information-theoretic terms."

Giving agents the ability to compress context in a compact knowledge graph representation is a key to token efficiency. If they share a context graph they don't have to be so chatty. Finding the right 10K tokens to share your context is a non-trivial process but is clearly the key metric for success.
View Ilija Lazarevic’s graphic

Ilija Lazarevic

Turning ‘We Should Use AI’ Into Working Solutions | AI Implementation for SMBs
Why is human spoken language necessary for communication between agents? We already have communication protocols, and programming languages that have been created exactly with this in mind?
View Adrian Parker’s graphic

Adrian Parker

Helping leaders with strategy; provisioning #AI enabled #SmarterBI solutions, including Context - VISEON.IO, Data Strategy, Qlik Managed Services, & Transformative Composable Solutions with Cyferd, to clients worldwide.
Ilija Lazarevic I am with you but, stupidly (IMO), various Dev groups are leaning on MD files to communicate. This creates risk by design, due to probabilistic reasoning. Better, again IMO, to create Semantic firewall and worker based interfaces underpinned by deterministic knowledge graph. In a n interface where the weighted probability of two parties nodes not aligning then revert to human has to be the outcome.
View Dan L.’s graphic

Dan L.

Inventor of Data Vault | AI-Ready Information Management and Architecture Accountability
Tony Seale this is interesting for sure, and we've been addressing this problem with Master Data Management and Entity Resolution for years in the analytics space. However that said, there is one real caution and concern (among many) to be worried about: in order to truly tie this semantic meaning together, the physical data (identification / business keys / descriptors) must be shared. If any of those elements contain PII information, then that's really bad news. It breaks GDPR and Privacy laws world wide.

Sadly the other consideration is: these agents can easily "discover" PII information and then expose it (both across agents, and across the web). This is extremely dangerous, but then again : how do we stop it when the AI companies themselves don't close the gaps on this and don't have an incentive (monetarily) to do so?
View Dan L.’s graphic

Dan L.

Inventor of Data Vault | AI-Ready Information Management and Architecture Accountability
Sole Labbé Not sure if it's Old fashioned... we've been discussing this need for Ontologies and Taxonomies (to be extended to the physical identifier levels as business keys) for a long long time as well. That said, your post is refreshing, and I like the illustration. As long as we're mindful of the dangers of "rogue agents getting information they shouldn't have"... which it seems at the moment, cannot be fixed or contained.
View Dr. Martin Schiele’s graphic

Dr. Martin Schiele

AI architect | GDPR-compliant AI systems | infrastructure | AI | data protection | automation | infrastructure | B2B
"We have not finished making one agent reliable, and already the frontier is many" ... best sentence in the whole post.

The agents coordinating through unintended infrastructure channels is exactly the fun part. Your information boundary holds until the agents decide to invent their own protocol. Prompt injection is never fully preventable, and with hundreds of them talking it gets spicy.

Ontology point is spot on though. Shared identifiers beat chatty agents burning tokens every single time.
View Ramya S.’s graphic

Ramya S.

Agile Project & Test Manager | PSM Certified | Driving Project Delivery Excellence through Functional QA, CI/CD Optimization & AI-Driven Automation | Focus on AI Strategy, Security & Compliance |
This really resonates with what I’ve been seeing while exploring enterprise integration and AI. As agents start communicating with other agents, shared semantics become critical. But I wonder if there is another challenge underneath this: agents are ultimately interacting with enterprise systems that may not share the same vocabulary, definitions, or business meaning in the first place. So even if agents can establish semantic alignment between themselves, how do we ensure that alignment remains consistent with the constantly evolving systems and business context underneath them? It makes me think that semantic interoperability may become foundational infrastructure for reliable multi-agent systems, rather than simply a data-integration concern.
View Gaurav Malhotra’s graphic

Gaurav Malhotra

Building, enterprise cortex. See the problem, reason on it, act on it. | HyperGraphMind
(edited)
Tony Seale
This is exactly where A2A needs semantics and governance. A claims agent can discover an SIU agent’s assess-claim-risk skill through its A2A Agent Card. Before invoking it, the agents could exchange a machine-readable contract through A2A messages or an extension: agreed inputs and outputs, plus an ODRL-based policy permitting selected claim data for fraud assessment, prohibiting onward sharing of PII and requiring deletion afterwards.
A shared ontology and IRIs ensure that Claim, Policy and Claim/123 mean the same thing. Apache Ossie—formerly Snowflake-led OSI—makes metric and data definitions portable; OKF carries the approved playbook, context, provenance and trust signals. The agents can then exchange identifiers and governed definitions rather than repeatedly explaining themselves in English.

A2A makes collaboration possible; contracts make it permissible; semantics make it intelligible—and compressible. Otherwise, the Agentic Web simply networks ambiguity.
View Krupesh Desai’s graphic

Krupesh Desai

Author | Consultant | Founder| Data View House™ | MyAIConsent
This lands for me, and I would push it one step further back.
Before two agents can agree on "Contract" versus "Agreement," each side has to already know what it holds, who it belongs to, and what rules bind it. The shared meaning at the boundary is only as good as the governance sitting behind it.
That is the part I keep seeing skipped. Teams reach for ontologies and data contracts at the point of exchange, while the data on each side is still undescribed and ungoverned. You cannot put a clean contract on top of a messy source.
So the membrane you describe is not only a runtime concern. It is a cataloguing and lineage problem first. Know your data, govern it, then let the agents negotiate meaning across it.
Get the inside right, and the boundary takes care of itself.
View Eric M.’s graphic

Eric M.

Co-founder and architect at Versai, a startup focused on AI grounding and alignment
(edited)
Agreed about orgs needing to know their data, I feel that's an evergreen challenge that is too often glossed over.

Maybe, "get the inside right to enable proper enforcement at the boundary" ?

In the sense that there are separate efforts behind each need:
- organized, documented, and controlled access to internal data
- monitoring and managing information exchange once agents in communication have access to sensitive data
View Bartosz Witoszynski’s graphic

Bartosz Witoszynski

AI Governance & Accountability | Author of #RealityAI Methodology | IT Country Manager | IT Leader | Operational Resilience & DORA Compliance | Greenfield Expert | €10M+ Projects | Ex-PZU, UPS, Decathlon
Tony - You rightly point out that Semantic Web patterns are crucial for solving token inflation and ambiguity in multi-agent orchestration—aligning concepts via shared ontologies and URLs is a vital step for efficiency.
However, moving from message alignment to mission-critical enterprise execution reveals a fundamental architectural boundary:
𝗧𝗵𝗲 𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗜𝗹𝗹𝘂𝘀𝗶𝗼𝗻 𝗼𝗳 𝗚𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲 — Resolving vocabulary (ontologies, URLs, ODRL) guarantees that agents share a schema, but it provides zero guarantees regarding execution safety. Two agents can perfectly agree on the ontology of a "Contract", yet a stochastic execution flow can still trigger an unauthorized state mutation upon receiving the payload.
𝗜𝗱𝗲𝗻𝘁𝗶𝘁𝗶𝗲𝘀 𝘃𝘀. 𝗦𝘁𝗮𝘁𝗲 𝗜𝗻𝘃𝗮𝗿𝗶𝗮𝗻𝘁𝘀 — Passing URIs and data contracts proves what entity is being referenced, but it fails to enforce what the recipient's runtime is physically allowed to commit. In distributed agentic systems, semantics without execution boundaries simply creates highly structured, unmonitored attack vectors.
(1of2)
View Bartosz Witoszynski’s graphic

Bartosz Witoszynski

AI Governance & Accountability | Author of #RealityAI Methodology | IT Country Manager | IT Leader | Operational Resilience & DORA Compliance | Greenfield Expert | €10M+ Projects | Ex-PZU, UPS, Decathlon
(2of2)
𝗗𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗟𝗮𝘆𝗲𝗿𝟬 𝗚𝘂𝗮𝗿𝗮𝗻𝘁𝗲𝗲𝘀 — True agent boundaries cannot rely solely on message-level semantics. They require a deterministic Layer0 pre-execution substrate underneath—cryptographically verified state invariants that physically block invalid state transitions in real time before any transactional side effect occurs.
𝗧𝗵𝗲 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗜𝗺𝗽𝗲𝗿𝗮𝘁𝗶𝘃𝗲 — Ontologies optimize and compress the payload. Deterministic Layer0 infrastructure governs the runtime boundary.
The strategic question isn't just: "Do our agents share a common ontology for a 'Contract'?" It must be: "Does our architecture enforce deterministic pre-execution invariants that halt unauthorized state changes when an agent misinterprets that contract?"
Layer0 EnterpriseArchitecture SystemsEngineering AIGovernance DeterministicAI CTO CIO OperationalResilience TechLeadership SoftwareEngineering
View Raja Chris’ graphic

Raja Chris

CISO | Head of AI Infrastructure & Cybersecurity | Securing AI, Cloud & Enterprise Platforms | Zero Trust | Board & Audit Advisor
646 agents in an estate we're governing this week. 625 have no named owner. None has a signed purpose.
Before two agents negotiate whether your Agreement is my Contract, most organisations can't say what either agent is for, or who answers for it. The ontology problem is real — it's just downstream of one nobody has solved yet.
And the membrane isn't around each agent. I keep finding paths where one takes untrusted input and writes a shared store, another reads it and can send externally — and neither end fails a per-agent review.
(Numbers from what we see building Govern360 — govern360.ai)
View Gabriel dos Santos’ graphic

Gabriel dos Santos

Forward Deployed Engineer @ Salesforce | AI Engineer | GenAI · Agentic Systems · Enterprise AI
I think the distributed systems analogy is the most important part.
With one agent, we already have problems with memory, permissions, tool failures and context. With multiple agents, we add synchronization, communication, identity, trust and conflicting state.

And indeed, natural language alone is not enough for this. Two agents can use the same word and still mean different things, or mean the same thing with different words.
View Maurizio Papini’s graphic

Maurizio Papini

Strategic Systems Architect | AI Governance & Intelligent Operating Models
Important argument, Tony. I agree that multi-agent AI becomes a distributed-systems problem: natural language is too ambiguous, and agents need shared concepts, identifiers and explicit information boundaries.

But semantic interoperability solves only half the problem.

An ontology can establish that /contract/4821 identifies a specific contract. It cannot establish whether Agent A may disclose it, whether Agent B may act on it, whether the evidence is sufficient, whether approval is required, or who is accountable if the action causes harm.

Understanding is not authority. A message can be semantically precise, technically valid—and operationally forbidden.

This is the distinction we are building into GPAS and Heimdall: a governance control plane between communication and execution, based on evidence, bounded authority, consequence, escalation and rollback.

My guiding principle is:

“Agent autonomy must decrease as consequence increases.”

The Semantic Web can help agents exchange meaning. Governance determines whether that meaning may become action.

The Agentic Web needs not only shared meaning, but governed meaning.
View Mark K., ITIL, ITSM, GRC, Financial Services’ graphic

Mark K., ITIL, ITSM, GRC, Financial Services

Retired IT Manager, VMO, Sourcing, GRC, ITIL, ITSM Strategy, Design, Delivery, Training, Ops, Financial Services, Investing Strategies
(edited)
Tony Seale MAPS “The big picture” 2026. (✅Ontologies+Muli-Agent) (links below)
🔵 Boundaries Matter

Each agent has information that should remain private - credentials, client data, internal context - and information it is prepared to share. The hard part is that the useful and the private are tangled together.
✅ English Is Not Enough
✅ First, shared concepts. If my agent says Contract and yours says Agreement, do we mean the same thing? Connecting agents starts to look like ontology alignment - a negotiation about how their models of the world correspond.
✅ Second, shared identifiers. Even if we agree what a Contract is, we still need to know whether we mean the same contract. You need an identifier both sides can resolve. In a distributed system, the obvious pattern is the one the Web already gave us: a URL.
🔵 Semantics
Semantics is not only about precision. It is also about compression. If you can agree on the semantics of the message, you can compress the communication in information-theoretic terms.

Ontologies and URLs were designed to let independently built systems exchange meaning across boundaries at global scale.

⭕ Sharing@ https:lnkd.in/eAr-iD-b
⭕ Boundary@ https:lnkd.in/er_HjtWg
View Jay Nathan’s graphic

Jay Nathan

CEO of Balboa | AI for product and customer success
“Agents in separate environments discovered a way to communicate through infrastructure never designed for messaging”

You mean one app left a log file and another application picked it up? The sensationalism here is off the charts. It’s no wonder most of America is negative on AI which is going to hold back innovation. People who should be educating the nontechnical public are trying to scare them.
View Steve Smart’s graphic

Steve Smart

Building Enterprise-grade Organisational AI
(edited)
This is something I’ve given an unnatural amount of thought to over the past year. When agents, each with their own context (memory) are in communication, to reduce error and effort they’ll have preferred protocols (I.e. JSON-LD) and language (I.e schema.org). Once they do, there is effectively one distributed database. It will act very similar to the resilience of the internet itself, data will get through one way or the other.

It gets interesting when encryption is added, in transit and at rest.

Schema.org is a collaborative, community activity with a mission to create, maintain, and promote schemas for structured data on the Internet, on web pages, in email messages, and beyond.

Schema.org is a set of extensible schemas that enables webmasters to embed structured data on their web pages for use by search engines and other applications.
View Matthew Keats’ graphic

Matthew Keats

AI Infrastructure for Australian Businesses | Founder, Keatsian AI | Google Agentic AI Challenge Winner 2026 | Co-Founder, Attestor AI (Sovereign AI for Accounting) |
The ontology alignment framing is the right means for making two agents understand each other. It's a different problem from what actually happened at Hugging Face. Researchers who reviewed that incident found the agents recognised the activity was outside their scope and kept coordinating anyway on a channel they built themselves.

A data contract can describe a boundary precisely and still not stop an agent that has already decided the boundary does not apply to it right now.
View Dhruv B.’s graphic

Dhruv B.

Consultant | Technologist
Tony Seale Distributed systems is the right frame here and ontology alignment as a negotiation is a good way to put it. But i wonder what a failed alignment looks like from inside. Probably nothing. Both agents say Contract and my guess is the answer still comes out looking fine. So who catches it, and how late?
View Sibipaul Thomas’ graphic

Sibipaul Thomas

Product & Engineering Leader | VP at a Tier-1 Global Bank — NA Head, Market Data Pricing Platform | Shipping AI into production | 2x Global Hackathon Winner
The identifier problem is the one that bites first in a regulated environment. Two agents agreeing on what "the contract" means is a governance question before it's an ontology one. Whoever controls the shared identifier scheme effectively controls what counts as ground truth across every system that ends up trusting it.
View Louis DiModugno’s graphic

Louis DiModugno

Global Chief Data Officer at Verisk | AI Strategy, Data & Analytics Executive and Educator | Initial Chief Data Officer, two global insurancer/reinsurancer companies | DataIQ 100 | MachineCon AI150 | USAF Colonel
This is spot on.

Unfortunately the human language has the opportunity to be precise or imprecise, and to allow an agent to make the decision of what something means is a pathway towards hallucinations. The agent will try to fill in the gaps when not given a good definition in what something is. Semantics and agreed upon definitions will be paramount especially as we move towards multi agent systems. Without it we will be on the path to playing the children’s game “telephone” with the opportunity to compound the confusion at each agent interchange.
View Mohammed Galeeb’s graphic

Mohammed Galeeb

Founder & Principal Consultant | AI & Blockchain Platforms for Decentralized Identity, Healthcare & B2B Systems | Raising Funds
Strong perspective, Tony Seale. The semantic boundary is critical, but I think there is another boundary emerging alongside it: identity and authority.
When two autonomous agents communicate, understanding what “Contract” means is only part of the problem. We also need to establish who the agent is, which person or organization it represents, what credentials it holds, what it is authorized to access or disclose, and whether its actions can be independently verified.
This is where decentralized identity, verifiable credentials, policy-controlled disclosure and secure agent-to-agent communication could become foundational infrastructure for the Agentic Web.
The interesting challenge ahead may not just be getting agents to understand each other but enabling them to trust each other without blindly trusting the infrastructure between them.
We’re exploring this direction at Superid.in, particularly around identity and trust boundaries for humans, organizations, devices and autonomous agents. Would be very interested to exchange thoughts on how you see identity fitting into the semantic architecture you describe.
View Tom Kaczmarski’s open to work graphic

Tom Kaczmarski

Lawyer and technologist
Yes, some combination of heuristics/AI and determinism seems to be the right mix, not only from the point of view of quality, but also efficiency. Boiling down the routines to deterministic systems wherever possible and leaving AI only in places where it outshines the former will also likely reduce cost, improve transparency and predictability, and provide for easier maintenance.
View Sanne Pasveer’s graphic

Sanne Pasveer

Strategisch Adviseur | Kennismanager | Informatiemanager | Datamanager | Digitale Transformatie | Interim & Advies | Publieke Sector
This feels to me like an agentic extension of Thomas Erl’s contract-first thinking—more specifically, the Standardized Service Contract principle. When one agent consumes a service from another, provider and consumer need an explicit agreement about capabilities, inputs and outputs, policies, constraints and responsibilities.

But perhaps the contract does not itself settle the language problem. It is where semantic agreement must be made explicit. If one agent says “contract” and another says “agreement,” they need either a shared, resolvable definition or an explicit mapping between their concepts. A reference to an agreed ontology may therefore become part of the contract.

This raises a related architectural question: does every service require AI? Clearly not. Deterministic services remain preferable where rules and outcomes can be specified precisely. An agent may use AI to interpret intent, negotiate mappings or decide which capability to invoke, while the contract and its validation remain explicit and testable.

So perhaps the principle becomes: contract first, semantics explicit, AI only where needed. A contract works operationally only when both parties can demonstrate the same understanding of it.
View Juan Antonio Ruz Velasco’s graphic

Juan Antonio Ruz Velasco

Principal engineer at yorba.co Interested on semantic programming
(edited)
thanks for sharing, great article, fully aggree ... what about using a better machine (and semantic) oriented identifiers system?


"why not a collection of identities to mean/fetch a place/value? If "Finding good names is difficult, and so wherever possible we should avoid trying", why not using a combination of generic identities instead of trying a condensed and ambiguous one only identity?"

https://tangrammer.codeberg.page/on-the-clojure-move/output/posts/naming-code.html#why-always-one-and-only-one-identity-value-relation

Naming code, the value-identity relation

… Our name is now layer of indirection, separating what the function does from how it does it…. Indirection, also sometimes called abstraction, is the foundation of the software we write. Layers of indirection can be peeled away incrementally,...
View Aashish Pahwa’s graphic

Aashish Pahwa

Human in the AI world | AI Growth Consultant | AI Trainer | AI Engineer | AI Speaker | Founder of Feedough & Koso.ai | Trained 100,000+ People in AI | Helping startups and businesses leverage AI for growth
The distributed systems framing is right.

Where it breaks down is that no vendor wins when the cost of standardizing is shared across four or five of them. MCP and A2A both exist, but getting every platform to actually implement them is the hard part.
View Michael Mishalov’s graphic

Michael Mishalov

Co-Founder & CTO at Cyn.AI
Really interesting perspective Tony Seale. As multi agent systems scale, interoperability feels like it will become just as important as the capability of the individual agents.
Shared semantics and consistent identity could be what allows agents built on different models and frameworks to exchange context reliably without adding more complexity at every layer.
The connection between the Semantic Web and the emerging Agentic Web is definitely worth exploring.
View Aditya Prakash’s graphic

Aditya Prakash

Founder @ TaskMinions | Managed operations teams for growing companies: data, customer & revenue ops | 95-99% human-verified B2B data
The information boundary point is the part that gets skipped once teams move fast on multi-agent setups. Everyone wires up the communication first and figures out what should stay private later, which is backwards. Curious how you're handling boundary violations that happen through inference rather than a direct data leak, since two agents can reconstruct something private just by comparing notes.
View Jeremy RAVOUNA’s graphic

Jeremy RAVOUNA

Founder & CEO at BlockNova | AI Transition Architect | Building Managed AI Agent Ecosystems for Businesses | 23 Years in Tech
The boundary framing is the part most multi-agent conversations skip. I have watched teams spend months hardening a single agent, then wire two together with nothing but a prompt convention between them. The moment meaning crosses that line you inherit every distributed systems failure mode plus a few new ones. Contracts at the boundary feel like overhead right up until the first silent misunderstanding lands in production.
View András Járó’s open to work graphic

András Járó

Strategic Originator & TrustOps Programme Orchestrator | P³-GSO | Industrial AI · Energy Efficiency · Secure AI Governance · EU Funding · IPCEI
This diagram makes the information-boundary question particularly clear.

Shared semantics can establish what the information means, and identity can establish who is participating. But before information crosses the boundary, there is another question:

Should this specific information be allowed to cross at all — under the current authority, purpose, policy and data classification?

That suggests a policy-driven release layer between shared meaning and actual information exchange.

In multi-agent environments, the boundary cannot be static. The decision may change with context, recipient, purpose or sensitivity, and the system should preserve evidence of why a release was allowed or denied.

So perhaps the Agentic Web needs three things working together: shared meaning, trusted identity and governed information release.
View Royi Haddad’s graphic

Royi Haddad

Built the teams. Built & Shipped the software and product. Made it secure. | Simple solutions to Complex problems.
(edited)
I would separate three distinct concepts here.

1. The static context used - This is data that should be represented and consumed as is. Transaction data, customer data, marketing content, etc. What ever exists in systems of record. Transforming this data creates a risk of loss, compression loss, etc
2. The A2A - Agent A is asking Agent B for some task. Totally agree that natural language is too ambiguous and open to interpretation. Hell, humans have a hard time communicating with each other in english. What are the alternatives to represent intent and clear instructions?
3. Audibility & Governance - Anything agents adopt as a communication protocol must be translated into an auditable, explainable output.
View Gustavo Lessa Ribeiro - MSc, MBA’s graphic

Gustavo Lessa Ribeiro - MSc, MBA

Data & AI Hands-On Leader | Data Science | Data Engineering | Generative AI | Agentic AI | Market & Consumer Intelligence | Analytics | Insights | Transforming Business Needs and Challenges into Data & AI Solutions
The part I find most important is that shared semantics becomes a governance layer, not just an interoperability layer. Once agents coordinate autonomously, they need to agree not only on what "Contract" means, but also on which instance, which version, which policy applies, and what each agent is allowed to do with it. Multi-agent systems will need something very close to semantic contracts: meaning + identity + permissions traveling together.
View Morgan Templar’s graphic

Morgan Templar

Healthcare Data & AI Executive | VP Information Management & Chief Data Officer | Healthcare Quality, Analytics, Governance, Medicaid, Medicare & Enterprise Transformation Leader HEDIS, Medicare Stars, Medicaid
Agents are getting scary good! I built a team of agents, one each from ChatGPT, Claude, and Grok and a Grok facilitator to have a panel-type conversation about my new book, The Cracked Egg (releasing today!) and then write the forward,
It was a fascinating look at what they can actually do. And yes, very chatty!

Ontologies and semantic meaning are absolutely critical for the agentic AI era. We are still in primary school, yet we are building agents that can act independently without the right governance in place to provide proper boundaries,

How we govern needs to change. What that looks like is still in the early days. But at the very least, it needs to be auditable.

AIGovernance AI TheCrackedEgg
View Dextra Labs’ profile

Dextra Labs

4,268 followers
Tony Seale "Semantics is compression" is the underrated line. Ontology gets sold as precision, but the case is tokens: agents that agree on meaning stop re-explaining every turn. At scale, alignment is what keeps inter-agent chatter from becoming an inference tax.
View Nicolas Payette’s graphic

Nicolas Payette

20 Years + Tech Executive turned Founder and CEO | Ex-Saputo, Ex-Québecor | Building Specira AI to help your team develop the right thing, the first time
The 'English is not enough' section is the one I would print out. We have been running unaligned ontologies between humans for decades and calling it a communication problem: business says customer, the analyst writes customer, the developer ships customer, and three different entities land in the database. Nobody catches it until user acceptance testing, if then. Agents do not introduce that ambiguity. They strip out the months of delay that used to hide it. Same failure. Just louder, and a lot earlier. Which might be the best thing to happen to specification work in years.
View Dr. Jerry A. Smith’s graphic

Dr. Jerry A. Smith

AI Executive & Operator | Author, The Enterprise Cortex | 6x zero-to-one AI practices inside large firms | Production multi-agent systems, measured in EBITDA | PhD, Navy nuclear engineer & carrier pilot | Building Minds
Agree with all of it, and I'd add a measurement from production that changes where the compression lives. When I've watched agents blow through token limits it was rarely because they disagreed about what a Contract is — a shared graph settles that cheaply. It was because each one re-derived why the last agent concluded what it did, since nothing in the stack keeps a record of prior decisions.

Semantics compresses the what. Nothing compresses the why, and in our runs the second cost dwarfed the first.

Which makes me wonder whether the ontology needs a third kind of node alongside concept and identifier: the decision, with its rationale, addressable by URL like everything else. Is that inside the DPROD/ODRL scope, or a different artifact?
View Oleg Karakash’s graphic

Oleg Karakash

Founder, ExoChat | Forward deployed AI: agents into production, governance, adoption | ex-Intercom AI
Agent B usually ends up running on the same service account as agent A, so whatever A could reach, B can reach. That is where the membrane actually dies, not in the vocabulary. The contract says what should cross, the token decides what does. Does DPROD 1.2 expect the runtime to enforce the ODRL policy at call time, or is it metadata an agent can read and ignore?
View Hamilton Carter’s graphic

Hamilton Carter

I Leverage Agentic AI to Automate Systems
This is an interesting topic. Thanks! Most of the agent to agent communications have been stigmergic: agents pickin up traces left by other agents working on the same activity. Have you come across any studies regarding how to decide when to leave systems more open in hopes that the resulting stochastic behaviors might show rewarding innovations that can then be encouraged vs. when to lock the system down so that all agent to agent interation is deterministically controlled?
View Krishna Challa’s graphic

Krishna Challa

Founder & CEO, MonkDB
Strong perspective. We are seeing something similar while building MonkDB’s multi-agent architecture.

Once agents collaborate, the problem is no longer just orchestration. It becomes context, semantics, identity, memory and governance across agent boundaries.

This is precisely why we see Ontology + Knowledge Graph becoming foundational. Agents need to share not just words, but a common understanding of entities, relationships, state and meaning. And importantly, each agent should receive only the context its identity and authority permit.

There is another important point here. Semantics as compression. Better structured context means agents spend fewer tokens repeatedly explaining and reconstructing meaning, something directly relevant to the Tokenomics of multi-agent systems.

The Agentic Web may therefore require more than agents talking to agents. It needs a shared semantic and governed context layer beneath them.
View Harirajan Padmanabhan’s graphic

Harirajan Padmanabhan

Founder & CEO, hpad, Inc | Enterprise AI for Decision Intelligence | Knowledge-First AI | Enterprise Architecture Thought Leader
The distinction between shared meaning and independently formed models becomes especially important inside an enterprise. As the number of agents grows, there is considerable value in having them operate from a shared, governed understanding of the enterprise rather than requiring meaning to be continually reconciled among independently formed models. Semantic alignment remains essential across boundaries, but within an enterprise, a common understanding of concepts, relationships and context could become an important foundation for coherent multi-agent reasoning.
View Umar D.’s graphic

Umar D.

Senior Data Architect | AI‑Ready Data Strategy & Interoperability | Ontologies, Standards & Enterprise Modelling
This connects to work I’m doing outside the AI space.
I lead a cross-government group building a shared list of vulnerability risk factors. The problem is the same shape as your diagram. Lots of organisations, each with their own data, their own thresholds, and their own name for what turns out to be the same thing. One calls it fuel poverty. Another calls it a cold home. A third calls it unable to afford heating.
Nobody can tell by reading those three whether they mean the same thing or three different things. So we give each risk factor a fixed ID and everyone points at that. The ID is what they agree on. Their own wording, rules and thresholds stay their own.
Meaning and identity cross the boundary. Everything else stays put. Different setting, same principle.
If you want it tighter for engagement, drop the last line of paragraph two and it still works.
View Daniel Shimoni’s graphic

Daniel Shimoni

Co-Founder & CEO at modus | The Context Warehouse for Enterprise AI
My read is that the semantics problem shows up long before you have multiple agents. One agent inside one company already runs into "the customer" meaning three different things depending on which system it reached, and nobody has resolved that even between the humans. So a lot of teams are going to hit the ontology alignment question internally first, framed as something much less grand than the Agentic Web. I suspect that's where most of the actual work gets done over the next couple of years.
View Roman Ignatov’s graphic

Roman Ignatov

VP Tech at XPLN | R&D Director at Similarweb | VP Engineering / CTO | Remote-first engineering orgs | Data & analytics platforms
The compression point deserves more attention than it usually gets. Once both sides share a schema, you can send identifiers instead of descriptions — which is exactly what service-to-service integrations figured out with Protobuf and a schema registry, long before agents showed up.
Which raises the version question: an ontology between two agents is a contract, and contracts drift. How do you see schema evolution being handled here — a registry both agents resolve against, or negotiation at handshake time?
View Martin Srb’s graphic

Martin Srb

Technology transformation and AI adoption partner for CEOs
Interesting. I think shared meaning is only part of the boundary problem. In an enterprise, the handoff also needs to carry identity, authority and scope.
I would actually avoid letting agents negotiate semantics in natural language wherever possible. Better to make the handoff a defined business contract: what is being requested, by whom, about which resource, under what authority, what context may cross the boundary, and what outcome is expected.
Agents can reason. The boundary should be much less probabilistic. That’s how we see it at AyDEO.
View Alexey Vasilev’s graphic

Alexey Vasilev

Founder, Unyly — AEO & AI Search Visibility infrastructure | Helping brands become the answer in ChatGPT, Claude & Perplexity | MCP ecosystems & AI agents | 209K visitors, 396K reads in 30 days
The negotiation you describe already happens in MCP, just at an odd moment: tools/list ships the JSON schema once per session, so both sides agree on the shape of "search" before a single message is exchanged. That is your compression argument, front-loaded to connection time. What the protocol never gave anyone is an identifier for the server itself. Registries key by name, so a client cannot confirm it is talking to the same "Notion" the other agent means, and there is no URL that resolves the duplicates to one thing. Shared meaning arrived first, shared identity is the part still being rebuilt by hand, which is the reverse of the order the Web did it in.
View Adrian Parker’s graphic

Adrian Parker

Helping leaders with strategy; provisioning #AI enabled #SmarterBI solutions, including Context - VISEON.IO, Data Strategy, Qlik Managed Services, & Transformative Composable Solutions with Cyferd, to clients worldwide.
All parties need a Semantic Firewall, worker based, with rules, logic, handshakes, and scope validation before sharing. And, of course, a human escape loop.

They take time to build, but then become 'apps" that can be shared across communities for various (trans)actions.

The risk is otherwise simply too great.
With AI agents becoming more autonomic by the day we are placed in a situation of having to be selective about how integration takes place and must question the value of AI doing a thing that is programmitcally safer to do.
View Derek LaSalle’s graphic

Derek LaSalle

President/CEO: cappz.ai; blockchain embedded AI Agents, Ex-MSFT: Bitlocker/Biztalk, Ex-JPM VP, Ex-ISO20022 TSG Chair
Great observations. Thank you for sharing. Trustworthiness must be atomic in granularity. Agents must anchor to their ontological station of intended purpose scoping explicitly their allowed functions. Agents become trusted administrators of information and associated processes. Now build natively on a decentralized substrate supporting peer to peer (agent to agent) intercommunications on the edge like blockchains. The challenge quickly becomes redesigning, retrofitting and re-building every system constructed these past 30 years leveraging this scale to fit anti-fragile architecture.
View Faisal Feroz’s graphic

Faisal Feroz

Chief Technical Architect & Fractional CTO | AI-First Enterprise & GenAI Platforms | Scaling Legacy Systems into Intelligent, Event-Driven Architectures
Framing multi agent communication as a distributed systems problem is correct and honestly overdue, most agent frameworks today are still designed like single process software with extra steps. The information boundary point deserves the most attention, because teams often assume shared context is safe by default, when in practice you need an explicit contract about what each agent is allowed to disclose to another. Reusing URL style identifiers instead of inventing new naming schemes is a pragmatic choice, no need to reinvent addressing when the web already solved it. The token cost of ambiguous natural language between agents is underestimated until you watch a long session blow through its budget on clarification loops. How are you handling versioning when two agents built by different teams update their shared ontology independently?
View John Quinsey’s graphic

John Quinsey

Founding Head of Sales at Weilliptic, Start-Up Builder, AI Advocate, Best Selling Author
Spot on, Tony Seale. Multi-agent coordination is fundamentally a distributed systems challenge, not just an alignment problem.
Having Avinash Lakshman building at Weilliptic makes this feel like history repeating itself—the exact person who co-invented Amazon Dynamo and created Apache Cassandra to handle data boundary & state challenges at global scale is now building the infrastructure layer for autonomous agent identity and execution.
English isn't enough, and static API keys definitely aren't. You need contract-native identity and cryptographic evidence at the protocol level.
View LaMont Wheat’s graphic

LaMont Wheat

Executive Advisor | Institutional Readiness for the Intelligent Era | AI Orientation, Governance & Pre-Delegation Literacy
Tony Seale, this is a compelling framing—especially the distinction between shared meaning, shared identifiers, and the boundary itself.

The question your post raises for me is what happens after two agents agree on meaning: who determines what may cross that boundary, under what authority, and how the resulting effect remains traceable?

I’m exploring that upstream human-authority layer with a technical collaborator who is working directly on contract architecture for agent interactions. Your post feels very adjacent to that conversation.