← All writing

The Enterprise AI Operating System: Why IBM i's Architecture Anticipated the Agentic Era

The governance that agent frameworks are now building from scratch is already part of IBM i's architecture, which makes it a natural foundation for enterprise AI agents.

1. The Shift

A few months ago I watched an agent answer a question about a failing batch job on an IBM i system. The question was vague, something like “why did last night’s order processing run slow?” The agent queried more than one source. It checked job logs, pulled active job statistics, looked at disk utilization, cross-referenced recent PTF activity, and came back with a coherent explanation in about fifteen seconds. A senior admin could have done the same investigation. It would have taken them an hour, maybe two, and they would have needed to know exactly where to look.

What stuck with me was less the AI itself than the system it was talking to, which has been running business-critical workloads since the late 1980s. The agent didn’t care about that. It issued SQL, received structured data, reasoned over it, and acted. The age of the platform made no difference to it; the architecture did.

I think we’re at the start of a structural transition in enterprise computing, and I don’t think most people have fully worked out what it means. For decades, enterprise systems operated under a basic assumption: humans drive and software executes. We design workflows, configure rules, review reports, and make decisions, and then we tell the system what to do. Software handles the transactions, and humans provide the judgment.

That assumption is breaking now.

AI models did get more capable, but the bigger change is that the interface problem got solved. Model Context Protocol, structured tool use, and agent-to-agent communication give AI systems a new kind of connection to the software infrastructure that runs businesses. MCP alone has seen over 97 million monthly SDK downloads and more than 10,000 active servers since Anthropic open-sourced it in late 2024. Every major platform adopted it: OpenAI, Google, Microsoft, AWS, IBM, SAP, Salesforce. Block deployed MCP to 12,000 employees in under two months.

So agents can now talk to enterprise systems. They can query databases, invoke APIs, read logs, and trigger workflows. The problem is that talking to a system and operating within a system are different things. An agent that can issue SQL queries is useful. An agent that can manage workloads on its own, enforce security policies, and make bounded decisions on a production system is something else. The distance between the two is an infrastructure gap more than a gap in model capability.

If agents are going to operate enterprise systems, and not only assist the humans who operate them, then we need to ask a question that I think the industry has been avoiding: what does the operating system itself need to become?

This post is my attempt to work through that question. I believe the answer points toward something I’m calling the Enterprise AI Operating System: a persistent runtime layer that coordinates autonomous agents, enforces governance, and maintains the state and observability that enterprise operations demand. And I believe that IBM i, a platform most people associate with “legacy” computing, possesses architectural properties that align with this paradigm more naturally than anything else being built today.

That’s a bold claim, and I want to earn it rather than just assert it. I’ll start with what the industry is converging on and why the current approaches have a structural problem. Then I’ll define what an Enterprise AI Operating System actually requires. Then I’ll make the case for IBM i, including the tradeoffs. And I’ll close with what we’re building, what we’ve learned, and where I think this goes.

Before getting into any of that, I want to give a sense of the scale. Gartner predicts that by the end of 2026, 40% of enterprise applications will embed task-specific AI agents, up from less than 5% in 2025. That is a fast shift. Yet Menlo Ventures found that only about 16% of current enterprise AI deployments qualify as true agents, meaning ones where the model plans, executes, observes feedback, and adapts. The rest are fixed-sequence workflows with an LLM call somewhere in the middle. The gap between where the market is heading and where the infrastructure actually is should concern anyone responsible for production systems.

I think that gap is where the real work is. The work is less in making models smarter or building more tools, and more in building the runtime infrastructure that makes autonomous enterprise agents safe, observable, and governable. That’s the problem this post is about.

2. Everyone Is Building an AgentOS

I’ve been tracking how the industry is responding to this problem, and I keep seeing the same pattern. Independent groups, without coordinating, have arrived at the same metaphor: the AI operating system.

At Rutgers, the AIOS project built what they call an “LLM kernel.” Agents make system calls into it, just like applications make syscalls into Linux. It has an agent scheduler, a context manager that can pause and resume agents, a storage manager, a tool manager, and an access manager. The companion paper was titled “LLM as OS, Agents as Apps.” They mapped the full analogy: the language model is the kernel, the context window is memory, external storage is the filesystem, and agents are the applications running on top.

PwC shipped a commercial product called “Agent OS”, a cloud-agnostic orchestration layer they describe as the “central nervous system and switchboard” for enterprise AI. Agno AgentOS, formerly Phidata, offers an open-source three-layer stack with a production runtime, session isolation, and team execution modes. And at CES 2026, Siemens and NVIDIA announced what they explicitly called an “Industrial AI Operating System,” built on digital twins where agents continuously test and optimize factory operations.

What I find more interesting than the shared metaphor is that they’re all building the same components from scratch. Each of these frameworks ends up implementing some version of the same core capabilities: scheduling and runtime management for agents, identity and access control, state and memory persistence, observability and audit logging, and policy enforcement.

I think the reason everyone is reinventing this is architectural. The platforms these frameworks run on (Linux, cloud VMs, Kubernetes) were designed for a different model of computing. They give you process isolation, but not governed object-level access. They give you filesystems, but not integrated data where the database and the operating system share the same address space. They give you containers, but not typed system resources where the platform itself knows what kind of object something is and what operations are allowed on it.

