ORMIT™-OpenJava · AI agents

From Oracle Forms to AI Agents. Migrate the rules, not the screens.

ORMIT™-OpenJava migrates your Oracle Forms to React or Angular and keeps every trigger, validation and procedure executable. Your employees work on the new screens, and any AI agent operates the same application, under the same rules, through an open connector.

Download the white paper See how it works

93 Oracle Forms trigger types
232 built-ins
Every save validated twice

2026: the year the market repriced software

Agents are moving the work off the screen.

Enterprise software is sold per seat, and an agent that executes a workflow needs no seat. In early 2026, investors priced that in. Then the market drew the line: software without agents gets repriced, software that embeds them keeps its value.

−25%

S&P Software & Services index, January 12 to February 23, 2026

$285B

Market value erased in a single session after the agent plugins shipped

+41%

The same index from its April 13 low to October 12, 2026, back at its highs for the year

Sources: The Batch (DeepLearning.AI), February 27, 2026; CNBC, September 3, 2026; 24/7 Wall St., October 13, 2026.

40%

of enterprise applications will embed task-specific AI agents by the end of 2026

Up from less than 5% in 2025.

2025: less than 5%End of 2026: 40%

Source: Gartner, August 26, 2025.

>40%

of agentic AI projects will be cancelled by the end of 2027

Escalating costs
Unclear business value
Inadequate risk controls

Oracle Forms owners already have that control: the rules in their forms.

Source: Gartner, June 25, 2025.

Tomorrow’s AI is a bureaucrat

Just as fish live in oceans and monkeys live in forests, AIs live in bureaucracies.

Yuval Noah Harari, Tanner Lecture on Human Values, University of Oxford, 2026

It’s not a tool in our hands. It is an agent with its own hands.

Yuval Noah Harari, same lecture

The bureaucracies that run on Oracle Forms

A bureaucracy is any system that lets strangers trust each other at scale: a bank, an insurer, a hospital’s billing, a ministry’s permits, a payroll. For three decades, a large share of them have been built on Oracle Forms: a trigger on every event, a validation on every field, a procedure behind every button.

The loan it decides onWHEN-VALIDATE-RECORD
The claim it settlesWHEN-VALIDATE-RECORD
The invoice it postsWHEN-VALIDATE-RECORD
The leave it approvesWHEN-VALIDATE-RECORD

The AI bureaucrat will not arrive in a new system. It arrives in yours. It is accepted only if it obeys the rules, and Oracle Forms owners already have them. The only question is whether the migration keeps them.

The rewrite trap

A rewrite reproduces the screen. The rules get lost on the way.

Ask an Oracle Forms team where the business rules are and they point at the database packages. Half of the answer is there. The other half is in the forms, written over twenty years, and nobody has a complete list.

What the specification sees

Every rewrite, by hand or with a code-generating AI, starts from a specification written from the screens.

The screen
The lookup
The save
The trigger nobody asked for

What the form enforces

Behind the same screen:

WHEN-VALIDATE-ITEMrefuses a posting date outside the open accounting period
PRE-INSERTderives a value the user never types
KEY-COMMITcalls a package in a precise order
Item propertymakes an item read-only once the record is posted

One lost rule, and what it costs with an agent

A form refuses a posting date outside the accounting period currently open. The rewrite reproduces the screen, the lookup and the save, but not the trigger, because nobody asked for it.

With a person

The error surfaces at month end, and gets corrected.

With an agent Illustrative

Hundreds of postings a day: the same gap produces hundreds of entries in a closed period before anyone looks.

PathWhat happens to the rules

Rewrite, by hand or with AIRediscovered later, one incident at a time.

A bolted-on assistantUntouched, and the work stays manual: the assistant helps the operator type faster, it does not change who does the work.

Oracle APEX 26.1: forms analysed into a specification, then rebuiltThe triggers become documentation, and the agent’s tools are new code.

ORMIT™-OpenJavaEvery trigger, validation and procedure becomes TypeScript that OFCS runs exactly where Oracle Forms ran it, for the employee and for the agent.

Sources: Oracle, May 2026, Announcing Oracle APEX 26.1 General Availability; Oracle, October 1, 2026, Modernization Forms to APEX Skill.

Migrate the rules, not the screens

The agent and the employee go through the same rules.

OFCS, the Oracle Forms Compatibility Service at the heart of ORMIT™-OpenJava, runs a migrated form’s rules as TypeScript: in the browser as the user works, and on a Node.js validation server with no screen. To the form, an AI agent is one more caller without a screen.

An employee saves a valid entry from the web screen.
OFCS runs the form’s rules, and the database receives the save.
An agent tries an entry the form forbids, through the connector.
The form refuses. The agent receives the form’s own message and stops.

A refusal from the form stops the agent as it would stop an employee.

