Blog Home

Your Oracle Forms already contain your AI agents' rulebook

Every organization that wants AI agents in its operations runs into the same question: what stops the agent from doing something it should not? For Oracle Forms owners, most of the answer already exists. It sits in the triggers and PL/SQL of their forms, written and refined over decades.

The real question is whether your migration keeps those rules working, or leaves them behind with the old screens.

Illustration: a legacy Oracle Forms screen feeds one rule, shown as a shield, which checks both an employee and an AI agent.

Where your business rules actually live

Ask an Oracle Forms team where the business rules are and they will point at the database packages. Half of the answer is there. The other half is in the forms themselves:

  • WHEN-VALIDATE-ITEM triggers that refuse a date outside the open period;
  • PRE-INSERT triggers that derive a value the user never types;
  • KEY-COMMIT triggers that call a package in a precise order;
  • properties that make an item read-only once a record is posted.

A large application holds thousands of these, written over twenty years by people who have since retired. Nobody has a complete list. Together, they decide what a valid transaction is, who may change what, and when a posting is refused. And each one acts at a precise moment: when a field is left, when a record is saved, when a query returns.

That is exactly what an AI agent needs in order to be trusted in a transactional system. Your forms already hold its rulebook.

Why a rewrite loses the rules an agent needs most

A rewrite loses a rule in one of two ways.

It forgets it. Every rewrite, whether by hand or with a code-generating AI, is built from a specification, and the specification is written from the screens and the obvious workflows. Take a form that 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.

It puts it in the screen. Even when the rule is rewritten, it often ends up attached to the screen: check the posting date when the user leaves the field. For an employee, that works. An agent does not use the screen. It sends the date straight to be saved, and the check never happens.

Either way, the gap costs far more with an agent:

  • With a person at the keyboard, the error surfaces at month end and gets corrected.
  • With an agent executing hundreds of postings a day, the same gap produces hundreds of entries in a closed period before anyone looks.

The rule the agent needed most is the one the rewrite lost.

Why not connect the agent to Oracle Forms as it is?

You can put an agent in front of an Oracle Forms application today, without migrating, in two ways. Each gives up something the agent needs.

Drive the screen. A computer-use agent or a robot works the Forms client like a person, reading the screen, typing and clicking. Every rule still applies. But each action costs seconds and tokens, and every run needs its own Forms session: a convincing demonstration, not a production process.

Go straight to the database. Since July 2025, Oracle has shipped an MCP server for its database, through which an agent runs SQL and PL/SQL directly. It is fast, and it reaches the tables without passing through a single form trigger: the posting-date check never runs. It is the rewrite's problem, without the rewrite.

Migrate the rules, not the screens

ORMIT™-OpenJava does not reinterpret a form. It migrates it. Every trigger, validation and procedure becomes TypeScript that OFCS, the Oracle Forms Compatibility Service at the heart of ORMIT™-OpenJava, fires at the moment Oracle Forms fired it: in the browser as the user works, and on a Node.js validation server with no screen attached.

That moment is the hard part, and Oracle never wrote it down. The Forms manual says which process each trigger fires in, not what happens in between, such as a trigger that fails halfway through a navigation. RENAPS learned it the only way it can be learned: by running the same cases in Oracle Forms and in OFCS and comparing the results, and by fixing, one by one, every difference a real production migration revealed. Each answer is now a test that runs on every release. A model can translate a trigger's code, but not its timing, because the timing is not in the code. A team that migrates with AI alone has to learn it all over again.

The conversion itself is deterministic. It is built on the form's abstract syntax tree, not generated by a model. AI works around it, for testing and for controlled repairs reviewed by people, never as the converter.

In numbers, OFCS reproduces 96 Oracle Forms trigger types, fired at the point where Forms fires them. It makes 284 built-ins available to the migrated code and supports 277 Oracle Forms properties, including full hierarchical tree support. Every save is validated twice: in the browser, then on the validation server before the database. Package logic, constraints and grants stay in your Oracle database, and OFCS is delivered with its source code.

One rule, two callers: the employee and the agent

From the form's point of view, an AI agent is one more caller without a screen. The open connector (MCP) is designed so that the agent works the form the way an employee does: it reads the form's blocks and items, sets values in the form's navigation order so that each item's validation runs, presses the form's buttons and commits. Every one of those actions goes through OFCS.

1 · In your Oracle FormsWHEN-VALIDATE-ITEM
Refuses a posting date outside the open accounting period.
2 · In OFCSThe same rule, as TypeScript
Enforced before the Oracle database, the same for everyone.
3a · EmployeeEnters the date on a React or Angular screen.
3b · AI agentCalls a tool through the MCP connector, under its own identity.
Same check, same answer: a valid entry is saved; a forbidden one is refused with the form's own message, "Posting date is outside the open period."
Illustrative example: a rule written once in the form applies to every caller, on screen or through the connector.

When a trigger refuses an entry, the agent receives the form's own message and stops, as an employee would stop at the same message. Going around the screen does not go around the rules.

Safe by construction, under the same rules as employees

Because the agent goes through the form's rules, the controls come from how the migration is built. They are not instructions added to the agent afterwards:

  • 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.
  • A record of every action. Each one is logged with the rule it went through, the agent that proposed it and the person who approved it.
  • A person approves. The agent prepares, an employee approves: the separation of duties auditors expect stays in place.

No capability depends on the model being right: the model proposes, the rules decide, and a person approves. That matters, because Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027, citing escalating costs, unclear business value and inadequate risk controls (Gartner, June 25, 2025). Oracle Forms owners already have that control: the rules in their forms.

What this means for you

  • Your forms are an asset. Their triggers and PL/SQL are the rulebook an AI agent needs.
  • Choose a migration that keeps the rules executable. A rewrite risks forgetting the very rules agents depend on, or leaving them in a screen the agent never uses.
  • Do not wire the agent around your forms. An agent on the database skips the rules your forms hold; an agent on the Forms screen keeps them but cannot work at volume.
  • One migration serves both. The application your employees use is the one any AI agent operates, yours, a platform vendor's or RENAPS's, without a second migration.
  • Start with one process. Pick one with volume and clear rules, run the agent in observation first, and measure the results before going further.
  • Already migrated with ORMIT™-OpenJava? Your application already runs on OFCS, with the same rules. The first step is choosing a process.

Our white paper, From Oracle Forms to AI Agents, goes further: the 2026 market shift, the rewrite trap, how OFCS keeps the rules executable, the two-tier offer, safe-by-construction controls and the first step, with a source for every figure and quotation.

Download the white paper From Oracle Forms to AI Agents

To see how the migration itself works, visit the ORMIT™-OpenJava product page.

Next in this series: why the rules matter more than the screens, how a single trigger becomes an agent tool, the guardrails that keep an agent within the rules, a practical roadmap, and the most common myths about Oracle Forms and AI agents.