So every AgentOS framework has to build its own governance layer on top of infrastructure that wasn’t designed to govern autonomous actors. AIOS builds an “Access Manager” from scratch to enforce privacy between agents. PwC’s Agent OS integrates across AWS, Azure, Google Cloud, Oracle, Salesforce, and SAP just to provide a unified view of enterprise data. Microsoft created Entra Agent ID and bolted Defender and Purview onto Copilot Studio to get identity, protection, and auditing. AWS added natural-language policy enforcement and episodic memory to Bedrock. Kyndryl launched “Policy as Code” to transform organizational rules into machine-readable agent constraints. Each of them is solving the same underlying problem: the platform doesn’t do this natively, so the vendor has to build it.

I don’t want to overstate this. These are smart teams doing serious engineering, and the products they’re shipping work. But when everybody independently arrives at the same set of missing capabilities, I read that as a signal about the foundation they’re building on rather than about the builders.

The security story makes this more urgent. MCP adoption exploded before authentication and registry mechanisms were enterprise-ready. Simon Willison identified the core issue early: MCP creates what he called “toxic combinations of private data, untrusted instructions, and exfiltration vectors.” The risk turned out to be real. CVE-2025-6514 compromised over 437,000 developer environments. Microsoft’s own Copilot suffered a zero-click prompt injection, dubbed EchoLeak, that allowed data exfiltration through poisoned emails. In December 2025, OWASP published a Top 10 specifically for agentic applications, cataloging threats like Agent Goal Hijack, Tool Misuse, Identity and Privilege Abuse, Memory Poisoning, and Rogue Agents. The Cloud Security Alliance published an Agentic Trust Framework in February 2026 applying Zero Trust principles to agents. NIST launched an AI Agent Standards Initiative the same month. Forrester predicts a publicly disclosed agentic AI breach in 2026.

I see these incidents as predictable consequences of running autonomous agents on platforms that weren’t designed for them.

3. What Does an Enterprise AI Operating System Actually Require?

I think the requirements become clear once you stop thinking about features and start thinking about architectural properties. An Enterprise AI Operating System is a set of properties that the platform either has or doesn’t, rather than a product, framework, orchestration layer, or set of APIs that you install on top of Linux or Kubernetes. If the platform doesn’t have those properties natively, you end up spending years reconstructing them and fighting the abstraction at every step.

I think this distinction gets lost in most of the AgentOS conversation. The frameworks I described in the previous section aren’t wrong. They’re compensating for what the underlying platform should have provided in the first place. Compensation works until you hit a security boundary that your governance layer can’t enforce because it sits above the kernel, or an audit trail has a gap because the agent framework forgot to log a syscall, or a data integration fails silently because the information an agent needed lived in a different system behind a different authentication model.

The better starting point is the platform level: what properties would a system need natively to serve as a real operating environment for autonomous enterprise agents?

I’ve written these as questions rather than a checklist, because each question exposes a gap that the industry is struggling with right now.

Can an agent access business data without crossing system boundaries?

This is the data integration problem, and it’s more severe than most people acknowledge. MIT Sloan found that roughly 80% of the work in deploying AI agents goes to what they called “unglamorous” tasks: data engineering, stakeholder alignment, governance, workflow integration. Deloitte’s research is starker: their findings suggest that agents make enterprise decisions on approximately 20% of the information they actually need. The other 80% (contracts, email threads, negotiated rates, historical patterns) sits in fragmented systems behind incompatible APIs. ServiceNow’s CEO put it bluntly: “The journey to agentic AI heaven goes through a data hell.”

This matters for the OS question because every system boundary an agent crosses adds latency, failure modes, and security surface area. If an agent needs to query a database, then call out to a separate document store, then hit an API to get configuration data, then authenticate against a different service to check permissions, that’s four trust boundaries, and each one is a place where the call can fail or context can be lost or corrupted. And the agent has to hold all of that state in its context window while reasoning about a business problem.

From an architectural standpoint, the ideal is an environment where the data and the execution live in the same space, and where the database is a component of the OS rather than a service the OS connects to. I realize this is a throwback to an older model of computing, and I think that older model is the right one for this problem.

Can the system enforce what an agent is allowed to do at the object level?

I mean the object level, not the network level or the API gateway level. When an agent attempts to read a database table, modify a configuration, or invoke a system function, does the platform itself know whether that specific agent identity has authority over that specific resource?

This is where the probabilistic nature of agents creates a new security challenge. Traditional software is deterministic. You can audit the code, trace every possible execution path, and verify that the program will never attempt an unauthorized operation. Agents don’t work that way. Their behavior emerges from model weights, prompt context, and runtime observations. You can’t pre-audit what an agent will decide to do. You can only constrain what the system will allow it to do.

The MiniScope framework from recent academic work provides the first rigorous definition of least privilege for tool-calling agents, drawing on mobile platform permission models. The AGENTSAFE framework operationalizes governance into design-time, runtime, and audit controls with dynamic authorization. Both are trying to solve the same problem: how do you enforce boundaries on actors whose behavior you can’t fully predict?

Most platforms today enforce boundaries at the API or service mesh level. An agent with access to an API has access to everything that API exposes. That isn’t least privilege; it relies on the agent behaving well.

An Enterprise AI OS needs something closer to what traditional single-level storage systems provide, where every object in the system has an identity, a type, and an authority model. Beyond knowing that an agent is making a request, the platform knows what object the agent is requesting, what operations are valid on that object type, and whether this specific agent identity has been granted those specific operations. The enforcement happens below the agent, at the system level, where the agent can’t circumvent it.

Is every agent action traceable to a decision, an identity, and a policy?