No path of its own
The agent reaches the database only through the connector and the form’s rules, never around them.
An identity of its own
Its own database account, with only the grants its process needs. Never an employee’s credentials.
Every save validated twice
In the browser as the user works, then on the validation server before the database. Going around the screen does not go around the rules.

OFCS by the numbers

The runtime that keeps your rules executable.

OFCS reproduces Oracle Forms behaviour where the form expects it, and it is delivered with its source code.

93
Oracle Forms trigger types
Reproduced by OFCS, fired at the point where Forms fires them.
232
Oracle Forms built-ins
Available to the migrated code.
240
Oracle Forms properties
Supported by OFCS.
2×
Validations of every save
In the browser, then on the server before the database.

Proven by tests

End-to-end tests are written from the original PL/SQL, and kept only if they fail on a deliberately broken copy of the form.

3,906automated OFCS tests
2,369Java backend tests
303end-to-end scenarios, run on React and Angular

Browser ✓→Node.js validation server ✓→Oracle DB

A deterministic conversionThe conversion is built on the form’s abstract syntax tree, not generated by a model. AI works around it: testing, and controlled repairs reviewed by people.
Delivered with source codeOFCS ships with its source code, under a licence that does not expire.
Your Oracle database staysPackage logic, constraints and grants remain in Oracle. Every write runs under its caller’s own Oracle identity.

Same migration, two more products

The application you migrate is the one agents operate.

The migration delivers screens for your employees. The same application, with the same rules, is what an AI agent operates through an open connector. No second migration.

1The application becomes operable

An open connector (MCP), or the same operations as a command line or a plain API, with the agent’s own identity and a log of every action.

2The agent does the work

Process by process, an agent proposes and your employees supervise and approve, on the application you already have.

The offer

An application any agent can operate.

A migration to agents does not replace a screen with a chat window. It changes what you buy, in two tiers, on one source of rules.

1Tier 1
Agent-ready

Delivered with the migration, or added to it. An open connector exposes the migrated form to an agent: its blocks, items, lists of values and buttons, in the form’s own order. Every call goes through OFCS and the form’s rules.

Whose agent
Any: your own, a platform vendor’s, Oracle’s or RENAPS’s.

Identity
The agent’s own, with only the database grants its process needs. Every action is recorded with the rule it went through.

How it is proven
Tested like the rest of the migration: the refusal test, the identity, the record. No model has to be right.
- MCP
- Command line
- Plain API
- Own identity
- Action log
2Tier 2
Operated processes

One process at a time, an agent takes over the work under supervision: it proposes, an employee approves, the rules apply. You choose the agent and the model, and you set the pace.

Whose agent
RENAPS’s, or the one chosen in tier 1.

Who decides
Your employees approve before anything counts.

How it is measured
Precision on ambiguous cases, cost and time per execution, and the share of cases that no longer need a person.
- Observation first
- Human approval
- Measured cost

Three ways to run a process

Moving a case changes who acts, never what is allowed.

A program, an AI agent or a person on a screen: all three go through the same OFCS rules.

A program
For which cases
Paths that require no judgement: the lines a rule can match on its own, the postings whose every field is known.
Who approves
Nobody, as today. The rules apply.
An AI agent
For which cases
Ambiguous cases: a payment that almost matches, a claim with a missing document, a request that needs a decision within the rules.
Who approves
An employee, who sees what the agent proposes and why.
A person on a screen
For which cases
Where a screen still serves: high-volume keyboard entry, and the exceptions the agent cannot settle.
Who approves
As today.

OFCSThe same rules under all three

The rules say what the form refuses. They do not say which match is right when several are valid: that is the agent’s column, and why approval is not optional.

A worked example

Bank statement reconciliation, with an agent in the loop.

A form found in most finance departments. The migrated application keeps its rules: which lines may be matched automatically, which accounts a posting may touch, what makes a reconciliation complete.

The rulesmatch the lines they recognize, as they already do.
The agentproposes a match for the remaining lines, with its reasoning.
The employeeapproves or corrects each proposal.
The postinggoes through the form’s commit triggers, so an entry the form would have refused is refused again.

The employee’s day moves from typing every line to settling the exceptions.

Bank statement · reconciliationIllustrative

Card settlement2,480.00Matched by a rule✓ Posted
Supplier payment, wire12,300.00Matched by a rule✓ Posted
Cheque 104821,150.00Agent: invoice INV-2291same amount and payeeApproved✓ Posted
Transfer, partial payment7,940.00Agent: 2 open itemsthe total matchesCorrected by the employee✓ Posted
Bank fee35.00Matched by a rule✓ Posted
Deposit, no reference3,000.00Agent: customer receiptclosest open itemApproved✗ Refused by the form: closed period

Rules: 3 lines · Agent proposals: 3 linesPosted: 5 · Refused by the form: 1

Safe by construction

The controls come from how the migration is built.

They are not added to the agent afterwards.

