Five layers. What each one is, how it works, and where IBM i sits in it. The technical companion to the Pegasus4i argument — a reference, not a narrative.
It answers the two questions a technical team actually asks. First: where does the value live? The five layers do not accrue value equally — the model is commoditizing; orchestration, where your domain logic lives, is where the advantage sits. Second: what do you build, and in what order? Agent-ready is not a switch you flip. It is a five-step sequence, built in order, before agentic traffic can flow without breaking.
The value map tells you where to aim. The build sequence tells you how to get there. Each layer below carries a definition, how it works, and an IBM i relevance note.
The layers build sequentially — each enables the next — so the order matters as much as the contents.
The orchestration layer is where your source lives. The distance between that source and what an agent can act on is its Knowledge Distance — and closing it is the work. That's not a layer you buy. It's a position you hold.
The intelligence layer is the large language model at the center of an agent deployment. It receives context, reasons through the problem, and generates structured output — a response, a tool call, or a decision. This is the layer everyone talks about, and it is also the layer commoditizing fastest as capable models multiply and prices fall.
The action layer is the bridge between reasoning and doing — the loop where an agent calls a tool, gets a result, and decides what to do next. MCP is becoming the standard here: the protocol that lets any agent call any tool through a common interface, including agent-to-agent coordination.
The governance layer is permissions, audit, runtime enforcement, and deterministic policy — the controls that decide what an agent is allowed to do and prove what it did. This is table stakes, not a differentiator — but its absence is disqualifying. An agentic system without it cannot be trusted near anything that matters.
The orchestration layer is where domain logic, workflow encoding, task routing, and human-in-the-loop decisions live. It is the layer that knows how your business actually works — and it is the layer that does not commoditize, because it is specific to you. This is where value accrues, and it is where IBM i operators hold structural advantage.
The economic layer is token cost, latency, per-outcome pricing, and data sovereignty — the dollars-and-cents reality of running agents at scale. It is a derivative of the orchestration layer's quality: well-orchestrated workflows cost less to run and produce more reliable outcomes. Get L4 right and the economics follow.
The value map tells you where advantage lives. This is how you reach it. Agent-ready is a sequence of five layers built in order — discovery before comprehension, access before execution, governance underneath all of it. Build them in order and agentic traffic flows through your systems without breaking. Skip one or invert the order, and the failure shows up exactly where you can least afford it: at the boundary between an agent and the core that runs your business. For IBM i organizations the hardest part is already done — the logic and the reliability exist. What remains is the reachability.
Can agents find you — and understand what you're willing to let them do? By default an IBM i system has no presence an agent can navigate: no llms.txt, no manifest, no declared policy. From an agent's perspective the system does not exist until you build the discovery layer — an llms.txt declaring permissions and your MCP endpoint, an MCP server manifest, and structured markup describing your capabilities.
Can an agent understand what you do well enough to act on it correctly? The logic that governs operations lives in RPG programs and Db2 tables no agent can read directly. Agentic coding tools surface that logic into documentation, then machine-readable specifications. This is where decades of encoded logic becomes an asset an agent can finally reach — the work of closing Knowledge Distance on the technology side.
Can an agent reach the sovereign core — without changing it? This is the bridge: APIs and an MCP interface that make RPG and Db2 agent-legible without rewriting the core. The encoded logic stays exactly where it is, protected at the center; the access layer exposes it on terms you define, scoped to least privilege. Reach the core — don't rebuild it.
When an agent acts, can you prove what it did — and stop what it shouldn't? Every agent action authenticated, permissioned, and logged. Runtime enforcement, deterministic policy, and an immutable audit trail are not features added later — they are the precondition for letting an agent near the core at all. Build this layer first, so execution never outruns it.
With the four layers beneath it in place, agents execute real work against the systems that run the business — while humans govern strategy, judgment, and escalation. Agents execute, humans govern, the sovereign core stays protected the whole way. Prove it on one slice — a pilot or agentic twin — before scaling, and scale only as fast as the governance layer can hold.
The strategic read of the stack is simple: do not pour effort into the layer that is commoditizing, and do not treat the layer where your advantage lives as an afterthought. The model is a utility you consume. The action layer is the bridge you build. Governance is the floor you stand on. And orchestration — your encoded business logic, surfaced and connected — is the advantage you already hold and most competitors do not.
That is the whole case for why IBM i organizations are positioned, not exposed, in the agentic era. The value accrues exactly where these platforms are strongest.
This page asks where the value sits. Its companion asks the prior question — whether an agent can reach your logic at all, across five gates from discovery to execution. What agent-ready means →
02 / 03 · The technology axis · ← 01 The platform was always agentic · 03 What agent-ready looks like → · ↑ The map