Auditability in enterprise systems is a regulatory requirement. The EU AI Act becomes fully applicable in August 2026 for high-risk systems, but analysis from The Future Society found that the Act’s static pre-market conformity approach conflicts directly with agents’ dynamic runtime behavior. No agent-specific guidance is expected before 2027 at the earliest. In that regulatory gap, enterprises need platforms where audit trails are an intrinsic property of operations rather than a logging framework added after the fact.

By “intrinsic” I mean this: if an agent makes a decision at 2 AM that affects a production workload, the system needs to have captured what the agent did, what policy authorized it, what data informed the decision, and what identity the agent operated under. It needs to capture all of it automatically, without relying on the agent framework to log itself, because the agent is the actor you’re trying to audit. Letting the actor control its own audit trail is precisely the pattern that enterprise governance exists to prevent.

The OS-level distinction matters here too. A logging framework that an agent writes to is different from a system journal that records every operation on every object, whoever or whatever initiated it. The first has gaps by design, because it depends on the agent’s cooperation. The second has no gaps, because it operates below the layer where the agent makes decisions.

The audit question also extends to something less discussed: reproducibility. When an agent makes a bad decision, can you reconstruct the full context that led to it? What was in the agent’s context window? What tools did it call, in what order? What data came back? If the audit system captures only the final action and not the reasoning chain, you can’t diagnose failures; you can only observe them after the damage is done.

Can new hardware capabilities be absorbed without rewriting agent code?

This might seem like a secondary concern, but I think it matters more than people realize. AI hardware is evolving fast: matrix math accelerators, dedicated inference cards, and new memory architectures, with each generation optimized for different workload profiles. If your agent code is compiled for specific hardware, every hardware generation requires migration work. In enterprise environments, that means testing, validation, change management, and risk.

The alternative is a platform that abstracts hardware behind a stable execution interface. Agents written today then benefit automatically from hardware shipped five years from now. Neither the code nor the compilation target changes; the platform absorbs the new capability and exposes it through the same interfaces.

For enterprises that plan in decades rather than quarters, this is a strategic question: does your investment in agent development compound over time, or does it depreciate with every hardware cycle?

This property gets the least attention in the current AgentOS conversation, because everyone is focused on the immediate problems of governance, security, and orchestration. But hardware abstraction is a decision that looks insignificant today and becomes load-bearing ten years from now.

Can agents operate within bounded autonomy that the system enforces?

This is the governed autonomy question, and I think it’s the most important one. It’s also the one where the distinction between “agent framework governance” and “platform governance” is sharpest.

The Cloud Security Alliance’s Agentic Trust Framework proposes a maturity model using human role titles: Intern agents get read-only access. Junior and Senior agents operate with supervised autonomy. Principal agents get trusted autonomy with monitoring. That’s a useful mental model, but it raises an immediate question: who enforces those boundaries?

If the answer is “the agent framework,” then governance is only as reliable as the framework. A misconfigured agent, a prompt injection, or a tool that exposes more than intended can each bypass framework-level governance, because the framework and the agent operate at the same layer. The framework is asking the agent to govern itself, or at best, wrapping the agent in guardrails that run in the same execution context.

If the answer is “the operating system,” then governance is an architectural guarantee. The agent cannot exceed its boundaries because the platform won’t execute operations that violate the authority model. Whatever the agent decides to do, whatever prompt injection it receives, and whatever tool it tries to invoke, the operation doesn’t happen if the system-level authority says no.

An agent that chooses to respect its boundaries is different from an agent that cannot exceed them because the platform won’t let it. I believe enterprise systems need the latter, and I believe that requirement, more than any other, determines what kind of platform can serve as a real Enterprise AI Operating System.

Properties, not products

All of this changes how I think we should evaluate platforms for the agentic era. The useful question is “which platform possesses these properties natively?” rather than “which product has the best agent framework?” The properties are integrated data that agents can access without crossing trust boundaries, object-level security enforced below the agent layer, intrinsic audit trails that don’t depend on agent cooperation, hardware abstraction that protects long-term investment, and governed autonomy enforced at the system level.

You can’t add these as features to a platform that lacks them. They’re architectural properties, and architecture is decided early. You can build an agent framework on top of any platform, but you can’t easily retrofit the platform’s relationship to data, security, and governance after the fact. Every AgentOS framework described in the previous section is trying to do that, and the complexity cost is real and grows over time.

I realize that framing the requirements this way makes it obvious where I’m heading, but I think the framing is honest. I didn’t reverse-engineer these requirements from a specific platform’s feature set. The industry is converging on them independently, through security failures, governance frameworks, and the practical experience of trying to deploy autonomous agents in production. The question is which platforms meet them natively and which require them to be reconstructed from parts.

4. The Accidental Alignment

I believe IBM i possesses architectural properties that the rest of the industry is trying to recreate. I mean this as a structural observation, and I want to walk through it carefully, because the claim sounds bigger than it is if you don’t understand why the alignment exists.

It starts in 1978. The designers of System/38 made a series of engineering decisions that, at the time, were responses to specific problems in commercial computing. They weren’t thinking about AI agents. They were thinking about how a system should manage shared resources safely when multiple users and programs need concurrent access to business-critical data. They chose single-level storage, where everything lives in one virtual address space. They chose object-based typing, where the system itself knows what kind of thing every resource is. They chose capability-based pointers validated in hardware, so programs cannot forge access to objects they haven’t been authorized to touch. They integrated the database into the operating system rather than running it as a separate service. And they built a technology-independent machine interface, TIMI, that decouples programs from the hardware they run on.

