gshc2020.com

When you first pick up a guitar, everything is manual, and every decision is conscious: which finger goes where, how hard to press and when to switch chords. It is slow, mechanical and awkward.​

Then something changes. The chord shapes become muscle memory. You stop thinking about your fingers and start thinking about the song. Eventually, if you stay with it, you stop thinking about the mechanics and start focusing on the music.​

That is what abstraction does. Nothing stops mattering. It just stops demanding your attention. The lower layers are still there. They still matter. But they no longer consume your conscious focus.​

Every architectural era follows this pattern. The client-server era reduced our dependence on the machine. The web era made location less important. The cloud era pushed infrastructure into the background.

Now, the next shift is underway. In the agentic era, the abstraction target is no longer just infrastructure, runtime or platform. It is execution itself. And it is the part many enterprises are underestimating.​

Enterprise Systems Were Built For Manual Execution​

Most enterprise architectures today are still built around a simple assumption: A human sits at every meaningful decision point.​

A person reads the output. A person interprets the data. A person approves the next step. A person triggers the action. Even in heavily automated environments, the architecture often assumes that human judgment will be inserted repeatedly into the workflow.​

Agents do not work that way. They plan ahead, and they reason across steps. They act without waiting for someone to click “approve” at every turn. That does not mean they should operate without control. It means the control model itself has to change.​​

An organization may introduce an intelligent agent into onboarding, support triage, customer operations or software delivery. The agent can reason. It can decide. It has access to enough data to begin. But every few steps, it runs into an architecture designed for human-scale execution: approval gates, disconnected policy layers, tribal knowledge stored in documents or domain rules that live only in people’s heads.​

The result is predictable. The agent stalls. Then the team puts a human back in the loop. At that point, the enterprise has not created autonomous execution. It has created a more expensive form of assisted manual processing.​

In a traditional system, leaky abstractions slow you down. In an agentic system, they break trust. A human working with a weak abstraction may make a mistake. An agent operating on a weak abstraction can make decisions automatically, repeatedly and at scale.​​

The New Abstraction Model​

If execution is becoming abstracted, the old way of structuring enterprise systems is not enough. Enterprises need an abstraction model that makes autonomous execution safe, explainable and governable by design.​

This new model must account for three design dimensions:

1. Intent​

Intent defines what the system is trying to achieve. In an agentic enterprise, the goal cannot be buried inside a 47-step workflow or scattered across approvals, tickets and forms. Agents need a clear, bounded understanding of what needs to happen, what success looks like and which constraints matter.​​

Intent becomes structural when the system understands what good looks like without being walked through every single step. That means defining goals, not tasks. Success is measured through encoding constraints up front.

2. Context​

Context gives a system the knowledge it needs to act appropriately. Agents cannot operate well if the knowledge they need lives in slide decks, wikis, PDFs or institutional memory. Policies, trust levels, data access rules, domain semantics and organizational constraints need to live close to execution and be available in a form the system can use.​​

This is also where many AI pilots break. The model may be powerful, but the enterprise context is fragmented. The agent knows how to reason, but it does not know enough about the business, the policy environment or the domain boundaries to act safely.​

Context becomes structural when it stops living outside the work. It has to be current, available where execution happens and accessible in a form agents and systems can actually use.​

3. Boundaries​

Boundaries define where autonomy is allowed, constrained or stopped. In many enterprises, governance still shows up as approval gates and manual intervention points. That model does not scale into the agentic era. By the time an agent hits a human checkpoint, the abstraction has already started to fail.​

Boundaries need to shape execution from the inside and should be structural properties of the system. Execution can be decentralized, but oversight must remain federated. That means policies, permissions, identity, data access and observability cannot be afterthoughts. They have to be embedded into the execution fabric.​

Rethinking Architecture Decisions​

This is where architecture becomes critical.​

One useful way to think about architecture is through domain-driven design (DDD) and cell-based architecture (CBA). DDD can give you the modeling discipline. It can help identify bounded contexts, shared language and business seams. CBA can turn those seams into operating units with clear ownership, interfaces and governance. Together, they can provide a model where intent is explicit, context is available close to execution and boundaries are enforced.

The agentic enterprise requires us to rethink where decisions live, how context is carried and how governance is embedded.​

What Technology Leaders Should Do Now

Leaders don't need to deploy as many agents as possible. They need to make the enterprise ready for agents. This starts with three practical moves.​

First, identify the business capabilities where autonomous or semiautonomous execution could create real value. Second, map intent, context and boundaries for each capability. Third, modernize the underlying architecture so those answers are not trapped in documents or meetings. Make capabilities explicit. ​​

When execution gets abstracted, people move up the stack. Their work becomes less about managing workflows step-by-step and more about defining intent, setting constraints and shaping outcomes. ​​

Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?