Qualcomm thinks AI agents are ready. But are we ready to trust them?

AI agents have spent the better part of two years being promised as the next big thing in computing. Now, suddenly, they are starting to feel less like a distant concept and more like something users can actually try.

Meta has Muse, its personal AI agent that can browse the web, book appointments, fill forms, and perform tasks across connected services. OpenAI has been expanding its agent infrastructure with Dots, while startups like Instinct AI are putting agents inside familiar interfaces such as WhatsApp and iMessage.

That rapid progress was particularly noticeable during Snapdragon Summit. At the same time as different companies were showing off agents that could increasingly act on a user’s behalf, Qualcomm was making a different but equally important argument: the hardware underneath these agents is finally catching up.

After a closed-door roundtable with Kedar Kondap, Qualcomm’s SVP and GM of Compute & Gaming, I left thinking the biggest question isn’t whether Snapdragon PCs can run AI agents. Increasingly, they can. The more interesting question is what happens when those agents become genuinely useful — and who actually gets to decide what that experience looks like.

Building the brain is only half the job

The easiest way to understand the jump from a chatbot to an agent is to look at what happens after the answer: while a chatbot can tell the user whether a flight is delayed, an agent could monitor the flight, spot a cancellation, check the weather and schedule, find alternatives, and ask for permission before rebooking.

I got a rather practical demonstration of that distinction during Snapdragon Summit, when Hawaii was dealing with Hurricane Nolo and widespread flight disruptions; I had deployed an AI agent to track the situation and alert me, while some of my colleagues went a step further, using agents to help with rebooking flights and checking in. It wasn’t some futuristic Qualcomm demo, but a real-world glimpse of how quickly AI agents are moving from novelty to something people can actually use when there’s a problem to solve.

But there is an important catch: Qualcomm cannot simply decide what that agent looks like

You see, Qualcomm can build the brains — the NPU, CPU, GPU, memory architecture, AI runtimes, and all the developer tools needed to make them sing. It can hand developers reference hardware, APIs, kits, and documentation well before any of this reaches a consumer’s desk. But all that silicon still needs someone to turn it into an experience people actually want to use. Whether an agent lives inside Windows, Android, an OEM’s software, or something as familiar as a messaging app is ultimately up to Microsoft, Google, Qualcomm’s partners, and developers.

That is the slightly awkward reality of the AI PC era. Qualcomm can build the runway. Someone else still has to build the aircraft. And that may explain one of the biggest questions around agentic AI today: how does an ordinary person actually deploy one?

The agent problem isn’t just intelligence. It’s the interface

We’ve become pretty good at the chatbot thing. Open ChatGPT, Gemini, or another assistant, type a question, get an answer, and move on with life. The mental model is almost laughably simple. AI agents, on the other hand, are asking us to throw that simplicity out the window. An agent needs a goal, access to tools, some understanding of context and, crucially, permission to actually do something on the user’s behalf.

And that immediately creates a rather awkward question: how does a normal person actually set one up? During our conversation, a question naturally came up: if someone knows how to open ChatGPT, how do they actually start an AI agent? Kondap’s answer was refreshingly candid:

“I think everybody’s trying to get there. I don’t think there is a simple way of saying, ‘Here’s what the UI and the interface is going to be.’ “

It’s a surprisingly honest admission, and an important one. Making an agent smarter is only part of the puzzle. Someone still has to figure out where it lives, how users activate it, what information it can access, what tools it can use, and, perhaps most importantly, when it should stop and ask for permission. Nobody wants an AI agent with the digital equivalent of a credit card and a severe case of enthusiasm.

Kondap pointed to Google’s demonstrations of Googlebooks as an example of where the experience needs to go: a handful of simple commands from the user, with considerably more complexity happening behind the scenes. “I think we need that level of simplification,” he said. And that is where Qualcomm’s role becomes clearer. It may not control Windows, Android, or the final interface users interact with, but it can make sure the underlying hardware and software platform is ready when developers finally crack that experience.

The real Qualcomm bet is local AI and orchestration

There was some feeling in the room that agentic AI might be moving slower than expected, but Kondap pushed back on that idea. From Qualcomm’s perspective, the infrastructure has actually moved remarkably quickly.