These were pragmatic decisions, and they turn out to be the decisions you’d make if you were designing an operating system for autonomous agents. The problems have the same structure: multiple actors, shared state, the need for enforceable boundaries, and a strict requirement for auditability. The System/38 designers were solving for untrusted programs, and we’re solving for unpredictable agents, but the architectural answer is the same.

I don’t think that’s a coincidence. Governed concurrent access to shared enterprise resources is a specific engineering challenge, and the set of good solutions is smaller than people assume. The industry is rediscovering this now, which is why every AgentOS framework ends up building the same components. They’re converging on answers that IBM i arrived at decades ago. IBM i didn’t predict agentic computing; it solved the underlying problem correctly.

Let me walk through the alignment concretely, requirement by requirement.

Diagram titled “IBM i: Built for Agents”: IBM i architecture (integrated OS + Db2, SQL services for system management, role-based security) enables agent superpowers (one tool call touches data, files, and system; every system action is a SQL statement; agent inherits user authority), which map to MCP server tools such as run_sql, run_cl, get_job_log, and manage_ifs

Governed access without bolted-on layers

Every object on IBM i has a type and an authority model enforced at the system level. Data areas, programs, files, queues, and user spaces are all typed objects with explicit authorities governing who can do what to it. Programs cannot masquerade as other object types. You can’t trick the system into treating a data area as a program or a file as a command. The hardware validates capability-based pointers, which means even low-level memory manipulation can’t forge unauthorized access.

For agents, this means that an agent running under a user profile inherits exactly the authorities that profile has been granted. If the profile can read INVENTORY but not PAYROLL, the agent can read INVENTORY but not PAYROLL. The operating system enforces that constraint, not the agent framework, so the agent doesn’t get a choice.

This is what the Cloud Security Alliance’s Agentic Trust Framework calls “Zero Trust for agents”: the idea that every agent action should be verified against explicit policies before execution. IBM i has been implementing this model since before “Zero Trust” existed as a term. The platform’s five security levels provide graduated enforcement, from no security at level 10 to full C2-certified resource protection at level 50, and most production IBM i systems run at level 40 or above.

Compare this to what other platforms are building. Microsoft created Entra Agent ID to give agents distinct identities within Azure Active Directory. That’s necessary work, but it’s an identity layer added to a platform that didn’t originally distinguish between human and programmatic actors at the OS level. AWS added natural-language policy enforcement to Bedrock because the underlying infrastructure doesn’t natively express fine-grained resource authorities in terms agents can inherit. These are good compensations, but they compensate for architectural properties the platform lacks.

I want to be careful here. I’m not saying IBM i’s security model is superior to modern cloud security in every dimension. Cloud platforms have capabilities IBM i doesn’t, such as federated identity across organizational boundaries, dynamic scaling of security policies, and integration with modern authentication protocols. But for the specific problem of “an autonomous agent operating on shared enterprise resources needs enforceable, object-level boundaries,” IBM i’s model is architecturally native in a way that other platforms have to reconstruct.

Integrated data without crossing trust boundaries

Earlier I quoted ServiceNow’s CEO saying that the journey to agentic AI heaven goes through data hell. On IBM i, there is much less of that data hell.

With single-level storage, Db2 tables, IFS files, program objects, data areas, data queues, and spool files all exist in one virtual address space. The database is a component of the operating system, not a service the operating system connects to. When an agent issues a SQL query against IBM i, it isn’t crossing a trust boundary to reach a database server. It’s accessing objects that live in the same governed space as everything else on the system.

In practice, think about the scenario I described at the beginning of this post. The agent investigating a slow batch job needed to check job logs, pull active job statistics, look at disk utilization, and cross-reference PTF activity. On most platforms, that’s four different data sources, possibly with four different APIs and four different authentication contexts. On IBM i, it’s SQL. IBM i SQL services expose the entire system through a single interface, including performance data, security configuration, developer tools, job management, system health, and PTF status. The agent uses one protocol, one authentication context, and one governed access model.

This is why the MCP server architecture I’ve been building works as cleanly as it does. An agent connected to an IBM i MCP server can issue SQL that reaches any of these system services. It doesn’t need ten different tool integrations for ten different system functions. It needs SQL and the authority to run the relevant queries. The integration complexity that consumes 80% of agent deployment effort on other platforms, according to MIT Sloan, largely doesn’t exist here because the integration happened at the platform level forty years ago.

I don’t want to pretend this is a complete solution to the enterprise data problem. Plenty of IBM i shops have data spread across multiple systems, multiple IBM i partitions, cloud services, and third-party applications, so the data integration challenge doesn’t vanish. But the on-platform data, which represents the core of what these systems do, is natively accessible in a way that other platforms can’t match without significant middleware.

Audit trails as a system property

IBM i’s security audit journal captures every security-relevant event at the OS level, including object creation, deletion, and modification, authority changes, program invocations, file access, and user profile operations. It isn’t a logging framework that you configure and hope agents write to. It’s part of how the system works: every operation on every object gets recorded, whoever or whatever initiated it.

In the previous section I said that the actor should not control its own audit trail. On IBM i, it can’t. The audit journal operates below the layer where agents, programs, or users make decisions. An agent can’t selectively log its actions, omit an embarrassing operation, or “forget” to record something. The system captures everything because auditing is a property of the platform, not a behavior of the application.

