The Next Great Abstraction in Software

Walter Meyer

When engineering intelligence moves inside the software itself.

For more than seventy years, software engineering has been an exercise in hiding complexity.

We started by packaging instructions into functions. We organized state and behavior into objects. We separated applications into services, introduced APIs, and eventually built independently deployable microservices around business capabilities.

Each generation changed how developers thought about software. We could accomplish more without understanding each detail of the underlying implementation.

But one responsibility remained consistent.

Someone still had to build, operate, maintain, and improve whatever lived behind the abstraction.

That responsibility is beginning to change.

Today, AI coding agents can investigate entire applications, generate functionality, refactor existing implementations, and diagnose problems. Engineering work that once required days can sometimes be completed in minutes.

Yet we still use these tools to manage software from the outside. Developers and centralized engineering processes typically recognize when change is needed and initiate the work.

What happens when that engineering intelligence moves inside the architecture?

Imagine engineering intelligence distributed across the services that make up an application.

A business capability defines what an enterprise needs to be able to accomplish. One or more services implement or support that capability through defined contracts.

Each independently governed service understands its responsibilities, observes its performance, and can manage the engineering work needed to sustain and improve its implementation.

Traditional engineering and enterprise governance remain in place. What changes is where responsibility for ongoing improvement resides.

The next great abstraction moves the engineering lifecycle inside the software itself.

How we got here

Software abstraction has evolved through several important transitions.

Functions and subroutines allowed programmers to package repetitive instructions behind stable interfaces. Developers could invoke operations without understanding each instruction required to execute them.

Modular programming and object-oriented design extended that principle to internal data structures, state, and behavior. Components and frameworks made more sophisticated capabilities reusable across applications.

David Parnas’s 1972 work on modularization articulated a key idea behind information hiding: module boundaries should protect design decisions likely to change.

Service-oriented architectures and APIs separated consumers from the location and technology used to implement a capability. A service could be consumed without knowing which programming language, database, or application server supported it.

Domain-driven design encouraged clearer business boundaries, while microservices made it possible to implement many of those boundaries as independently deployable services. Internal changes could be released without requiring corresponding changes throughout an application.

Cloud platforms and declarative infrastructure then abstracted much of the operational machinery required to run those applications.

These approaches accumulated over time. Most still coexist, and each addresses a different category of complexity.

Throughout that progression, one principle endured:

Consumers should depend on contracts rather than implementation details.

A service can change its internal architecture, replace dependencies, or adopt new technology without requiring its consumers to understand those changes, provided it continues fulfilling its contract.

But somebody remains responsible for making the changes. Historically, that has meant a development team, a software vendor, or another engineering organization.

What changes when that responsibility moves inside the abstraction?

Moving engineering intelligence across the boundary

AI-assisted software development already demonstrates that agents can perform substantial engineering work.

They can examine unfamiliar codebases, identify dependencies, construct solutions, execute tests, and coordinate specialized agents to handle different parts of an engineering task.

Today, that intelligence generally operates above or outside the application. A developer uses an agent to manage code, whether that code belongs to a single service or an entire enterprise application. The software being maintained remains largely passive.

Now consider an independently managed service with its own engineering intelligence.

The engineering agent does not need to be a large, general-purpose model. It operates within a bounded context, understands the service’s implementation and dependencies, and knows the contract the service is expected to fulfill.

It observes operational evidence and can initiate engineering work when something needs to change.

Consider an invoice processing service that begins encountering failures from a supplier whose document format has changed.

Its engineering agent recognizes the pattern across those failures, investigates the cause, develops a correction to the underlying parser, and tests the revised implementation against known cases.

Independent verification establishes that the correction meets its acceptance criteria without introducing unacceptable regressions. When the change falls within the service’s preauthorized evolution rules, established release controls can promote it automatically.

No developer needed to discover the recurring failures, investigate the parser, or initiate the correction.

The same mechanism extends beyond error correction.

The service might recognize an emerging transaction pattern, an unanticipated use case, or a change in its operating environment. It can investigate whether its existing implementation remains appropriate and develop new functionality when justified.

It might construct a specialized subagent, replace repeated model reasoning with deterministic code, improve an integration, or reorganize its internal components.

