A few months ago I watched an agent investigate a slow batch job on an IBM i system. The question it got was vague: “why did last night’s order processing run slow?” In about fifteen seconds it checked the job logs, pulled active job statistics, looked at disk utilization, cross-referenced recent PTF activity, and came back with a coherent explanation. A senior admin could have done the same investigation, but it would have taken them an hour or two, and they would have needed to know exactly where to look.
What stuck with me was the system on the other end. Its lineage goes back to the late 1970s, and none of that mattered to the agent. It issued SQL, got structured data back, and reasoned over it.
This post makes the case that IBM i’s architecture is a good fit for running AI agents in production, and that much of what the industry is building for agents already exists in it. It’s a shorter version of a longer post, and the full version has the references and more detailed examples.
Every agent platform is building the same layer
Over the last year, groups working independently of each other have reached for the same metaphor: the AI operating system. Rutgers built an LLM kernel (AIOS). PwC shipped a commercial Agent OS. Siemens and NVIDIA announced an Industrial AI Operating System at CES 2026.
What I find more interesting is what’s inside them. Each one builds the same components from scratch:
- Scheduling and runtime management, to decide what runs when.
- Identity and access control, to decide what an agent may touch.
- State and memory, so work survives between steps.
- Audit logging, so every action can be traced afterward.
- Policy enforcement, so limits hold even when the model doesn’t follow instructions.
They build these because the platforms underneath don’t provide them in a form that fits agents. Linux gives you process isolation, but not governed access to individual objects. A cloud VM gives you a filesystem, but the database is a separate system with its own permissions. Kubernetes gives you containers, but the platform doesn’t know what kind of object a file or table is or which operations are allowed on it. So each framework builds its own governance layer on top. Because the gap is in the platform, every team ends up closing it again on its own.
Five questions an agent platform has to answer
I find it more useful to think of an enterprise agent platform as a set of architectural properties than as a product you install. In the full post I frame them as five questions:
- Can an agent reach business data without crossing system boundaries?
- Can the system enforce what an agent may do at the level of individual objects?
- Can every agent action be traced to a decision, an identity, and a policy?
- Can the platform take on new hardware without agent code being rewritten?
- Can agents run with bounded autonomy that the system enforces, rather than the agent itself?
A platform either has these properties built in, or it has to approximate them in an application layer, and they’re hard to add after the fact.
IBM i answers them in its architecture
IBM i descends from System/38, announced in 1978. Its designers weren’t thinking about AI. They were working out how a system could let many users and programs share business-critical data safely, and they made four decisions that are still part of the platform today:
- Single-level storage. Memory and disk form one address space, so programs work with objects rather than managing files and buffers.
- Typed objects. Everything on the system is an object with a type, and the type determines which operations are allowed on it.
- An integrated database. Db2 for i is part of the operating system, not a separate server.
- TIMI, the Technology Independent Machine Interface. Programs compile to an interface above the hardware, which is how IBM i has moved across processor generations without recompiling applications.
Those choices were about governing shared resources, which is the same problem agents bring back: several actors, shared state, boundaries that have to hold, and a requirement to audit everything. IBM i didn’t anticipate agents, but because it solved that problem, the solution carries over. In practice, three consequences matter most.
Authority comes from the user profile. An agent connected under an IBM i user profile has exactly the authorities that profile has been granted. The operating system enforces this, not the agent framework, so the agent can’t go beyond those authorities even if a prompt tells it to. Those authorities are also data the agent can inspect. This tool from the IBM i MCP server checks whether any user on the system can run the command that changes the system library list:
SELECT object_authority
FROM qsys2.object_privileges
WHERE system_object_schema = 'QSYS'
AND system_object_name = 'CHGSYSLIBL'
AND object_type = '*CMD'
AND authorization_name = '*PUBLIC'
SQL services expose the whole system through one interface. Performance data, security configuration, job management, and PTF status can all be queried with SQL, over one connection and one authentication context. That’s what the agent in the opening example relied on. Here is the MCP server’s tool for finding the top CPU consumers, defined in YAML so the agent picks a question rather than writing SQL:
active_job_info:
source: ibmi-system
description: "Find the top 10 consumers of CPU in the QUSRWRK and QSYSWRK subsystems"
parameters:
- name: limit
type: integer
default: 10
statement: |
SELECT CPU_TIME, A.* FROM
TABLE(QSYS2.ACTIVE_JOB_INFO(SUBSYSTEM_LIST_FILTER => 'QUSRWRK,QSYSWRK')) A
ORDER BY CPU_TIME DESC
FETCH FIRST :limit ROWS ONLY
On other platforms, much of the work of deploying an agent goes into connecting it to each system it needs. On IBM i, that integration was built into the platform decades ago.
Auditing happens below the agent. The audit journal records operations at the operating system level, beneath the layer where an agent decides what to do. An agent can’t choose what gets logged or leave an operation out, because the platform does the recording, not the application.
Where IBM i falls short
The argument has real weaknesses, and most of them are about people, not architecture. The ecosystem is small. The developer community skews older, and the talent pipeline is a real concern. The “legacy” label hurts too: if you tell a CIO that the best platform for their agent strategy traces back to 1978, you can see the skepticism before you finish the sentence.
The Model Context Protocol (MCP) changes part of this. Any MCP client can connect to an IBM i MCP server and work with the system, with no IBM i expertise needed on the client side. An agent developer needs Python and SQL, not RPG or CL. That doesn’t fix the ecosystem, but it does mean the people building agents don’t have to come from it.
Where this goes
I see IBM i as the trusted core for the agent operations that carry the most risk: payroll, financial data, production systems that can’t go down and can’t leak data. It doesn’t replace the agent frameworks being built on Kubernetes, Azure, or AWS. It’s where the high-stakes actions run, with governance enforced by the platform itself.
Right now the industry is moving quickly on deploying agents and slowly on governing them. I expect that to change after the first major public breach caused by an agent. At that point the question becomes how safely agents can be deployed, not how fast, and governance built into the platform starts to matter when companies choose where to run them.
The full post covers the architectural analysis in more depth, the security frameworks it draws on, what we’ve built with iAssist, and the questions I’m still working through. If you’re running agents against IBM i, or thinking about it, I’d like to hear what you’re seeing.