This matters a great deal for regulation. The EU AI Act’s requirements for high-risk AI systems include maintaining logs of operations for traceability. The challenge, as The Future Society’s analysis pointed out, is that the Act’s static pre-market conformity approach doesn’t map well to agents whose behavior emerges dynamically at runtime. You can’t pre-audit what an agent will decide. What you can do is guarantee that whatever it decides is recorded completely, automatically, and in a way the agent itself cannot tamper with. IBM i’s journal-based auditing provides this guarantee.

Audit completeness is not the same as audit usefulness, though. Capturing every operation is necessary but not sufficient. For real diagnostic value, you also need to reconstruct the reasoning chain: what was in the agent’s context, what tools were called, what data came back, why the agent chose one action over another. That reasoning-level audit is an agent framework responsibility, not an OS responsibility. But the OS-level guarantee that the effects of every decision are captured completely and immutably is the foundation everything else builds on, and IBM i provides it today.

Hardware abstraction through TIMI

This may be the most underappreciated property for agentic computing, and I think it will matter more over time in ways people aren’t considering yet.

Programs on IBM i don’t compile to native machine code. They compile to an intermediate representation defined by the Technology Independent Machine Interface. When IBM ships new hardware (Power10, Power11 and whatever comes after), programs don’t need to be recompiled. TIMI absorbs the new hardware capabilities and exposes them through the same interfaces.

For agents, this matters because of where AI hardware is going. IBM’s Power11 includes Matrix Math Accelerator cores designed for AI inference workloads. The Spyre Accelerator cards add dedicated AI processing. Future generations will bring capabilities we can’t predict today. On platforms where agent code compiles to specific hardware targets, every hardware generation triggers a migration cycle: recompile, retest, revalidate, redeploy. In enterprise environments, that cycle is expensive and risky.

On IBM i, that migration doesn’t happen. An agent’s underlying programs, written today, will automatically benefit from hardware capabilities that don’t exist yet. Because of the TIMI layer, the platform can use Matrix Math Accelerators, Spyre cards, or future AI silicon without anyone touching the agent code. No other enterprise platform offers this kind of temporal decoupling between software investment and hardware evolution.

I realize this sounds like a theoretical concern when the immediate pressure is getting agents working at all. But I’ve seen enough enterprise technology cycles to know that the decisions that feel secondary today become the ones you’re grateful for, or cursing, a decade later. Enterprises plan in decades, and the value of hardware abstraction grows over that time.

SQL as the universal agentic interface

I touched on this in the data integration section, but it deserves its own treatment because I think SQL’s role as the agent-to-system interface on IBM i is a real differentiator.

Slide titled “IBM i: The first agentic-native operating system” listing three pillars (integrated OS and database, command-driven environment, security and role-based access) above a diagram of SQL as the universal agentic interface: a human talks to an LLM call, which runs SQL against Db2 for i on IBM i and gets feedback until it stops

IBM i SQL services expose the operating system, not only database tables. Performance metrics, security configuration, system values, active jobs, message queues, PTF status, IFS contents, and authority structures are all accessible through standard SQL. IBM has been investing heavily in this design, and it makes a large difference for agents.

Consider what this means for agent architecture. On most platforms, an agent that needs to manage system resources requires a collection of platform-specific tools: one for monitoring, one for security, one for job management, and one for configuration. Each tool has its own API, its own authentication model, its own error handling. The agent needs to know which tool to call for which task, and the MCP server needs to expose and manage all of them.

On IBM i, the agent needs one tool: SQL. The MCP server I’ve built translates natural language questions into SQL queries against IBM i SQL services. The agent gets one protocol and one interface, with full system access within the bounds of its authority. I see this simplicity as an architectural advantage. Fewer integration points mean fewer failure modes, fewer security surfaces, and fewer things that can go wrong at 2 AM when the agent is making autonomous decisions.

This is also why the text-to-SQL agent pattern works so well on IBM i specifically. The agent layer converts natural language to SQL, the MCP server routes it to the IBM i system, the system enforces authorities and returns structured data, and the agent reasons over the results. Every step in that chain is governed and auditable. And because the interface between the agent and the system is SQL, which both humans and machines understand, the people who need to review what the agent did can read the audit trail.

The honest tradeoffs

I said I wanted to earn the claim rather than just assert it, and that means acknowledging where IBM i falls short.

The ecosystem is small, and the developer community skews older. The talent pipeline is a real concern, because fewer people are entering the IBM i workforce than leaving it. The “legacy” label creates perception problems that go beyond branding and affect hiring, investment decisions, and strategic planning conversations. When you tell a CIO that the best platform for their AI agent strategy is a system that traces its lineage to 1978, you can feel the skepticism before you finish the sentence.

Some of those concerns are legitimate. The tooling ecosystem is narrower than what you’d find on Linux or in cloud-native environments. The learning curve for IBM i system administration is steep. Modern developer expectations around CI/CD, containerization, and infrastructure-as-code are only partially met.

But I think the counterarguments are stronger than the objections, and they’re getting stronger fast.

PASE, the Portable Application Solutions Environment, runs standard AIX binaries on IBM i. Python and Node.js, the tools that AI development depends on, run there as supported runtimes. An agent developer doesn’t need to learn RPG or CL to build agents that operate on IBM i. They need Python and SQL.

MCP also makes IBM i much more accessible. Any MCP client, such as Claude Desktop, VS Code with an AI extension, or a custom orchestration platform, can connect to an IBM i MCP server and interact with the system without any IBM i expertise on the client side. The agent doesn’t know or care that it’s talking to an IBM i system. It sees tools, issues calls, and gets responses. The platform knowledge lives in the MCP server and the agent’s instructions, not in the developer’s head.

