# Switch from IBM ODM to GoRules | Decision Engine Migration

> Step-by-step IBM ODM migration guide: export BAL rules, decision tables, and ruleflows, convert them to JSON decision graphs with the AI copilot, and run them on Zen Engine.

v2.0

GoRules Version 2 is here - redesigned, now with managed cloud.GoRules Version 2 is here!

Watch the launch videoWatch

# Switch from IBM ODM to GoRules.

A step-by-step guide to moving your BAL rules, decision tables, and ruleflows to GoRules: export, convert with the AI copilot, validate in parallel, and cut over.

[Start migrating](https://us1.gorules.io) [Talk to an engineer](/contact-us)

## What you get with GoRules

Where your rules land: the parts of GoRules most relevant to this migration.

### Rule changes are live in seconds

Rules are JSON decision graphs (`application/vnd.gorules.decision`). Edit in the editor, publish, and the change reaches production via an atomic `releaseId` swap - the decision cache expires within 5 seconds (`DECISION_CACHE_TTL`, configurable). No build step, no restart.

### Visual editor for developers and business users

Rules are modeled as decision graphs in a web editor: decision tables, expressions, switches, and functions on one canvas. Business users and developers edit the same graph, with changes tracked per release.

### Stateless Rust engine with per-node tracing

The Zen Engine evaluates a decision per request: JSON in, DAG traversal in topological order, JSON out. Each node runs exactly once, and the response can include a per-node trace with input, output, and sub-millisecond timing.

### Native SDKs across languages

The same Rust core ships as `@gorules/zen-engine` for Node.js, `zen-engine` for Python and Rust, `zen-go` for Go, `io.gorules:zen-engine` for JVM (Java and Kotlin), `GoRules.ZenEngine` for .NET, plus Swift, Android, and browser or Lambda via WASM.

## The migration path

A step-by-step route from your current setup to running your rules on Zen Engine.

### 1. Export rules from your IBM ODM project

Export BAL action rules (`.brl` files) and decision tables (`.dta` files) from Rule Designer or Decision Center. For decision tables, also export as Excel via the Business console's Excel export feature. Locate your ruleflow (`.rfl`) files to capture rule execution sequence. Collect BOM verbalizations (`.voc` files) - the AI copilot uses them to understand business term mappings.

### 2. Map IBM ODM constructs to GoRules node types

BAL action rule conditions map to `decisionTableNode` input columns; actions map to output columns. Decision table rows map directly to `decisionTableNode` rows - the `is between` operator maps to Zen range syntax `[100000..300000]`, `is less than` maps to `< 100000`. Ruleflow task sequences map to `switchNode` conditional routing + edge connections in the DAG. `collect`\-style aggregation logic in IRL maps to `expressionNode` chains using Zen built-ins (`sum`, `avg`, `filter`, `map`). Subflow tasks map to `decisionNode` references.

### 3. Upload rule files to the AI copilot

Create a decision document in GoRules and open the AI chat panel. Rename the `.brl` export to `.xml` (BRL files are XML) or paste the rule text into the chat; exported Excel decision tables attach directly. The copilot reads BAL natural language syntax and generates nodes and edges. Decision tables with `is between` operators convert to Zen range tests. Preconditions convert to `switchNode` gates before the decision table node in the graph.

### 4. Rebuild constructs that depend on working memory

IRL technical rules using `modify`, `retract`, and `update` on working memory objects have no structural equivalent in a stateless DAG - redesign as explicit `switchNode` branches and `expressionNode` chains. Rules that trigger other rules via fact changes must be restructured as sequential DAG paths. Ruleflow forks/joins become separate graph branches converging at a common node. `evaluate()` conditions and BOM methods backed by arbitrary Java require rewriting as `functionNode` JavaScript (sandboxed, with `zod`, `big.js`, `dayjs`, `http` imports).

### 5. Validate with the simulator

Run your test inputs through the GoRules simulator. The response includes per-node execution trace - each node reports its input, output, and timing. Compare outputs against your existing baseline. If you have ODM test suites with Excel scenario files, use the same test data as input to the GoRules simulator for direct comparison.

### 6. Swap the API integration

If you invoke rules over REST via a hosted decision service, GoRules follows the same POST/JSON pattern: `POST /projects/:projectId/evaluate/*` with input wrapped in a `context` object and auth via `x-access-token` header. The response returns `{ performance, result, trace }` (`trace` is included when the request body sets `"trace": true`) - no BOM/XOM type mapping required in the request or response. The decision must be published in GoRules before the evaluate endpoint serves it. For embedded JVM use, replace the `IlrJ2SESessionFactory` -> `IlrSessionRequest` -> `session.execute()` -> XOM casting chain with `io.gorules:zen-engine` (Maven Central). Node.js: `@gorules/zen-engine`, Python: `zen-engine`, Go: `zen-go`.

GoRules AI

## Let the copilot do the translation.

The AI copilot uses the underlying LLM's knowledge of BAL syntax to interpret `.brl` files - it is not a deterministic parser, and every generated graph requires human review. BAL `if`/`then`/`else` conditions using business terms map to `decisionTableNode` input columns with Zen unary tests. Decision tables exported as Excel map closely to `decisionTableNode` rows - operator syntax differs but the structure is equivalent. Constructs that depend on working memory - IRL `modify`/`retract`/`update` operations, inference chains where rules trigger other rules, and ruleflow forks and joins - require manual restructuring because GoRules uses stateless DAG traversal, not inference over working memory. BOM verbalizations (`.voc` files) are helpful context for the copilot but do not convert automatically to any GoRules structure - there is no BOM equivalent. Expect the LLM to handle BAL condition-action rules and tabular decision logic well; ruleflows and IRL technical rules need guided copilot conversation or manual graph design.

**On this page**

-   [What you get with GoRules](#what)
-   [Rule changes are live in seconds](#rule-changes-are-live-in-seconds)
-   [Visual editor for developers and business users](#visual-editor-for-developers-and-business-users)
-   [Stateless Rust engine with per-node tracing](#stateless-rust-engine-with-per-node-tracing)
-   [Native SDKs across languages](#native-sdks-across-languages)
-   [The migration path](#path)
-   [1\. Export rules from your IBM ODM project](#export-rules-from-your-ibm-odm-project)
-   [2\. Map IBM ODM constructs to GoRules node types](#map-ibm-odm-constructs-to-gorules-node-types)
-   [3\. Upload rule files to the AI copilot](#upload-rule-files-to-the-ai-copilot)
-   [4\. Rebuild constructs that depend on working memory](#rebuild-constructs-that-depend-on-working-memory)
-   [5\. Validate with the simulator](#validate-with-the-simulator)
-   [6\. Swap the API integration](#swap-the-api-integration)
-   [Let the copilot do the translation](#ai)

## Other migration guides

[View all guides](/switch)

[_Guide_

### Switch from Drools

A step-by-step guide to moving your DRL rules, DMN models, and spreadsheet decision tables to GoRules: export, convert with the AI copilot, validate in parallel, and cut over.

](/switch/drools)[_Guide_

### Switch from FICO Blaze Advisor

A step-by-step guide to moving your SRL rulesets, decision tables, ruleflows, and score models to GoRules: map the BOM to JSON, convert with the AI copilot, validate in parallel, and cut over.

](/switch/fico-blaze-advisor)[_Guide_

### Switch from InRule

A step-by-step guide to moving your .ruleapp rule applications, Business Language rules, and decision tables to GoRules: export, convert with the AI copilot, validate in parallel, and cut over.

](/switch/inrule)

## Leave the build step  
behind.

Bring your IBM ODM rules over, run both engines in parallel, and cut over when the outputs match.

[Get started](https://us1.gorules.io) [Book a demo](/contact-us)
