In 2019, I wrote about a simple but powerful idea: Own Less – Serverless. The argument was that serverless computing represented a new layer of abstraction – one where developers no longer needed to worry about servers, infrastructure provisioning, or scaling mechanics. You wrote code, deployed it, and the platform took care of the rest.
At the time, serverless felt like a natural next step in the long history of abstraction in software engineering. We moved from physical machines to virtual machines, from virtual machines to containers, and then to functions. Each step removed a layer of responsibility from the developer, allowing them to focus more on business logic and less on operational plumbing.
Fast forward to today, and something interesting has happened. While serverless continues to be an important abstraction, it is no longer the most disruptive one. Large Language Models (LLMs) have quietly turned the abstraction conversation on its head. We are now witnessing the emergence of agents powered by LLMs – and they are becoming a new layer of abstraction not just over infrastructure, but over programming itself. And increasingly, the platforms making this real, like MuleSoft and Agentforce, are where this abstraction meets enterprise execution.
Abstraction has always been the real story
If you zoom out, the history of programming is really the history of abstraction. Assembly abstracted away raw machine instructions. High-level languages abstracted away memory management and CPU registers. Frameworks abstracted away repetitive patterns. Cloud platforms abstracted away infrastructure. Serverless abstracted away servers entirely.
Each abstraction followed the same pattern:
- Reduce cognitive load
- Shift responsibility to the platform
- Let developers operate closer to intent
Serverless fits neatly into this story. Developers stopped thinking about servers and started thinking in terms of events and functions. But the unit of work was still code. You still had to write it, structure it, test it, and maintain it. That assumption is now being challenged.
LLMs introduce a different kind of abstraction
LLMs don’t just abstract infrastructure. They abstract expression. For the first time, developers can describe what they want in natural language and let the system figure out how to do it. This is a fundamental shift. We’re no longer just hiding complexity – we’re changing the interface to complexity.
Instead of writing a class, a method, and a test suite, a developer might simply say: “Build an API that validates customer data, stores it securely, and exposes a reporting endpoint.”
An LLM doesn’t just autocomplete code. It reasons, drafts, revisions, tests, and refactors. When wrapped inside an agent — think Agentforce. It can take ownership of a task end-to-end, from interpreting your intent to triggering real workflows across your enterprise. This is not a better IDE. This is a new abstraction layer over programming languages themselves.
Agents as the new programming surface
In the serverless era, the abstraction unit was a function. In the agentic era, the abstraction unit is intent. An agent is not just a prompt. It is a system that:
- Artist intent
- Break it into steps
- Generates or modifies code
- Runs tests and observes results
- Iterates until the outcome is right
The developer’s role shifts from “writing code” to directing behavior. This doesn’t mean programming disappears. It means programming moves down a layer — just like infrastructure did before. Developers still care about correctness, performance, and security, but they engage at a higher level of abstraction. Much like serverless hid servers, agents hide syntax. And platforms like Agentforce are making this a lived reality for enterprise teams today, not a distant promise.
Why this shift feels bigger than serverless
Serverless changed where code runs. Agentic systems change how code comes into existence. That distinction matters. With serverless, you still need deep language expertise. You just didn’t need to size machines or manage scaling. With LLM agents, even language fluency starts to become optional for many tasks. The developer becomes a reviewer, a guide, and a decision-maker rather than the sole author.
This is why LLMs feel uncomfortable to some engineers. They challenge a long-held identity that writing code line by line is the core value of software engineering. In reality, the value was always problem-solving. LLMs are simply removing friction from the expression of that value.
From “own less infrastructure” to “own less code” — and where integration comes in
The original “own less” philosophy applied cleanly to infrastructure. Today, it extends naturally to code. Owning less code doesn’t mean caring less about quality. It means letting agents handle the boilerplate, letting models generate first drafts, and letting systems propose solutions you refine. This mirrors what happened with serverless operations. Teams didn’t stop caring about reliability; they just stopped manually managing servers.
But here’s the thing that doesn’t get said enough: agents don’t operate in a vacuum. They need to reach into real systems – your CRM, your ERP, your databases, your legacy platforms – to actually get things done. And this is precisely where MuleSoft becomes indispensable. MuleSoft’s Anypoint Platform provides the unified API layer that agents plug into to take real action. Without this connective tissue, an agent’s reasoning is stranded. With it, reasoning becomes execution.
Building with agents instead of code-first
Consider a typical internal application: data ingestion, validation, transformation, and exposure via APIs. Traditionally, this involves writing ingestion code, defining schemas, implementing validation logic, writing tests, and debugging edge cases. It’s thorough, but it’s slow – and most of it is plumbing, not differentiation.
With an agentic system like Agentforce, the workflow looks fundamentally different. A developer describes the outcome. The agent generates the pipeline, writes tests, runs them, fixes failures, and proposes improvements. The developer reviews, adjusts constraints, and approves. Meanwhile, MuleSoft APIs serve as the action layer – connecting the agent’s output to the downstream systems that need to receive it, process it, or act on it. The abstraction is no longer “function” or “service.” It is a capability.
The emerging stack: Agents, APIs, and orchestration
Agents reason. APIs act. An LLM may decide what to do, but APIs determine whether it can be done. This is why integration becomes the silent backbone of agentic systems – just as it did for serverless architectures. And just like the serverless era validated the importance of well-designed APIs, the agentic era is now elevating them to a whole new level of strategic importance.
The stack that’s emerging looks something like this:
- LLMs as reasoning engines: Interpreting intent and planning action
- Agents (like Agentforce) as execution planners: Orchestrating multi-step workflows autonomously
- APIs (exposed via MuleSoft) as action interfaces: Connecting agents to enterprise systems
- Integration platforms as governance layers: Ensuring security, access control, and observability across every action
This isn’t a replacement of software engineering – it is its evolution. And organizations that have invested in a solid MuleSoft integration foundation are discovering they have a significant head start. Their APIs are already cataloged. Their systems are already connected. Plugging an agentic layer on top is a much shorter journey than starting from scratch.
What this means for developers
This shift doesn’t make developers obsolete. It makes them more influential. The best developers in an agentic world will ask better questions, define clearer intent, set better constraints, and review outcomes critically. Coding skill still matters, but judgment matters more. This mirrors the serverless transition exactly. The best serverless engineers weren’t those who knew servers best, but those who understood system behavior, failure modes, and business impact.
In the same way, the most valuable engineers in the agentic era will be those who understand how to define problems well, how to trust and verify AI-generated solutions, and how to design the API surfaces that agents need to operate effectively. If you are building on Agentforce or integrating through MuleSoft today, you are not just implementing tools. You are developing the intuition for a fundamentally different way of building software.
Programming as conversation
If serverless made infrastructure invisible, agentic systems are making code conversational. The future developer experience will feel less like writing instructions and more like collaborating with a highly capable assistant. Code will still exist, but it will no longer be the primary interface. And just as serverless once felt radical before becoming normal, agentic programming will follow the same path. What feels experimental today will feel inevitable tomorrow.
The enterprises that will lead this transition are the ones that have already built the integration fabric — where every system is reachable, every API is governed, and every action is auditable. MuleSoft has been that fabric for thousands of organizations. Agentforce is now the intelligent layer that sits on top of it, ready to act.
Closing thought
In 2019, the idea of “owning less” infrastructure helped teams move faster and think bigger. Today, LLM-powered agents are extending that philosophy to programming itself. The abstraction frontier has moved again. And this time, the question is not just whether you adopt new tools – it is whether your integration foundation is ready for the agents that are coming.
The good news? If you’ve been building with MuleSoft and thinking in APIs, you are already closer to that future than you might think.