It can recognize when the implementation needs to evolve, including in ways its original designers never anticipated.

This is the distinction between AI-assisted development and what I’ll call a Self-Evolving Service.

The external development agent may still design and construct the initial service. Engineers can inspect it, intervene, or modify it directly. But once deployed, the service can assume much of the continuing responsibility for its own engineering lifecycle.

Its engineering intelligence does not need to execute on each service request or reside in the same runtime. Shared models and development infrastructure can support many services while each retains responsibility for its own evolution.

What matters is where engineering responsibility resides.

Traditional software responds to change through externally initiated engineering processes. A Self-Evolving Service can increasingly detect the need for change, engineer its own response, and introduce that response through governed mechanisms.

That’s the new abstraction boundary.

Distributed engineering intelligence

We’ve spent decades separating software into bounded responsibilities for good reasons. Independent ownership, loose coupling, reuse, fault isolation, and stable interfaces remain valuable. Agentic engineering extends those principles.

A modern enterprise application may contain dozens or hundreds of services. They collaborate through APIs, events, and contracts, each owning a bounded responsibility that contributes to one or more business capabilities.

Now imagine those services independently managing the evolution of their internal implementations.

Each service has its own engineering context, performance expectations, and responsibility boundaries. It can investigate and construct improvements without requiring a centralized development agent to understand the implementation details of the entire enterprise.

Consuming services continue interacting through established contracts, independent of how their dependencies are maintained.

The next abstraction isn’t a smarter agent sitting above our applications. It’s engineering intelligence distributed throughout them, allowing independently governed services to manage and evolve their own implementations.

Centralized development and enterprise architecture continue to establish capabilities, define contracts, govern interactions, and coordinate changes spanning service boundaries.

A central engineering agent might still construct a new service, manage a major transformation, or intervene when local changes are insufficient.

But ongoing engineering activity can increasingly originate within the services themselves.

That’s a significant extension of encapsulation. The service boundary now encompasses not just the implementation, but the engineering intelligence responsible for evolving it.

From self-healing to self-evolving

Software that manages aspects of itself isn’t a new concept. IBM’s autonomic computing research described interacting self-managing components, self-configuration, self-healing, and self-optimization more than two decades ago.

Modern orchestration platforms already monitor applications and respond automatically to changes in their operating environments. Kubernetes, for example, continuously reconciles observed conditions against a declared desired state.

Distributed self-management is established architectural thinking. The additional step proposed here is giving individual services responsibility for initiating, constructing, and evaluating changes to their own implementations, beyond predetermined operational responses.

A service can recognize that its current design is no longer the best way to meet its responsibilities, construct an alternative, evaluate it, and introduce a verified improvement.

That introduces three related behaviors.

Self-correction: The service identifies defects or recurring failures, investigates their causes, and develops corrections.

Self-optimization: The service identifies opportunities to improve performance, reliability, quality, or operating cost, even when nothing is technically broken.

Self-extension: The service recognizes emerging requirements or previously unanticipated behaviors and develops new functionality within its defined responsibilities.

The first repairs existing behavior. The second improves it. The third expands what the implementation can accomplish. All three involve engineering changes initiated from within the service.

A self-healing system restores intended behavior.

A Self-Evolving Service goes further. It can engineer changes to its own implementation, not merely adapt its behavior at runtime. Those changes remain subject to independent verification and established governance.

What happens as the service matures?

I’ve observed a related pattern in my own work building an agent-driven website migration system.

Early migrations require substantial engineering activity. Each new website can introduce unfamiliar layouts, components, and behaviors. Specialized agents determine whether existing components can handle them or whether new components, mappings, or tools are needed.

Those additions are constructed, tested, and incorporated into the reusable implementation.

As more sites are processed, the system encounters more problems it has already solved. Existing components and transformation logic handle more of the work, which reduces the need for new engineering.

Successful decisions accumulate as reusable components, mappings, and tools.

This changes the economics. The system can stop paying agents to rediscover familiar solutions. It executes established cases through tested, reusable components.

New platforms, unfamiliar patterns, and changing requirements can still trigger engineering activity. But for a relatively stable problem domain, the amount of new engineering required for familiar cases should decline as coverage expands.