IBM Bob, the AI-powered assistant for IBM i development, is showing 45% productivity gains for developers working with legacy codebases. That doesn’t solve the talent pipeline problem entirely, but it changes the calculus. If AI can make one developer as productive as two on legacy code, the talent shortage becomes less existential.

The hardware helps too. With the Matrix Math Accelerator cores in Power11, you can run AI inference locally, next to the data, without shipping anything to the cloud. The data stays where it is, the governance stays intact, and the latency drops. For enterprises with data sovereignty requirements or simply massive on-premises datasets, this is significant.

None of this makes the tradeoffs disappear. The ecosystem needs to grow, the developer experience needs to modernize, and the perception gap needs sustained effort to close. But the core thesis, that IBM i possesses the properties an Enterprise AI Operating System requires, stands regardless of the ecosystem challenges. An ecosystem can grow, and architecture is much harder to change after the fact.

5. From Architecture to Runtime

Everything I’ve described so far has been a structural argument: IBM i has these properties, and the industry needs them. But a thesis about architecture only matters if you can show it working. So I want to move from the theoretical case to what we’ve actually built, what it has taught us, and where the practical edges of the idea are.

The system is called iAssist. It’s an agentic platform for IBM i that currently runs 28 agents organized into 5 coordinated teams, executing 3 multi-step workflows with shared learning across agents and flexible deployment options. The system is growing, so those numbers will be outdated by the time you read this, but the architecture behind them is what matters here.

What an agent actually looks like on IBM i

The AgentOS conversation tends to describe agents abstractly, with agent taxonomies, capability matrices, and autonomy levels. That’s useful for framework design, but it doesn’t tell you what it’s like to build and operate agents on a real enterprise system. So here is the anatomy of an iAssist agent, from the perspective of someone who built them.

iAssist AgentOS for IBM i high-level architecture: UI clients (web UI, CLI/TUI, MCP clients, A2A) connect to an Agno AgentOS runtime with agents, teams, workflows, memory, knowledge, guardrails and observability, which calls the IBM i MCP server over MCP, which runs SQL against Db2 for i, QSYS2 SQL services and system APIs

An agent has four components: tools, instructions, memory, and skills.

Tools are the agent’s interface to the system. In our architecture, the primary tool interface is the IBM i MCP server, which exposes IBM i’s capabilities through Model Context Protocol. Through MCP tool calls, an agent can issue SQL queries against Db2, interact with IFS files, call programs, read message queues, and check system values. The agent doesn’t need to know RPG or CL or how IBM i system APIs work. It needs to know what question to ask and how to express it in SQL, and the MCP server handles the translation to IBM i’s native interfaces.

This is where the modular architecture becomes important. The IBM i MCP server provides raw tools, and raw tools alone aren’t enough for production use. An agent with unrestricted access to SQL and no guardrails is dangerous for the same reason that giving a new hire direct database access on day one is dangerous. They might be smart and mean well, but they don’t have the context to know what they shouldn’t touch.

So we build in layers. I can take an agent, say the ibmi-text2sql agent, preconfigure it with instructions, safeguards, and tools via the IBM i MCP, and then expose that configured agent as its own MCP server. Any MCP client can connect to it: Claude Desktop, VS Code, a custom orchestration platform, even IBM Bob. The request flows from the client to the agent MCP, which routes to the IBM i MCP, and the response flows back up. The agent layer adds the structure, the guardrails and the specialized logic, and the IBM i MCP provides the raw system access. Each component stays separate, and they work together.

You can plug the IBM i MCP server directly into a client. But then you get only the primitives, with no safeguards, specialized instructions, or domain-specific reasoning around them. It’s the difference between giving someone a set of wrenches and giving them a mechanic who knows which wrench to use when.

MCP was designed to enable this layered pattern (tools → agent → MCP endpoint → any client), where you build your agents and tools once and use them anywhere. On IBM i, the “anywhere” part matters because the IBM i expertise doesn’t need to live in the client or the user’s head. It lives in the agent layer.

Instructions are the agent’s domain knowledge expressed as behavioral guidance. What kind of questions can this agent answer? What SQL services should it prefer for different query types? What are the boundaries of its authority? What should it do when it encounters ambiguity? Instructions are structured prompts that shape how the agent uses its tools, not model weights or fine-tuning. Think of them as the runbook a senior admin would hand to a junior one: here’s what you’re responsible for, here’s how to approach common scenarios, here’s when to escalate.

Memory is where things get interesting, and where we’re still figuring out the right patterns. An agent that forgets everything between sessions is limited in ways that become obvious fast. The first time you ask an agent about a system issue and it has no context about the resolution you worked through with it yesterday, you feel the gap. We’re building memory capabilities that let agents accumulate domain-specific knowledge across conversations, so an agent that helped diagnose a performance issue last week carries that context into this week’s investigation. But how memory should work across sessions, teams of agents, and different user contexts is still an open question, and we haven’t solved it.

Skills are loadable capabilities that agents can acquire on demand based on the task at hand. Rather than building monolithic agents that try to do everything, we build focused skill modules that agents pull in when needed, such as a performance analysis skill, a security audit skill, or a PTF management skill. The agent assesses what the task requires and loads the relevant skills. This keeps individual agents focused while allowing the overall system to handle a broad range of scenarios.

