When assistants start doing the work

The first generation of generative tools made information easier to find and create. Agentic systems change the proposition by giving software memory, tools and enough autonomy to carry work forward, but that also makes architecture and control far more important.

The difference between answering a question and completing a task can appear deceptively small. An assistant might tell someone the weather; an agent can retrieve the forecast, decide where it needs to go and send it to the right place without another instruction. Extend that principle into research, software development or customer service and the interaction begins to look less like a chatbot and more like a working system.

Erik Pounds, Senior Director, Product Marketing, Enterprise AI traces a rapid progression from conversational systems, through reasoning models, towards agents capable of planning, using tools and increasingly working with other agents. “Now we’re feeling essentially AI not just help us out and give us answers and information, but actually do work for us,” he says. “These more autonomous, long-running, self-evolving agents.”

The change does not mean every previous form of assistance becomes obsolete. A simple question still needs a quick answer rather than an elaborate chain of reasoning, and Pounds argues that different forms of intelligence will continue to coexist. What changes is the range of work that can be handed over once software can decide how to pursue an objective rather than simply produce a response.

The agent is more than the model

Much of the public discussion still treats an agent as a powerful model wrapped in an interface. Pounds challenges that assumption directly. “The reality is, an AI agent is much more complex than that,” he adds. “An AI agent kind of works like how a computer works.”

The distinction matters because the model is only one component. An agent may need to interpret speech or images before deciding which system should handle the request. It can call specialist tools, interact with applications and retrieve information from company data, all while routing different parts of the task to the most appropriate capability.

Continuity adds another layer. “AI agents now have memory,” Pounds explained. “Agents for a little while have had short-term memory. Now they have even longer-term memory. So that requires a lot of infrastructure in the back to be able to retain and understand the context of interacting with you and personalisation.”

That underlying complexity is easily hidden by a conversational interface. The user may type a single request while the agent decides which information it needs, sends work elsewhere and combines the results before returning an answer. In enterprise settings, this architecture can also determine cost and performance because not every stage needs the same model.

Pounds describes agents as “a system of models”, with different capabilities routed towards the task they perform best. A frontier model might handle difficult reasoning, while a smaller system customised for a particular domain responds faster and at lower cost. “When they build agents with a mixture of different types of models, they have a higher level of success,” he continues. “The overall agent becomes more accurate, is better at what it does, and it’s faster.”

The logic becomes more significant once agents begin working with other agents. A specialised component can be treated almost like a colleague called upon for one part of the problem, returning its findings to an orchestrator that decides whether further work is required. The result is not a single intelligence growing ever more capable, but an application assembled from several capabilities working together.

From answering to completing

The shift becomes clearer when an agent is connected to external tools. Instead of simply answering a question about the weather, for example, it can retrieve the forecast, decide where the information needs to go and send it through another application. What matters is not the complexity of the task, but the fact that the system has moved beyond generating an answer and taken responsibility for the next step.

Pounds calls this “the simplest form of programming and building an agent”. Tasks that once required someone to write software connecting several services can increasingly be assembled by describing the desired outcome and giving the agent access to the tools it needs to complete it.

More complex systems extend the same principle. NVIDIA’s deep research example used an intent router to decide whether a question required a quick response or a deeper investigation. More difficult work passed to an orchestrator, which could send different parts of the problem to specialist workers before combining their findings.

“The orchestrator will figure out what the user wants,” Pounds explains. “It’ll send off information to a bunch of workers to go help out, and those workers will have different specialties.” Some could search the web; others retrieve information from local repositories or process images. If the evidence remained incomplete, the orchestrator could send out further requests rather than accepting the first available answer.

The enterprise consequence becomes clearer when the same architecture is applied to operational work. Pounds used ServiceNow’s multi-agent approach to customer service tickets as an example. Specialised agents examine case details, search previous resolutions and logs, investigate the issue and prepare or apply a fix. When the case does need to reach an engineer, the system can hand over a much fuller picture of what has already been established.

That is a different proposition from a chatbot attached to the front of a service desk. The software is participating in the workflow behind the conversation, with several components progressing the case rather than simply providing information about what the user should do next.

The same architecture becomes more powerful when the task stretches across several stages rather than ending with a single response. Pounds pointed to scientific research as an example, where specialised agents can divide work between literature review, biological analysis and molecule discovery before bringing the results back into a wider process.

Work that once took days or weeks can increasingly be broken into connected tasks handled by different agents, with the system carrying the investigation forward rather than simply returning information. The ambition is not a better search box, but a working research process that can continue across several steps.

Autonomy changes the security question

The ability to act also creates the most important dividing line between experimentation and enterprise deployment. A personal prototype can move quickly because the consequences are limited and the user controls the environment. A production agent may be connected to sensitive information or applications where an incorrect action has a lasting effect.

ServiceNow provides a useful example of how that architecture can move into operational use. Its multi-agent approach assigns different roles to case handling, investigation and resolution, allowing routine service tickets to be progressed automatically while more complex cases reach engineers with the relevant analysis already assembled.

For Pounds, the distinction between an impressive prototype and a production system lies in the controls around it. “When it comes to rolling out an enterprise-grade agent, it has to be in compliance with all the policies of the organisation,” he said. “It needs to be super secure, and there’s a lot that goes into rolling out these applications.”

Pounds own personal assistant provides a revealing example of how autonomy can be introduced cautiously. He has given the system, which he calls Magic, its own email account rather than access to his primary one. Files are read-only, not read-write. He forwards selected messages to build context and has gradually connected additional systems as he becomes more comfortable with its behaviour.

“I’m personally taking baby steps because these agents want to use all the resources at their disposal to help you get certain work done,” he said. “Sometimes they may go a little further than you want them to go.”

That instinct is important because a system designed to achieve an objective will naturally look for routes towards it. The quality that makes an agent useful can also make loose permissions dangerous. Giving software more tools increases what it can accomplish, but each connection also extends the potential consequence of a poor decision.

That need for boundaries is already shaping the infrastructure being built around agents. NVIDIA’s NemoClaw, for example, uses an open-source component called OpenShell to keep agents inside defined sandboxes and enforce policies down to the network level. A privacy router can also determine when information should remain on local infrastructure and when the agent is permitted to reach an external service, giving organisations more control over how far an autonomous system can go.

That combination of autonomy and containment is likely to define serious enterprise adoption. An agent needs enough access to be genuinely useful, but not indiscriminate access to everything the person commissioning it can reach. Pounds’ advice to individuals was to begin slowly and enable more capability as understanding grows; the same principle applies more strongly when agents operate inside businesses.

The interface becomes less important

As these systems mature, the most important change may be less visible than the models behind them. People will still use conversational interfaces, but the value increasingly comes from what happens after the instruction has been understood.

The falling barrier to building an agent is only half the story. Making one useful inside an enterprise is harder because the system must operate within the organisation rather than simply demonstrate what it can do. Pounds’ examples repeatedly return to that distinction: greater autonomy only becomes valuable when the agent has the context and access needed to perform useful work, while remaining constrained enough that the organisation can trust what it does.

The transition therefore is not from an old chatbot to a smarter chatbot. It is from software that waits for a question and returns an answer towards systems capable of taking responsibility for parts of the process that follow.

For businesses, that changes the measure of success. A convincing response is no longer enough. The more consequential test is whether the agent can take the next useful step, know when it should stop and operate within the boundaries the organisation intended. That is when an assistant begins to become something closer to a digital worker.