Two years ago, running a 13-billion-parameter model on-device was the benchmark. Today, Kondap points out that developers are running 30- to 35-billion-parameter models on Snapdragon PCs with near-identical accuracy, driven by NPUs delivering between 45 and 85 TOPS. But as models grow more efficient, that muscle isn’t isolated to PCs. Instead, Qualcomm sees this agentic layer expanding seamlessly into phones, wearables, and smart devices.

That matters because an AI agent isn’t exactly a lightweight chatbot with a fancy job title. One instruction could kick off multiple model calls, searches, tool invocations, and decisions, and sending every single step to the cloud isn’t always the smartest way to do things. Latency, privacy, and the cost of repeated inference all start to matter when an agent is expected to work continuously rather than simply answer the occasional question. However, Qualcomm’s answer is not to pretend the cloud disappears. It is to make the device another intelligent part of the equation. Kondap’s preferred word here is orchestration.

“The orchestration is more important.”

And that is where Qualcomm’s approach gets interesting. A phone could handle a lightweight task, a wearable could capture context, a PC could take over when a workload needs more memory or thermal headroom, and the cloud could step in when something demands a much larger reasoning model. The agent effectively becomes the traffic cop, deciding which device and which layer of compute should handle the job. That’s a far more interesting proposition than simply cramming a bigger NPU into a laptop and calling it an AI PC.

Qualcomm is essentially trying to make the entire device ecosystem part of the agent’s toolbox. The company’s demonstrations at Snapdragon Summit showed developers already experimenting with on-device agents, while its platform gives them the hardware and software tools to build those experiences.

There is a practical reason to keep at least some of that intelligence local: private files, personal context, and everyday inference don’t necessarily need to make a round trip to a remote server. In other words, Qualcomm isn’t really arguing for local AI versus cloud AI. It’s arguing for an agent that knows when to use both.

The uncomfortable bit: trust

The more useful an agent becomes, the more it needs to know about the person using it. And that’s where things get a little uncomfortable. A chatbot can happily answer questions without knowing much about its user. A genuinely useful agent, however, could need access to emails, calendars, files, travel plans, and potentially even payment systems. More context makes an agent smarter and more useful, but it also means its mistakes can become a lot more consequential.

Kondap’s comparison for this is surprisingly relatable: online banking. We weren’t always comfortable putting credit card details into a phone or trusting a screen to move money around. Over time, authentication, permissions, and security systems made digital payments feel almost boringly normal. AI agents could go through a similar trust-building exercise, particularly as they graduate from answering questions to actually doing things on our behalf.

“We’re all very comfortable with putting our credit cards in our phones using payment. We all were nervous when it first came in.”

But there is one rather important difference: an AI agent isn’t just processing a transaction. It’s interpreting intent and making decisions along the way. If it misunderstands an instruction, sends the wrong email, books the wrong flight, or makes a purchase it wasn’t supposed to, the obvious question is: who gets the blame? The device maker? The operating-system provider? The AI model developer? The agent developer? Or the user who trusted it in the first place? No amount of NPU horsepower is going to answer that one.

Kondap acknowledges that trust won’t materialise overnight, and he is careful not to pretend Qualcomm has already solved it. His view is that users will become more comfortable as the ecosystem establishes clearer boundaries around what agents can access, what they can do, and when they need permission. Qualcomm can build the processing engine, optimise the models and give developers the tools to run increasingly capable AI locally, but trust isn’t something silicon can ship in the box. It has to be earned by the entire ecosystem.

Qualcomm’s AI agent bet is bigger than the PC

That is ultimately what makes Qualcomm’s approach to agentic AI more interesting than simply putting a faster NPU inside a laptop. The PC could become the local brain in a much larger ecosystem of phones, glasses, wearables, and cloud services, with each device contributing the compute or context it is best suited to provide. Kondap sees every device having a role, with the PC taking on workloads that smaller devices simply cannot handle thermally, while the cloud remains available when something demands even more computing power.

The irony is that the best agentic PC may eventually make the PC itself feel less important. Instead of opening applications, moving between windows and manually piecing together information, the user could simply state an intent and let the system work out the rest. Qualcomm appears to believe the silicon is finally getting ready for that future. Now it needs operating systems, OEMs, developers, and, ultimately, users to decide what happens when the computer stops waiting for instructions and starts taking action.

The PC has spent decades asking users what to do next. The agentic era could finally flip the script, and Qualcomm wants Snapdragon to be ready when it does.