The packaging question is one I keep coming back to: what’s the best way to consolidate tools, skills, custom knowledge, and instructions so we’re not constantly rebuilding? The IBM i MCP server is only part of the equation. The full picture includes the agent’s specialized intelligence, its accumulated knowledge, its skills library, and the guardrails that keep it operating safely. How you package all of that into something reusable and maintainable is, I think, one of the harder unsolved problems in the agentic space right now, on IBM i and everywhere else.

The thesis in practice

From what I’ve built and observed, the architectural argument from Section 4 does hold up when agents are running on the system, with some nuances.

The security model works as described. When an agent operates under a user profile, it inherits that profile’s authorities. Early on, an agent was asked to pull data from a table that the user didn’t have authority to. The query failed cleanly, with no data leak, no escalation, and no ambiguous failure mode. That wasn’t because of clever guardrails in the agent framework. IBM i’s object-level security did what it has always done. The agent never had a chance to access that data because the platform prevented it at a level below where the agent operates.

That experience taught me something I now consider basic: the most reliable form of agent governance is governance the agent can’t opt out of. You can build the smartest guardrails imaginable into your agent framework, but if the agent operates on a platform where it could circumvent them given the right sequence of tool calls, you’re trusting the agent to be good rather than ensuring it can’t be bad. IBM i’s architecture removes that trust requirement for the security layer.

The data integration advantage is just as concrete. When I built the first version of the MCP server, I expected to need separate tool interfaces for different IBM i subsystems: one for database queries, one for system monitoring, one for job management, and one for security auditing. Instead, I found that SQL services cover almost everything, including performance metrics, active jobs, PTF status, authority structures, and IFS file operations. Having one interface to the whole system makes agent development much simpler. Fewer tools mean fewer failure modes, simpler testing, and a smaller surface area for things to go wrong.

The audit story has also held up in practice. Every SQL query an agent issues through the MCP server passes through IBM i’s normal security audit mechanisms. We don’t maintain a separate agent audit log, because the system journal captures everything. When someone asks “what did the agent do last night?”, the answer is in the same place it would be if a human had done the same operations. The audit infrastructure that IBM i customers have used for decades works unchanged for agent operations, and we didn’t have to build any of it.

What building this has taught me

I want to close this section with a few less structured observations from building an agentic platform on IBM i.

First, the gap between “agent that can talk to a system” and “agent that can operate within a system” is much larger than it looks from the outside. Getting an agent to issue a SQL query is a weekend project. Getting an agent to reliably triage issues across a team of specialist agents, with appropriate escalation, memory of past interactions, and correct authority scoping, is months of work. MCP solved a real interface problem, but that was only the start.

Second, the modular architecture matters more than I expected. Early on, I tried building comprehensive agents that handled everything. They were brittle, hard to maintain, and difficult to reason about. Moving to focused agents with loadable skills, organized into teams with clear responsibilities, made the system much more reliable. This mirrors how human teams work, which probably shouldn’t be surprising, but it was a lesson I had to learn through building rather than theorizing.

Third, IBM i’s architectural properties reduce the engineering burden in practice. Every governance capability I didn’t have to build in the agent framework is one that I can’t break, introduce bugs into, or misconfigure. The security model, the audit trail, and the data integration all worked without extra effort from us. That freed up engineering time for the problems that need new solutions: agent reasoning, memory management, skill composition, and team coordination. The platform handles the infrastructure problems, so the agent framework can focus on the intelligence problems.

Fourth, and this connects back to the thesis, I don’t think you could build what we’ve built on a platform without these properties in the same timeframe with the same team size. The compensating engineering that other AgentOS frameworks require (building governance layers, integrating data sources, constructing audit infrastructure) adds more than time. It adds ongoing maintenance, security surface area, and complexity that grows with every new agent you deploy. On IBM i, the platform absorbs that complexity, and the agents inherit governed behavior rather than implementing it.

For me, that is the practical case for IBM i as an Enterprise AI Operating System: it is operationally simpler, because the hard problems were solved at the right layer forty years ago.

6. The Road Ahead

I want to end with specifics: where I think this goes, what I think comes next, and what I’m still working through, including the open questions as well as the opportunity.

The MCP infrastructure play

IBM is targeting 500 MCP tools by the end of 2026. I think that’s the right move, and the pace matters. MCP adoption has grown very fast, with 97+ million monthly SDK downloads and every major platform on board, and the organizations that establish rich MCP tool ecosystems earliest will have an advantage as agents become the default interface to enterprise systems.

But tools alone aren’t the full picture. What turns IBM i from “a system agents can talk to” into “the system agents should run on” is the layer between MCP and the platform: the governed runtime, or AgentOS. Five hundred tools exposed through MCP give agents access to IBM i. A governed agent runtime on IBM i gives agents a home on IBM i, where they operate within the security model, accumulate knowledge, coordinate with other agents, and benefit from all the architectural properties I’ve described in this post.

I think the tool expansion and the runtime development need to happen in parallel. Tools without a runtime give you access but not governance, and a runtime without tools gives you architecture but not capability.

The governed autonomy window

Timing matters here. The industry is moving fast on agent deployment and slowly on agent governance. Gartner predicts that by 2028, 25% of enterprise breaches will be traced to AI agent misuse. Forrester expects a publicly disclosed agentic AI breach in 2026. OWASP published a Top 10 specifically for agentic applications. The Cloud Security Alliance built an entire Agentic Trust Framework. NIST launched an AI Agent Standards Initiative. The regulatory pressure from the EU AI Act is building, with full applicability for high-risk systems in August 2026 and no agent-specific guidance expected before 2027.

