For years, we’ve seen intelligent software as something behind APIs. You send a request, get a response. The system remains elsewhere, centralized, logged, metered, and observed.

But then, a fundamental shift occurred. It wasn’t just another product launch or platform announcement. A new possibility for intelligent, decentralized interaction appeared.

This shift began when large language models became accessible in the browser. The browser, already peer-to-peer capable, suddenly enabled intelligent agents to communicate directly, a notable change from previous patterns. In real time, at the edge, and without asking a server for permission. That changes the geometry of software.

From request–response to conversation WebRTC was built for people, mainly for voice and video calls. Low-latency, real presence. It assumes immediacy, imperfection, and negotiation. GPT arrived as a text oracle, stateless, deterministic in form but not in outcome.

But if we put them together, the interaction model shifts.

Now you don’t just ask a remote system for an answer. You let systems coordinate, share partial context, and resolve ambiguity on the fly. They hand off tasks to the collective and correct each other mid-sentence.

This isn’t just APIs calling APIs. It’s an entirely new conversation unfolding between intelligent agents.

On paper, it’s elegant, even simplistic. But this new model for distributed intelligence is a promise that demands exploration.

Agents negotiate where the data already lives, with no round-trip to a central brain. This promises lower latency, fewer always-on backends, and software that feels smaller, more local, more alive.

It suggests decentralization, but not the blockchain type, more pragmatic, browser-native, and human.

And that’s exactly where the idea faces real challenges, for now.

Real-time intelligence is not cheap. We (or at least I) tend to underestimate what “real time” actually demands.

Low latency means less margin for correction, fewer retries, and smaller safety nets. When GPTs talk over WebRTC, there are no queues, no graceful degradation, no comforting pause of a request lifecycle.

Every hesitation becomes visible, every misunderstanding propagates instantly.

And intelligence, especially probabilistic intelligence, likes time. It likes reflection. It likes retries and guardrails. Strip those away, and you don’t get faster thinking. You get more brittle thinking.

The cost isn’t just “compute”. It’s cognitive. You’re forcing systems to behave socially before they’re epistemically ready.

Trust moves to the edge, too. In centralized systems, trust is implicit. You control the backend and log everything, auditing afterward.

Peer-to-peer systems don’t offer that luxury.

When agents exchange context directly, trust becomes situational and negotiated. Who can share what? How do you verify intent? What does identity mean when intelligence appears dynamically in a browser tab?

Security models designed for APIs struggle here. Observability fades the moment systems stop reporting home. Debugging becomes forensic, not preventative. You’re no longer just securing code paths. You’re securing conversations.

And conversations are messy.

Debugging shifts from logic to language This might be the most underappreciated change.

When GPTs coordinate via messages, failures look like misunderstandings, misaligned assumptions, or different interpretations of “done.”

Traditional debugging tools don’t help much here. There’s no stack trace for a bad inference, and no breakpoint for a subtle semantic drift. You don’t fix these systems by stepping through code. You solve them by listening.

This is powerful, but uncomfortable. Engineers reason about state, not intent; we learn control flow, not dialogue. Human communication is one of the hardest things, and we are both skilled and flawed at it.

When WebRTC and GPT push software into the same space where design, linguistics, and systems thinking collide, not everyone will enjoy it. It is the brave new frontier of communication.

A promise worth exploring. A reality worth respecting. These are still early days for this comingling of techniques. And we are still taking our first steps into this field, which at this point is more of a barren backyard.

I have just started experimenting with the concept, and I have to say I had a lot of fun doing so. At the moment, it consists mostly of tabs in different browsers talking to each other, and the main hurdle so far has been getting them to connect seamlessly. But once I got that figured out, and I’m still trying to perfect it, something strange and new appeared. When a new tab, device, or unit is added to the mesh, the capabilities of the hive increase. New possibilities are granted, with new models, more computing power, and a new set of sensors.

One device, a single agent, or a single model is often lacking. When they get to organize, they manage to orchestrate themselves into completing larger tasks faster.

Currently, I understand my agents. They are few in number, and their tasks are simple and given to me. They communicate in English and let me see their discussion, intervene, and participate. I am just one agent, a human agent, in a large chat between devices. But that is about to change.

I have started exploring the concept of message condensation, in which messages are dehydrated into their purest essence and then rehydrated into a message with the same core but completely different semantics. The idea is largely about human communication, and a subject for later blog posts, but I will apply the same concept here as well. Making my understanding of the process and the discussion less precise and more esoteric.

Now, why do I do this? The simple answer is, because I can. In reality, this is well beyond my pay grade and cognitive abilities. This is in the realm of science fiction, and to think anything productive could come out of it is naive at best. But still, that has never stopped me before, so I continue my feeble experiments. Not because they are easy, not because they are hard. Because they are fun!

Why this still matters This combination may never become mainstream. It is likely to remain experimental, awkward, difficult to govern at scale, and too niche to provide real value.

And yet, it matters because it questions the foundation of software intelligence.

Because it forces us to question assumptions we’ve quietly baked into modern software. That intelligence must be centralized for safety, and that observability requires control. That faster and larger always means better. And, that “conversations” solely belong to humans.

While a WebRTC meeting with GPT doesn’t solve these tensions, it probably makes them worse; it just relocates them.

It reminds us that architecture is philosophy made executable and that every technical convenience hides a value choice. And that intelligence, once it becomes conversational, stops behaving like infrastructure and starts behaving like culture. Like us.

Some ideas are valuable not because they succeed, but because they unsettle us.

This embodies one of those ideas. It’s not a destination, but a way to feel where the edges of our thinking still are.