The new set of problems for engineers to solve

A lot of software engineers are going through what can only be described as an identity crisis. The job has changed a lot. Some are depressed, others are having the time of their lives. There's a really specific thing I see happening that makes me really excited for what engineering looks like over the next, call it a year or two - AI just isn't going to be able to create the incredible outcomes it's capable of creating unless software engineers solve problems to make it possible. This is existential, which is honestly a lot of fun, so it's a pretty incredible time to be a software engineer.

Multiagent systems are creating these problems

Agents started out as basic, human in the loop chats. Then models got better at running for longer on harder problems, and agentic systems started moving to the cloud. While that was happening, models have started to get better at working together, and people have built basic multiagent systems. Like an orchestrator that spawns some subagents for a given task, or giving agents jobs other than executing to improve outcomes, like grading or advising or dreaming.

Now, some folks are starting to build truly amazing multiagent systems to tackle the world's hardest and most important problems, like serious research, discovery, and hardware design. Picture thousands of agents, persistently working towards these outcomes. This comes with a new set of software engineering problems that we're already seeing crop up.

Infrastructure needs to evolve to handle burstier workloads. We need proper authentication and authorization to identify agents, let them work together, enable them to take the actions they should, and prevent them from taking the actions they shouldn't. Security and proper isolation are critical for untrusted code and content. And we've gotta have monitoring and the ability to stop a system in its tracks when it's veering into the wrong territory.

Models will keep getting better, and these types of multiagent systems will become really powerful. But software engineers have to solve all these problems if we're going to actually unlock that power and enable the world to trust it to create good outcomes like cured diseases rather than bad outcomes.

The problems

Infrastructure needs to evolve

The software industry has been building on Kubernetes, which was designed for stateless, replicated apps or stable numbered sets of stateful pods. Agents are totally different. They're essentially isolated, stateful, single-instance workloads. They can go idle for arbitrary amounts of time between bits of work, and they spend a lot of time waiting on tools, model inference, other agents, or human input. Some workloads need fast startup times, others need to avoid wasting compute, and others need crazy scale. Amazing engineers are pushing hard on this problem space - like AI infra companies building new filesystems and sandboxing offerings, and the Google team building Agent Substrate as a new runtime. There's a ton left to figure out.

Identity and access

There are problems to solve in agent authentication - identifying an agent that took an action. This area has the benefit of the building blocks that have been built and hardened from the microservices world, like workload identity with short-lived certs rather than static keys, and folks are beginning to apply these concepts to agents.

Agent authorization as a problem space is much more wide open - what do you allow an agent to do? Many agents work on behalf of a human, and use that human's identity and credentials to access various systems and take actions. There's already a problem in there, which is identifying that it was the agent and not the actual human who took an action. But there are deeper problems in this on-behalf-of (OBO) setup, like consent. If multiagent systems are working for weeks, how does the human meaningfully approve what their agent can do? Agentic platform features like auto approval for tool calls helps, but there's deeper permissioning needed to get this right at high scale. And then we have agents working with their own identity, which is even less solved, and how we apply that to agents working together - how does an agent trust another agent that asked it for something?

Security and isolation

Over the past few months and especially in the past couple weeks, we've seen vulnerabilities surfacing faster than the industry can patch them, much of it in critical core software that many systems rely on. Now think about thousands of persistent agents running on top of that core software, writing untrusted code and reading untrusted content. Those unpatched vulns get a lot more dangerous in that world, and one of the most important things for software engineers to do is get creative about how to harden that software - kernels, browsers, runtimes, and common libraries.

Multiagent systems add another twist. A compromised agent could pass injected instructions to other agents it's working with, and those instructions could end up in memory for future agents to accidentally trust. Blast radius gets real - how much of the multiagent system is at risk when that first agent got compromised? Isolation becomes important in that world - agents should use strongly isolated sandboxed execution environments to take actions. I wrote a bit about that here.

Monitoring and halting

Lastly, we need the tools to make sure these multiagent systems are working in a positive direction, and that we catch them and cut them off if they're not. We need OTel tracing across agents, and to ensure that an agent can never modify its own trace or another agent's trace. We need kill switches that monitoring can trigger, that truly stop the whole system at once and cut off its creds. Really the hard part is how to know when the system is going in the wrong direction. Well-intentioned persistence to solve a problem can look a lot like maliciousness - repeated attempts to reach a domain that isn't on its allowlist, for example.

Software engineers should be excited

This is for the engineers feeling an identity crisis because they think their knowledge and skills won't be important - you and your skills can be the difference in whether or not these problems get tackled and multiagent systems can solve the world's hardest problems. You can and should go deep in these domains, learn new things, and form opinions. So much of this problem space is wide open for new solutions. It's an incredibly exciting time to put your skills to work.