A mature Self-Evolving Service doesn’t need to change constantly. It needs to recognize when change is warranted, preserve what works, and avoid solving the same problems repeatedly.

A new dimension of independence

Historically, software abstraction has established two important forms of independence.

Implementation independence allows consumers to use a capability without understanding how it works.

Execution independence allows consumers to request an outcome without coordinating each internal step required to achieve it.

Self-Evolving Services introduce a third dimension.

Evolution independence allows a service to initiate, engineer, and manage changes to its implementation without requiring each improvement to originate from an external development process.

This third dimension extends responsibility beyond execution and into the continuing engineering lifecycle.

The service’s authority has limits. It works within a defined scope, where it can recognize opportunities, develop improvements, and participate in its own evolution.

The service becomes an active participant in engineering as well as a product of it.

Governance becomes part of the abstraction

Software that can modify its own implementation creates an obvious challenge. How do we trust a service whose internal behavior can change without a conventional development project?

The answer can’t be a prompt instructing the agent to behave responsibly. Nor should routine improvements require the same human approval process as a major architectural change.

We need enforceable boundaries defining the service’s responsibilities, operating authority, and permission to evolve. I would organize those boundaries around three contracts.

The outcome contract defines the service’s responsibilities, quality expectations, acceptance criteria, and contribution to measurable business outcomes.

The operating contract defines its authority, including available systems, permitted actions, security restrictions, resource limits, and interactions with other services.

The evolution contract defines what the service can change about itself, how proposed improvements must be evaluated, which changes may be introduced autonomously, and where additional authorization is required.

These contracts establish the conditions under which engineering autonomy can operate.

A service might independently develop and promote an internal optimization after passing prescribed verification gates. Changing financial policy, expanding access to sensitive information, or modifying an interface used by other services would require different authority.

The agent proposing a change cannot be the sole authority deciding whether that change is acceptable.

This is where the method I outlined in Agents Decide, Tools Do, Gates Prove becomes relevant. Agents make judgments. Tools execute controlled operations. Gates independently verify results and produce evidence.

Those principles apply to both the work a service performs and the changes it makes to its own implementation.

The process also needs to be traceable and reproducible wherever practical. Each change should preserve an evidence record containing:

Deterministic components should produce repeatable results under controlled conditions. Agent-generated changes should preserve enough context and evidence for independent review.

We may not reproduce each internal reasoning step or receive identical answers from a model. But we should be able to rerun verification, examine the resulting implementation, and establish why a particular change was authorized.

The implementation may evolve. The evidence supporting that evolution needs to remain inspectable.

Proving that a change is actually better

Demonstrating that a change was authorized and implemented correctly doesn’t establish that it improved the service.

A parser update might resolve one supplier’s failures while introducing errors for another. A performance optimization might reduce latency while increasing infrastructure costs.

A Self-Evolving Service needs evidence of improvement, not merely evidence of change.

That starts with a baseline. Before introducing an improvement, the service should establish the measurements that matter: error rates, accepted outcomes, latency, operating costs, or other criteria appropriate to its responsibility.

Candidate changes can then be evaluated against reference cases, regression suites, and controlled comparisons. Where necessary, they can be introduced gradually, with production outcomes compared against the previous implementation.

Return to the invoice parser. Resolving the new document format is necessary, but success also means preserving accuracy on previously supported formats. The service should measure correctly processed invoices, false acceptances, exception rates, and processing cost against its established baseline.

If the improvement fails to deliver the expected results, the system needs a defined way to stop or reverse it.

Some outcomes can be measured deterministically. Others require statistical evaluation, independent judgment, or longer observation periods.

This approach builds on established architectural thinking. Neal Ford, Rebecca Parsons, and Patrick Kua’s Building Evolutionary Architectures emphasizes guided incremental change and architectural fitness functions that protect important system characteristics.

The additional step proposed here is to give individual services greater responsibility for initiating and engineering those changes, while independent mechanisms evaluate their fitness.

The service can initiate and manage its improvement cycle. Independent verification establishes whether the changes deserve to remain in production.

The implications extend beyond software engineering

Most organizations are approaching AI by asking how it can improve existing work.