Identity and accountability
Its own database account, only the grants its process needs, never an employee’s credentials. The agent prepares, an employee approves: the separation of duties auditors expect. Every action is logged with the rule it went through, the agent that proposed it and the person who approved it.
Progressive trust
The organization decides the pace, process by process.
1. 1Observation: proposals compared with your employees’ work
2. 2Each action approved
3. 3Only exceptions approved
Your data, your region, your model
Through Amazon Bedrock or Google Cloud Vertex AI, prompts and results stay in your cloud account and region. Nothing is sent to a consumer AI service, and the model can be replaced, including by an open model on your own infrastructure.
A measured cost
Each agent action has a cost. RENAPS quotes it only once measured on a real form, per execution, and you decide whether you pay for the AI on your own cloud account or through the subscription.
The refusal test
When the agent tries something the form forbids, the answer is the same as for a person: the form refuses, the agent receives the form’s message, reports it, and does not work around it.

The context layer Gartner asks for

A migrated form already holds it.

Gartner’s AI context platform, trend 4 of its strategic trends for 2027, has three components. The rules are the one no platform vendor can write for you: they exist only in your forms.

Gartner componentWhat it holdsIn a migrated application
SemanticsOntology, metrics, rules, ownership, policies
The rules: every trigger, validation and procedure of the form, as TypeScript that OFCS executes. Not a description of the rules. The rules.
Operational stateEntities, environment conditions, right-time data
The form’s blocks, items and lists of values, and the live records in your Oracle database, read through the queries the form itself runs.
ProvenanceTracking of data, processes, decisions, actions, outcomes
The agent-ready tier’s action log: for each action, the rule it went through, what the agent proposed and the person who approved it.

Gartner’s guidance is to “separate passive business rules from active, machine-generated decision traces.” The rules are code that does not change when the agent runs; the agent’s reasoning is a trace kept beside them, and it never becomes a rule. OFCS feeds a context platform; it does not replace one.

Source: Gartner, October 20, 2026, Top 10 Strategic Technology Trends for 2027.

The first step

Start with one process. End with numbers.

The first step is the migration itself, then the connector, then one process. It reuses what every RENAPS migration already produces.

Migrate with ORMIT™-OpenJava
to React or Angular, as the migration project already plans. This is the step that keeps the rules executable.
Make the application agent-ready
The connector, the agent’s own identity and the action log. Tested, not measured: the refusal test, the identity, the record, with any agent and any model.
Choose one process
with volume and clear rules: a reconciliation, a claims intake, a permit review.
Write its use cases
in the use-case workbook RENAPS asks for before every proof of concept. It becomes the agent’s task list.
Run it in observation
The agent runs the cases on the migrated forms, observed first. The end-to-end tests written from the original PL/SQL grade every run.
Measure
the share of cases the agent settles, the share it raises, the cost and time per execution, and the time your people get back.
Decide
which column each case belongs to: the program, the agent or a person on a screen. Then move to the next process.

Questions

What clients ask first.

Does the agent replace my employees?

No. It takes the cases your rules can settle and proposes the others. Your employees move from data entry to supervision and exceptions. The share of work that moves to the agent is measured process by process; it is never promised in advance.

What stops the agent from making a costly mistake?

The same rules that stop your employees: the triggers, validations and procedures of your forms, migrated as executable code by OFCS and enforced before the database. The agent has no separate path to the database, and it acts under its own identity, with only the rights of its process, never an employee’s. A refusal from the form stops it, and it reports the form’s message. No capability depends on the model being right: the model proposes, the rules decide, and a person approves.

Who is accountable for an entry the agent prepared?

The person who approved it, as today. The agent prepares, the employee approves: the separation of duties your auditors expect stays in place, and every action is logged with the rule it went through, the agent that proposed it under its own identity, and the approver.

Where does our data go?

To your cloud account and region. Through Amazon Bedrock or Google Cloud Vertex AI, prompts and results stay in your account and region. Nothing goes through a consumer AI service, and nothing depends on one model: your migrated rules are your code, the connector uses an open protocol, and the model can be replaced, including by an open model run on your own infrastructure.

Can we use our own agent, or a platform vendor’s?

Yes. That is the first tier of the offer: the connector exposes the migrated application to any agent, under the same rules, with an identity of the agent’s own and a log of every action. The RENAPS agent is an option, not a condition.

We are not ready for agents yet. Should we still migrate now?

Yes. Oracle Forms follows its own support calendar: Oracle’s published dates give Forms 12c Premier Support until December 2026, and Forms 14.1.2 until 2030. The migration to React or Angular is the first step, and it is the step that keeps the rules executable. The agent is added afterwards, process by process, without a second migration.

We already migrated with ORMIT™-OpenJava. What changes for us?

Your application already runs on OFCS, with the same rules. The first step is choosing a process.

Cover of the RENAPS white paper From Oracle Forms to AI Agents

White paper · October 2026