Calling a model from RPG is the easy part. The hard part is deciding what an agent is allowed to do, and proving who answers for it when it does. Here is how we answer that on a live IBM i, one rung at a time.
I spent a decade as CTO of a regulated IBM i company. In that seat, nobody ever asked me whether a new system could connect to our core. Of course it could. The question was always the same: what will it be allowed to do, and who signs for it when something goes wrong?
AI agents bring that question back, and they bring it at a scale we haven't seen before.
The connection itself is no longer interesting. Db2 for i speaks SQL and JSON. IBM i can make HTTP calls from SQL. A gateway on a Linux partition can call RPG in a few lines. Any competent IBM i team can wire a model to the system of record in an afternoon. That isn't where projects fail.
They fail at the authority. Across the industry, the numbers say we are handing agents more than we can see:
And the authority is moving faster than the oversight. In Illumio's survey of 1,100 IT and security decision-makers in fall 2026, 70% said they now let AI make decisions that needed a person's approval a year ago. Only 49% can fully see and audit every action an agent takes, and 24% said AI had reached data it shouldn't have.
Our own community is not ahead of this. In the COMMON × Fortra survey of the IBM i community (147 respondents, final results October 2026), 93% of respondents use at least one AI tool, and 15.6% have already built or deployed agentic systems. 44% have no security or governance framework, and only 7% have a comprehensive, active one. Asked for their single largest barrier to AI, more chose security or compliance concerns than anything else.
So here is the way I think about it, and the way we build. An agent doesn't get access to IBM i. It earns it, one class of action at a time. Autonomy starts where mistakes are cheap and works its way toward the actions that matter. Every step up brings its own controls.
We run this on Silver Lake Financial Group, a fictitious lender we built so the ideas would have to survive contact with a real system. The IBM i under it is real. Below, the controls come first, as the rules we hold ourselves to; what's under "On Silver Lake" runs today. I showed an earlier version of this crossing live in my session at IBM TechXchange 2026 in Atlanta; the session deck is online.
| Rung | What the agent does | Reversible? | Binds anyone? | Who decides |
|---|---|---|---|---|
| 1 | Read and inform | Not applicable | No | Agent, logged |
| 2 | Check and prequalify | Fully | No | Agent, logged |
| 3 | Decide, such as underwrite | By compensating entry | Conditionally | A deterministic program. No model makes the call |
| 4 | Bind to terms, move money | Hard or costly | Yes | A named person approves |
| — | Override a governed decision | Not applicable | Not applicable | Nobody. No agent gets a door for it |
The rungs are classes of action, not autonomy levels. Separately, every agent earns its level (read only, recommend, act with sign-off, act within limits) on its own record. The rung says how much is at stake; the level says how much the agent is trusted with it.
For each rung, three questions: what can go wrong, what stops it, and what it looks like on Silver Lake.
What can go wrong
The agent sees more than it needs, and what it sees leaves the building. This is the most common failure in the field, not the most exotic one. In a 1Password survey of 1,000 security and engineering staff in mid-2026, 71% said their agents can reach sensitive information, and about four in ten organizations said their agents reach data outside what anyone approved.
OWASP, the nonprofit security community whose Top 10 lists are the industry's standard checklists, has a name for this: excessive agency. Its three root causes are excessive functionality, excessive permissions and excessive autonomy. Notice that none of the three is about the model. They are all about what we wrapped around it.
What stops it
The LoanIQ gateway runs under its own IBM i profile, with no special authorities. When it tried to read the decision table directly, IBM i refused, and the refusal was logged. The only door it has is the procedure it was granted.
What can go wrong
A confident, wrong answer flows straight into a process. Or a document, an email or a web page tells the agent to do something else, and it does. In that same 1Password survey, 47% of developers said an agent had acted unintentionally after following instructions hidden in a web page, document, email or tool output.
The UK's National Cyber Security Centre has been blunt about this. Prompt injection may never be fully mitigated the way SQL injection was, because a language model draws no real line between instructions and data. Its advice is to reduce the impact. OWASP agrees on the order of things: its first Top 10 for agentic applications, published in December 2025, puts agent goal hijack at number one.
What stops it
Silver Lake's credit agent, Foothold, calls no model, so it shows the other two controls. Every call to the LoanIQ gateway carries a service token for its caller. A caller without one is refused at the network edge, the gateway checks the identity again, and the caller's name is recorded on the IBM i job and on the run. Foothold passed its first gate review on the evidence: its outbound connections are limited to a fixed list enforced in code, a test proves an unlisted destination is refused and logged, and no applicant data appears in its traces or logs. And when we revoked Foothold's credential at the edge, its next call was refused before it reached the gateway. The applicant was told it isn't a decline, never given a default approval.
What can go wrong
A model makes a regulated decision. Nobody can explain the reasons to an examiner, and nobody can reproduce it next month.
What stops it
The model never decides. A deterministic program decides and records its reasons. Where a decision is regulated, this isn't a preference. It's the only design that survives an exam.
Corrections are new entries, never edits. If a decision was wrong, you write a compensating entry and the history stays intact. And the tables behind the decision are owned by a profile no agent or service uses, so no agent can change the rules that guard them.
Foothold sends each application through the LoanIQ gateway, which calls RPG on IBM i. The program decides, and the decision is recorded in Db2 for i, written only through the gateway's one procedure. The first real decision, on test traffic, went through on November 10.
What can go wrong
An agent commits the company to terms, or moves money, on authority nobody actually gave it. Or the authority was real but stale: approved yesterday for a different amount. And governance bends under a deadline: in EY's 2026 survey, 47% of senior AI executives said their organization had skipped its own AI governance process for an urgent deployment.
What stops it
On November 11 we ran this rung end to end for the first time. A fictitious shopper asked for $8,280. LoanIQ on IBM i referred it to Silver Lake's credit desk, where a named person approved it under their own sign-in; the gateway takes that name only from the verified sign-in, ignoring anything in the request. Foothold then showed one offer at LoanIQ's own terms, and the shopper accepted it.
An offer can be accepted only at the terms the lender quoted, once per decision: a rate or term that doesn't match is refused, a second acceptance returns the first, and a decision that was declined or is still referred can't be accepted. The IBM i holds the referral, the desk decision and the acceptance under one decision number, and a gateway restart loses none of them. No money moves. Not every rule above is shown running yet, and I'd rather say so: the approval's expiry window, for one.
There is one action on the ladder with no rung under it: overriding a governed decision. No agent gets a door for it. No procedure exists for it to call.
People ask me whether any of this is IBM i–specific. Most of the ideas aren't. The ladder works on any platform. What's different is where the controls live, and how much you have to build yourself.
On a typical cloud or Linux stack, an agent's identity lives in an identity provider, its permissions in an access policy, its audit trail in a separate logging service, and its transactions spread across services that each own their own database. Each piece is good. They just aren't the same piece. When a business action spans services, there's no single commit. You design compensating steps by hand, and cloud architecture guidance itself warns that those compensations might not always succeed.
On IBM i, the controls are part of the operating system and the database:
| What an agent needs | Typical cloud / Linux stack | IBM i |
|---|---|---|
| Its own identity | A service account or workload identity in an identity provider, separate from the data | A user profile, checked by the OS on every object it touches |
| A narrow door | An API gateway plus app code that enforces scope | A procedure that adopts its owner's authority; the agent can call it but never touch what's behind it |
| All-or-nothing changes | Hard across services; sagas with hand-built compensations | Commitment control across Db2 for i in one unit of work |
| Rules that can't be bypassed | Application code, policy engines | Constraints, triggers and grants owned by a profile no agent uses |
| A record of who did what | Separate log pipeline, often per service | The security audit journal (QAUDJRN), built in; plus journaling on every table that matters |
| Row- and column-level limits | Row-level security in the database (where supported) | Row and column access control (RCAC) in Db2 for i |
That is a real head start. The building code is already in the building.
But I want to be honest about two things, because a CTO who oversells this gets caught.
First, having the controls isn't the same as using them. Fortra's 2026 State of IBM i Security study (June 2026), covering 163 partitions, shows real progress: 96% of systems had the security audit journal on, and the share of users holding all-object authority fell to 8%. The same study found an average of 889 users per system holding job control authority, 10% of systems with default passwords on at least one profile, and only 31% with exit programs covering all 27 common network entry points. Every one of those is a path an agent could use. Agent governance on IBM i starts with the basics most shops already know they should finish.
Second, adopted authority cuts both ways. It's the strongest door IBM i offers, and it travels. IBM's own documentation explains that adopted authority can flow to programs further down the call stack. Design the owning profile and the call chain deliberately, or the narrow door turns into a wide hallway.
Everything above is about the moment of crossing. The harder problem starts after launch.
Agents don't run on IBM i. They run on Linux beside it, or in a cloud, with their own performance, security and cost behavior. So a shop that goes agentic now runs two systems that know nothing about each other: the IBM i it has trusted for decades, and an agent layer it has never had to oversee.
The scale is coming fast. Palo Alto Networks' 2026 Identity Security Landscape puts machine identities at 109 for every human. And in Salt Security's 2H 2026 survey, more than 60% said reconstructing an agent's activity from the day before would take hours or days of manual work. In EY's survey, 26% of executives at companies using agentic AI said they can't detect an unauthorized agent running inside their own organization.
On Silver Lake, one correlation ID sits on the agent's run, on the gateway's run and on the Db2 for i decision record, and the gateway's trace ID is on the IBM i job that did the work. One request reconstructs as one trail. And none of our agents acts on its own without a stop we have tested and recorded.
Behind that sits a simple principle: you should be able to see both systems, the platform and the agents, in one view. Try these on your own shop:
We built the view that answers those. It's called OneLens4i. It runs today on our own agents and our own IBM i; no client runs it yet.
Everything on the ladder uses what an IBM i shop already owns. None of it requires a new platform. All of it requires deciding, in advance, what each agent is allowed to touch.
You can start that this week, before any agent goes near production:
Not sure where your shop stands? The Agent-Ready Read asks eight questions at the level you run the box, takes about three minutes, and needs no account.
The models will change every few months; I track how fast in The Premium Has a Half-Life. The rules you build into your own platform stay yours.
That has always been the IBM i bargain. AI didn't change it. It just raised the stakes.
Built In: what moved on the line this week, in your inbox. Subscribe →
Silver Lake Financial Group is a fictitious company created by Pegasus4i for demonstration; its traffic is test traffic. Pegasus4i is an IBM Business Partner.