Based on the security track record so far, I think the first major public agentic AI breach is a question of when rather than if. When it happens, the market conversation will move from “how fast can we deploy agents” to “how safely can we deploy agents.” That shift is IBM i’s window.

IBM i isn’t immune to security problems; no system is. The window exists because IBM i’s answer to the governed autonomy question is architecturally different from everyone else’s. When a CISO asks “how do I know this agent can’t access data it shouldn’t?”, most platforms answer with layers of compensating controls, such as API gateways, policy engines, and monitoring frameworks, all sitting above the OS. IBM i answers at the hardware level, with capability-based pointers, object-level authorities, and a security model that has been C2-certified and running production workloads for decades.

I expect companies to look for that kind of answer once the market gets nervous about agent security.

Knowledge and memory

MCP gave agents tools. The next step is giving them knowledge and memory, and I think this is where the platform can change the most for IBM i customers specifically.

Knowledge through RAG (Retrieval-Augmented Generation) means agents that understand context as well as query databases. An agent investigating a performance issue doesn’t start from scratch every time. It has access to a knowledge base of past incidents, resolution patterns, system-specific quirks, and tribal knowledge that currently lives in the heads of senior admins who are retiring faster than they’re being replaced. The IBM i talent pipeline problem is real, and the community acknowledges it openly. RAG-powered agents don’t replace that expertise, but they can preserve and distribute it in ways that weren’t possible before.

Memory means agents that learn. An agent that helped diagnose a subsystem bottleneck last month carries that context into this month’s investigation. It remembers what worked and what didn’t, and it builds a model of how this specific system behaves under different conditions. Over time, the agent becomes more valuable as its understanding of the environment grows.

I’m excited about this direction, but it’s early. The patterns for how agent memory should work across sessions, teams of agents, and different user authorization contexts aren’t settled. How do you scope memory so that an agent remembers relevant context without leaking information across authorization boundaries? How do you version knowledge bases so that outdated information gets retired? How do you handle conflicting memories when two agents learned different things from similar situations? These are real problems without standard solutions yet.

Still, IBM i’s architecture makes several of these problems easier than they’d be on other platforms. Memory scoping maps naturally to IBM i’s authority model, because an agent’s memory should be governed by the same authorities as its data access. Knowledge bases stored on IBM i inherit the platform’s object-level security. Audit trails for memory operations flow through the same journal infrastructure as everything else. The governance questions around agent memory are hard on platforms where governance is added on top, and more tractable on a platform where it is built in.

What I’m still figuring out

Some of the hardest questions are still open, and I think being clear about that is more useful than false confidence.

The packaging problem is the one I think about most. How do you consolidate tools, skills, knowledge, instructions, and guardrails into composable, maintainable, reusable units? Right now, building a new agent means assembling these pieces from scratch or copying and modifying an existing agent’s configuration. That works at the scale of 28 agents, but it won’t work at the scale of 200. The IBM i MCP server covers only the tools layer. The full picture requires a packaging model for agent intelligence that I haven’t seen anyone, on any platform, get right yet.

The developer experience gap is real. IBM i’s architectural advantages are invisible to a developer who’s struggling with green-screen interfaces, unfamiliar toolchains, and documentation that assumes decades of platform knowledge. PASE and MCP lower the barrier significantly, because a developer can build IBM i agents with Python and SQL without learning RPG. But the barrier is lower, not gone. Making the development experience feel modern while preserving the architectural advantages is a design challenge that requires sustained investment.

The organizational adoption question might be harder than the technical one. There’s a real fear of AI in enterprise environments that comes partly from legitimate concerns and partly from misunderstanding. An architectural argument is necessary but not sufficient. People need to see agents operating safely on their own systems, handling real scenarios, and governed by policies they understand and control. The path from “interesting idea” to “approved for production” runs through trust, and demonstrations build that trust better than arguments do.

And the competitive positioning needs to be clear-eyed. Microsoft’s Agent 365, Salesforce Agentforce, Google’s Agent Development Kit, and AWS Bedrock Agents are well-funded, well-marketed platforms with massive ecosystems. IBM i’s AgentOS story isn’t going to win on ecosystem breadth or developer mindshare. Its strength is architectural depth, specifically on the governed autonomy problem that all those platforms are trying to solve through compensating layers. The argument has to be precise: for high-stakes, governed enterprise operations where the cost of an agent acting outside its boundaries is severe, IBM i offers something architecturally different. It isn’t better at everything, but it is different where it matters most.

The vision, stated plainly

I see IBM i as the trusted kernel of the agentic enterprise.

It isn’t a replacement for cloud-native frameworks, or a competitor to every AgentOS being built on Kubernetes, Azure, or AWS. Its role is more specific: it’s the place where high-stakes, governed agent operations run. That means the platform where agents manage payroll, touch financial data, and operate production systems that can’t go down and can’t leak data. It’s the only platform where governance is an intrinsic property of the operating system rather than an aftermarket addition.

Forty years ago, the designers of System/38 made architectural decisions about how to govern shared resources safely. They couldn’t have imagined autonomous AI agents. But the problem they solved, multiple actors operating concurrently on shared enterprise resources with enforceable boundaries and complete auditability, is the problem the agentic era needs solved.

I think they got the architecture right, and now it’s on us to build what that architecture makes possible.

References & Further Reading

IBM i Agent Infrastructure

Model Context Protocol (MCP)

Agent Operating System Research & Platforms

Industry Research & Market Data

Security Frameworks & Standards

Additional Reading