DecisionManager

Platform/Decision Manager

Authoring

Author and govern decision logic

Decision Manager is the authoring console — decision-table grid, action-rules editor, ruleflow canvas, tree and template editors — where business and engineering design, test, and govern decision logic before it reaches a runtime. Everything it writes lands in the same governed rule repository the other two consoles read.

Business authors open a grid in a meeting; architects keep hit policies, vocabulary and Git review under one repository. Policy changes ship without a release train.

Get started

No credit card · Trial does not auto-convert · Export anytime

Decision Manager

Authoring & governance

Where business and engineering design, test, and govern decision logic.

Built for
Business analysts and rule authors
  • Decision-table grid, action-rules editor, ruleflow canvas
  • Version lifecycle, Git review, rule-aware pipelines
  • AI-assisted authoring and dry-run testing (human review required)
Open the console

Capabilities

What it does

Real surfaces: table grid, action-rules and ruleflow editors, tree/template editors, pipelines and Git review — from blank artifact to published version without leaving the console.

  • Author

    Decision-table grid, action-rules editor and ruleflow canvas, plus tree and template editors for structured artifacts — with hit-policy evaluation and BAL type validation as you edit.

  • Govern

    A version lifecycle with structured diff, Git review (commit summary, drift explain) and rule-aware delivery pipelines — so a change is reviewable before it is published.

  • Test

    AI-assisted authoring and dry-run / test-suite runs, so the effect of a rule change is visible before it is promoted. AI never auto-publishes.

At a glance

  • Decision-table grid, action-rules editor, ruleflow canvas
  • Tree and template editors for structured artifacts
  • Rule-aware pipelines and Git review (commit summary, drift)
  • Dry-run and test suites before promote — AI never auto-publishes
  • Same repository Decision Server executes (content-hash provenance)

Authoring surface

Everything your rule authors and architects open daily

Decision tables with hit policies, multi-stage ruleflows, AI drafts with mandatory human review, BOM vocabulary, governed promotion into the warehouse, and VS Code when engineers prefer disk — one console, one repository.

  • Hit policies

    Decision tables & hit policies

    Author complex grids with ODM-familiar hit policies, compound conditions and BAL type validation as you type — then compile to multi-key indexes so lookups stay fast as tables grow.

    • First, collect, rule-order and related hit policies on the grid
    • Overlap, gap and unreachable-row analysis before publish
    • Compiled indexes — not a linear scan when candidate rows climb
  • Multi-stage

    Visual ruleflow designer

    Compose multi-stage flows with gateways and branches on a canvas policy owners can read in a review. Structure and task order stay explicit — no hidden orchestration buried in code.

    • Canvas gateways, branches and ordered tasks
    • Business-readable layout for meeting walkthroughs
    • Same governed lifecycle as tables and action rules
  • Human-in-the-loop

    AI authoring — human review required

    Draft BAL rules, tables and tests from plain language across multi-provider chains with ordered fallback and content-hash cache. AI never auto-publishes; every draft waits for a person.

    • Multi-provider chain with fallback on rate-limit or 5xx
    • Content-hash cache so re-runs are genuine re-runs
    • Draft → review → approved → published — always
    Learn more
  • Vocabulary

    BOM vocabulary & data contracts

    Authors write business phrases against a versioned vocabulary — the BOM — not raw field paths. Verbalization, sensitivity flags and publishable grammar keep models and rules aligned.

    • Versioned vocabulary with verbalization, not free-text paths
    • Sensitive / PII member flags travel with the model
    • API testing workbench for the same data contracts
    Learn more
  • SoD enforced

    Governance, pipelines & warehouse

    Draft → review → approved → published with separation of duties, structured diff, Git review and rule-aware pipelines. Published versions feed the decision warehouse for post-hoc explanation.

    • Structured version lifecycle with review gates
    • Git commit summary, drift explain and delivery pipelines
    • Warehouse KPIs and traces after execute — no hot-path tax
  • Git-friendly

    VS Code for engineers

    Pull rule projects to disk as plain JSON, edit with the BAL language server and tests, then push back with the dm CLI — same repository the browser console governs.

    • BAL LSP diagnostics against the live vocabulary
    • Inline test runner and quality-gate friendly CLI
    • No release-pinned Eclipse desktop for day-to-day edits
    Learn more

Built for both sides of the table

Exciting for business authors — solid for architects

Policy owners change a table in the meeting that decides it. Platform architects get hit-policy honesty, vocabulary versioning, SoD and a path into Git — without splitting Decision Center from Rule Designer.

Business authors

Change policy without waiting on a release train

Open the grid, ruleflow or action-rule editor, dry-run the change, and send it through review. AI can draft the first pass; you still own every publish.

Architects & leads

One repository, explicit residual honesty

Hit policies, BOM vocabulary, content-hash provenance and pipelines sit in one model. Prefer IDE workflows? VS Code and the dm CLI stay on the same governed path — no shadow rulebase.

In the studio

Editors and AI assist — human review required

Draft decision tables and action rules from a plain-language brief in the studio, then review in the real editors and promote under governance — nothing auto-publishes.

Decision Manager authoring studio with AI-assisted draft and editors

Audience

Who uses it

Business analysts and rule authors, working alongside the engineers who own the data model. It is the console a policy owner opens; it is not where production traffic is operated — that is Decision Server.

Migration

What it replaces in an IBM ODM estate

In an ODM estate, authoring happens in the Eclipse-based Rule Designer desktop application and governance in a separate Decision Center with its own database schemas. Decision Manager is both, in one browser console over one repository — and for teams who prefer to work in an editor, rule projects can be pulled to disk as plain JSON and edited in VS Code.

Bringing an existing estate across starts with the ODM migration assessment, which reads a Rule Designer or Decision Center export in your browser and inventories what is in it.

Next step

Author your first decision — or walk it with an expert

Start a free trial with Decision Manager included, run the zero-signup live demo, or book a meeting with an executive seller on your underwriting, claims or eligibility policy.

No credit card · Trial does not auto-convert · Export anytime