How can it accelerate development? Automate content production? Reduce service costs? Make existing workflows more efficient?

These are reasonable questions, and many will produce measurable benefits. But they largely preserve the structure of the work.

The same applications, operating models, organizational boundaries, and development processes remain in place. AI is introduced into selected activities, and we measure how much faster or cheaper they become.

We’re optimizing the current operating model. The more consequential question is:

If we can define a business capability and its expected outcomes, then give an accountable system responsibility for building, operating, and continually evolving the implementation that delivers them, what should the operating model look like?

Today, a capability improvement typically begins as a requirement. Someone identifies a need, a team evaluates it, work enters a backlog, and engineering resources are assigned to deliver the change.

But what happens when the services implementing that capability can identify and develop many of those improvements themselves?

Some development activities may become unnecessary. Others may shift toward defining contracts, establishing policies, building reusable foundations, and validating results.

Engineering teams retain architectural ownership and accountability, and may spend less time directing individual implementation changes.

Technology investment could shift from funding collections of features and discrete projects toward funding capabilities with ongoing business responsibilities and measurable performance expectations.

The implications reach into budgeting, team structures, delivery models, and the relationship between business and technology.

They also help explain why measuring AI exclusively through productivity improvements risks missing a larger opportunity.

The greatest value may come from changing which activities require human initiation and coordination in the first place.

What changes for enterprise architecture?

Business capabilities are already established concepts in enterprise architecture. Domain-driven design, capability mapping, service-oriented architecture, and microservices have progressively moved technology organizations toward more explicit ownership of business responsibilities.

The new proposition is that the services implementing those capabilities can assume more responsibility for their own engineering lifecycle. That changes what enterprise architecture needs to govern.

Applications and microservices remain essential implementation components, while accountable capabilities become more important as units of investment and operational responsibility.

Service contracts become more consequential. Independent evolution requires stable interfaces, version compatibility, reliable integration, and clear ownership of dependencies.

Engineering governance must address how implementations change, including evolution authority, verification, provenance, and auditability.

Enterprise-level architecture remains responsible for coordinating the larger ecosystem. A service might improve its own performance by increasing requests to a shared dependency. Locally, the optimization appears successful. Across the enterprise, it may create unnecessary cost or instability.

Local improvement therefore cannot be evaluated entirely in isolation.

Centralized engineering retains responsibility for enterprise constraints, shared infrastructure, cross-capability dependencies, and changes that exceed local authority.

The architectural shift is a redistribution of engineering responsibility, with bounded autonomy at the service level and continued oversight of the enterprise as a whole.

The next abstraction boundary

Reliably evaluating autonomous engineering changes remains difficult.

Complex business outcomes aren’t always reducible to simple tests. Independently evolving services can introduce compatibility problems, unexpected costs, security vulnerabilities, and behavioral changes across an enterprise.

But these are familiar engineering challenges. Human developers already introduce regressions and vulnerabilities. AI-assisted development introduces variations of the same problems.

What changes is the distribution and potential frequency of engineering activity. When services can initiate their own improvements, engineering decisions that once passed through centralized teams may originate throughout the architecture.

That makes established disciplines such as testing, version management, deployment controls, observability, and rollback more important.

Autonomy also needs to be applied selectively. Stable, deterministic components may have little to gain from managing their own evolution. The overhead needs to be justified by the value of continued adaptation.

Still, the architectural direction is significant. We’ve demonstrated that AI can perform meaningful engineering work. The next question is where that intelligence belongs and which responsibilities it should assume.

I believe we’ll increasingly build services that can initiate and perform much of their own engineering work.

External development tools will remain available. Enterprise architects will continue to define boundaries, establish standards, and manage system-wide change.

But responsibility for local implementation evolution can reside within the services themselves.

We may be approaching a point where accountable business capabilities become the primary units of architectural responsibility, supported by Self-Evolving Services that manage much of their own implementation and improvement.

For seventy years, we’ve extended abstraction to hide the complexity of software implementation.

The next great abstraction extends that boundary to the engineering lifecycle itself: software that can recognize when it needs to change, engineer the response, and evolve through governed, verifiable processes.

That could change far more than how we write code.

Related reading

Read as plain Markdown