canonical: https://jentic.com/apis/ibm.com/odm-api

# IBM Operational Decision Manager API

IBM Operational Decision Manager (ODM) is the rule engine and decision platform IBM ships for executing business rules at runtime, used in pricing, eligibility, fraud, and routing decisions. The REST API exposes both the Rule Execution Server (RES) for executing rulesets and the decision services surface for invoking decision models, so external systems and agents can call deterministic decisions without embedding the rule engine. It is suited to teams that want to reuse rule-based decisions across many channels.

## For AI agents

Execute IBM ODM business rules and decision services - call rulesets and decision services with input payloads and get back rule-engine outputs.

## Scope

Does not handle ruleset authoring, deployment from Decision Center, or rule debugging - use for executing and inspecting deployed ODM rulesets and decision services only.

## Capabilities

- List and inspect rule applications via `/v2/ruleapps` and `/v2/ruleapps/{ruleAppName}`
- Execute the latest version of a ruleset via `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute`
- Execute a specific ruleset version via `/v2/ruleapps/{ruleAppName}/{rulesetVersion}/{rulesetName}/execute`
- List and execute decision services via `/v1/decisionservices` and `/v1/decisionservices/{dsId}/execute`
- Inspect server status and diagnostics via `/v2/status` and `/v2/diagnostics`

## Use cases

### Eligibility and Pricing Decisions

Call an ODM ruleset to make a deterministic eligibility or pricing decision - for example, deciding whether an applicant qualifies for a loan or what discount tier applies. POST the input payload to `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute` and ODM returns the rule-engine output, keeping the decision logic in a maintained ruleset instead of scattered application code.

Example prompt: POST a JSON body with applicant income and loan amount to `/v2/ruleapps/loans/eligibility/execute` and parse the decision and explanation from the response.

### Versioned Ruleset Execution

Pin an integration to a specific ruleset version while a new version is being tested in parallel. The `/v2/ruleapps/{ruleAppName}/{rulesetVersion}/{rulesetName}/execute` endpoint takes the version explicitly, which lets release managers run A/B comparisons or roll forward and back without reconfiguring callers.

Example prompt: POST the same payload to `/v2/ruleapps/loans/1.2/eligibility/execute` and `/v2/ruleapps/loans/1.3/eligibility/execute` and compare the two outputs.

### Decision Service Invocation

Invoke a higher-level ODM decision service that may compose multiple rulesets and data lookups. The `/v1/decisionservices/{dsId}/execute` endpoint is the entry point for consumers that should not know the internal rule structure, which makes it the right surface to expose to less-privileged callers.

Example prompt: POST the customer profile to `/v1/decisionservices/fraudCheck/execute` and use the returned risk score to decide whether to clear the transaction.

### AI Agent Decision Caller

An AI agent uses Jentic to call ODM rulesets when a decision must be deterministic and auditable rather than LLM-generated - pricing tiers, eligibility cuts, or compliance rules. The agent searches by intent, loads the execute schema, and posts the input, receiving a rule-engine answer with an explanation. Typical agent integration is under one hour.

Example prompt: Search Jentic for 'execute an ODM ruleset', load the `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute` schema, and run the eligibility ruleset for a candidate applicant.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v2/ruleapps` | List rule applications |
| GET | `/v2/ruleapps/{ruleAppName}` | Get a rule application |
| POST | `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute` | Execute the latest version of a ruleset |
| POST | `/v2/ruleapps/{ruleAppName}/{rulesetVersion}/{rulesetName}/execute` | Execute a specific ruleset version |
| GET | `/v1/decisionservices` | List decision services |
| POST | `/v1/decisionservices/{dsId}/execute` | Execute a decision service |
| GET | `/v2/status` | Get server status |
| GET | `/v2/diagnostics` | Get server diagnostics |

## Key resources

- **Rule Applications** — List and inspect deployed rule applications
- **Rulesets** — Execute rulesets, optionally by version
- **Decision Services** — List and execute composed decision services
- **Server** — Inspect server status and diagnostics

## Why Jentic

- **Setup:** Wiring the IBM Operational Decision Manager API by hand means configuring basic auth against your Decision Service host and port and mapping its ruleset execution routes yourself. Through Jentic you install once, import the IBM Operational Decision Manager API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** ODM puts the rule app and decision service ids in the URL path (`/ruleapps/{ruleAppName}`, `/decisionservices/{dsId}`), so a rule can pin your agent to inspecting and executing one deployed rule app. You choose the operations it may call, so executing a decision service is not included unless you add it.
- **Credential handling:** Your ODM credentials are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'execute a deployed ruleset' or 'list available rule apps', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **IBM Business Automation Workflow API** — BAW orchestrates the long-running process; ODM provides the deterministic decisions that process invokes.
- **Camunda API** — Camunda's DMN engine evaluates decision tables; ODM provides a richer enterprise rule and decision platform.
- **IBM API Connect Management API** — API Connect publishes ODM-backed decision services as managed APIs to consumers.

## FAQ

### What authentication does the IBM ODM API use?

The ODM REST API uses HTTP basic authentication. Through Jentic, those credentials are stored in your Jentic One instance and the agent calls ODM via a scoped Jentic credential, so the basic auth header is never visible in the agent's context.

### Can I execute a specific version of a ruleset?

Yes. POST the input payload to `/v2/ruleapps/{ruleAppName}/{rulesetVersion}/{rulesetName}/execute` with the version path segment. This is the right call when you need to pin an integration to a known ruleset version while a new version is being tested.

### What is the difference between rulesets and decision services?

Rulesets under `/v2/ruleapps/{ruleAppName}` are the unit deployed by the Rule Execution Server, while decision services under `/v1/decisionservices` are higher-level entry points that may compose multiple rulesets and data sources. Pick the surface that matches the abstraction the caller should know about.

### How do I call an ODM ruleset through Jentic?

Search Jentic for 'execute an ODM ruleset', load the `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute` schema, and execute with the input payload. Install the SDK with pip install jentic and use the async search, load, execute pattern.

### Can I check the health of the ODM server through this API?

Yes. GET `/v2/status` returns the live status of the Rule Execution Server and `/v2/diagnostics` returns deeper diagnostics. These are the right endpoints to wire into a readiness or health check ahead of routing rule traffic.

### What are the rate limits for the IBM ODM API?

ODM does not enforce a fixed REST rate limit; throughput depends on the Rule Execution Server configuration and the rule complexity. Treat 429 and 503 responses as backpressure, retry with exponential backoff, and prefer batched payloads where the ruleset supports them.

### Can I limit what my agent is allowed to do with the IBM ODM API?

Yes. Because you self-host Jentic One, your own rules decide which ODM operations and credentials the agent may use, and ODM puts the rule app and decision service ids in the URL path (`/ruleapps/{ruleAppName}`, `/decisionservices/{dsId}`), so you can pin the agent to inspecting and executing a single deployed rule app. You choose the exact operations it can call, so executing a decision service under `/v1/decisionservices/{dsId}/execute` is not available to the agent unless you add it. This lets you allow, for example, only `/v2/ruleapps/{ruleAppName}/{rulesetName}/execute` for one rule app while keeping every other endpoint out of reach.