Explanation: Engine Licenses
Engine licenses control how many active USoft runtime processes can run simultaneously. This article explains the different types of engine licenses, how they are consumed, and how they relate to each other.
What Is an Engine License?
An engine license grants permission for a single runtime process to execute. Without a valid engine license, a USoft runtime component cannot start. The number of engine licenses in your entitlement determines how many processes can run at the same time.
Engine licenses only cover runtime — the tools you use to build an application, such as Definer and Web Designer, are licensed separately as Development Tools under Developer Licenses.
There are three categories of engine license:
| License Type | Consumed by | Unit of consumption |
|---|---|---|
| Engines | Rules Services | One license per running Rules Engine instance |
| Client Server Engines | Windows Client Server applications and RunBatch.exe | One license per machine, shared by all processes on that machine |
| Peak Engines | Rules Services (overflow) | One license per Rules Engine instance above the base Engine limit |
These three categories exist because Rules Services and Windows client processes don't consume compute resources the same way. A single Rules Service can spin up many Rules Engine instances to handle concurrent load from many users and APIs, so it makes sense to license that workload per instance. A Windows client or RunBatch process, on the other hand, is inherently tied to the machine it runs on — so licensing it per machine, rather than per process, matches how that workload actually scales. Peak Engines sit on top of the base Engine model as a way to absorb temporary overflow without changing either of those underlying rules.
Engines
An Engine license is consumed each time a Rules Service starts a Rules Engine instance. The total number of Engine licenses in your entitlement is the maximum number of Rules Engine instances that can run simultaneously across your environment. Licensing by instance, rather than by Rules Service, means your entitlement scales with actual concurrent usage instead of with how many services you happen to deploy.
For example, if your entitlement includes 10 Engine licenses, no more than 10 Rules Engine instances can be active at the same time — across all Rules Services and all machines.
Client Server Engines
A Client Server Engine license is consumed per machine, not per process. All USoft Windows applications and RunBatch.exe processes running on the same machine share one Client Server Engine license. The underlying question this model answers is "how many machines are running USoft client software," not "how many processes are running" — so consumption is scoped to the machine.
This means a machine running multiple applications simultaneously uses only one Client Server Engine license. However, each additional machine that runs USoft client software requires its own Client Server Engine license.
Batch jobs
Batch jobs can be started two ways; calling the batchrunner component inside an already-running engine, or by launching RunBatch.exe as its own process.
This means that the required license for starting a batch job depends on how the batch job was called.
| You call it from… | Using… | Why |
|---|---|---|
| A running Rules Engine | The batchrunner component | The job runs inside the Rules Engine process that's already started — no new process, so nothing new to license. It uses the Engine license the Rules Engine already holds. |
| A running Rules Engine | RunBatch.exe | RunBatch.exe starts as a separate process on the server where the Rules Engine runs. It draws from the Client Server Engine pool, not the Engine pool the Rules Engine itself uses. |
| A Client Server application | The batchrunner component | The job runs inside the C/S application that's already open. It uses the Client Server Engine license the application already holds. |
| A Client Server application | RunBatch.exe | RunBatch.exe starts as a separate process outside the open C/S application, and does draw on the Client Server Engine pool — but per the per-machine model above, the station already holds a license, so no second one is consumed. |
Peak Engines
Peak Engines are an optional add-on to the base Engine entitlement. They allow your environment to temporarily exceed the standard Engine limit when demand spikes, without requiring a permanent increase to your base license count.
Key characteristics of Peak Engines:
- Peak Engine licenses are always cloud-based, even in an otherwise network-licensed environment. They require a separate Sentinel Key.
- They must be explicitly enabled in the Rules Service configuration. See How to configure Sentinel Keys.
- If your entitlement does not include Peak Engines, the Enable Peak Engines setting in the Rules Service configuration is inactive.
Peak Engines require a separate license agreement. Contact your USoft account manager for details on adding Peak Engines to your entitlement.
How License Consumption Is Tracked
License consumption is tracked in real time by the Thales Runtime service. You can inspect current consumption — including active sessions and available capacity — in the Thales Sentinel Admin Control Center.
License Connection Loss
Both the Rules Service and client server applications hold a license session for each engine they use. Every 15 minutes, the engine checks that this session is still valid.
- If the session was manually ended — for example, by killing it from the Admin Control Center — the engine stops immediately, and a client server application quits.
- If the check fails to get a response at all, such as due to a network problem, the engine keeps running for up to 45 minutes, retrying every 15 minutes (up to three attempts). If the connection is still lost after the third retry, the engine shuts down.