I’ve spent a big part of my career working on the Internet of Things. Long before the term was trendy, I was building systems where devices in the field talked to a central system, and later I co-founded companies built entirely around IoT.
The idea behind IoT has always been simple: connect machines and devices globally, so we can collect their data and coordinate actions. A sensor reports a temperature, a meter reports consumption, a controller receives a command. Scale that to millions of devices and you can run a factory, a building, or an entire city more efficiently.
It works. But it works because everything is defined in advance. Every message has a fixed format, and every device knows exactly what to send and what to expect. That makes IoT reliable and predictable, but also rigid. If a situation wasn’t anticipated when the system was designed, only a human can handle it.
There’s another limitation. In today’s IoT, the intelligence has to be centralized. Devices collect data and send it to a platform in the cloud, where all the analysis and decision-making happens; the devices themselves are just eyes and hands. Every decision has to travel to the center and back, and we lose the potential benefits of distributed intelligence: faster local decisions, systems that keep working when the connection drops, and devices that coordinate directly with their neighbors instead of waiting for someone above to tell them what to do.
The next revolution
I think we’re at the start of a new revolution. The same devices that today just report data can become intelligent: able to understand what’s going on around them and talk to each other, exchanging not just numbers, but intent and context.
I like to call it the Internet of Thinking. (Not to be confused with the “Internet of Thoughts,” a term some researchers use for connecting human brains directly to the cloud. That’s a different story.) Same acronym, very different network: instead of a network of things, a network that thinks.
Here’s what the difference looks like in practice:
- Water network. Today: “Pressure: 2.1 bar.” Tomorrow: “Pressure in my section is dropping in a way that looks like a leak, not higher demand. Upstream valve, can you lower the pressure until a crew checks it?”
- Factory. Today: “Vibration: 7.2 mm/s.” Tomorrow: “The bearing on pump 3 is wearing out. I estimate it’ll fail in about two weeks. Line 2 can take over its load if we move production to Thursday. Maintenance, should we schedule it then?”
- Building energy. Today: “Battery charge: 40%.” Tomorrow: “It’ll be cloudy this afternoon, and electricity gets expensive at 7 p.m. I’ll charge now while it’s cheap. HVAC, can you pre-cool the building before 7 so we use less during peak hours?”
The information is much less structured. Nobody had to define those messages ahead of time; the device on the other end figures out what’s being asked. That’s the big shift.
Why now? Two reasons. AI models are getting small and efficient enough to run on much more modest hardware, closer to the devices themselves. And we’re starting to see protocols designed for AI agents to talk to each other and to tools, like MCP and A2A. The missing layer is finally showing up.
What about everything we’ve already built?
Nobody is going to replace millions of installed devices overnight. And they don’t need to.
A practical path is to add an AI layer at the edge: a smart gateway that speaks “Internet of Thinking” upstream, while downstream it keeps talking to traditional IoT devices in the protocols they already understand, like Modbus, BACnet, or MQTT. The gateway works as a translator. It turns sensor readings into context (“this looks like a leak”), and it turns decisions back into concrete, predictable commands (“close valve 12 to 60%”).
This has two big advantages. First, you keep your entire installed base, which is the only realistic way to migrate. Second, the critical control layer stays deterministic: the “thinking” happens above it, while the part that actually acts on the physical world stays predictable.
The risks
Of course, a network that thinks also brings new ways for things to go wrong. Three I’d keep a close eye on:
- Getting it wrong, with total confidence. What if that “leak” was actually a hospital using more water than usual? AI can misread a situation and act on it without a hint of doubt.
- A compromised device that “convinces” the others. If devices act on each other’s requests, fooling one of them could be enough to move the whole network.
- Accountability. When something goes wrong, can we explain why the system made that decision, and who’s responsible for it?
The good news is that these risks can be managed:
- AI proposes, the deterministic layer disposes. Hard safety limits live in firmware or controllers, and no conversation, however convincing, can override them.
- Verified identity and minimum permissions. Every device has a trusted identity and can only ask for what it’s supposed to ask for.
- Everything gets logged. The “conversations” between devices are recorded, so every decision can be reconstructed. Low-impact actions can be automatic; high-impact ones need human approval.
I’d add one more layer on top: a supervisor agent that coordinates the network and checks every critical action before it happens. Since that supervisor is also AI, it should be independent from the rest (a different model, different rules, different data sources), and it should never be able to bypass the hard limits at the bottom.
So, are we ready?
The Internet of Things taught machines to talk. The Internet of Thinking will teach them to understand each other. The technology is coming either way.
The real question is: are we ready to let our machines think together, and to trust what they decide?
I’d love to hear what you think.
