What is FlexLM (FlexNet Publisher)?

FlexLM (now FlexNet Publisher) is a popular license manager used by high-value engineering, CAD, and scientific software publishers (such as Autodesk, ANSYS, MathWorks, and Siemens). It manages concurrent licensing pools, checking out licenses to active users and checking them back in when they exit the application.

What are the common causes of engineering license waste?

Engineering license waste typically stems from three behaviors: (1) idle sessions, where a user keeps an application open overnight or over the weekend, holding a license token hostage; (2) over-purchasing concurrent pools based on historical peaks rather than average utilization; and (3) double-checkout, where a single user checks out licenses on both a laptop and a workstation simultaneously.

How can I automatically reclaim idle FlexLM licenses?

Use an automated monitoring tool to track active system resource utilization (CPU, GPU, file reads/writes) of the engineering processes. If activity falls below a threshold for more than 30-60 minutes, the tool can gracefully save the user's progress and issue a command to the FlexLM server to reclaim the license token for other users.

Can I optimize AutoCAD licensing without changing my users' workflows?

Yes. By continuously monitoring utilization patterns, you can right-size your concurrent token pools to match actual average demand (plus a safety buffer) rather than buying licenses for every engineer. You can also implement automated idle reclamation that only triggers when the token pool reaches capacity, minimizing user disruption.

AutoCAD & ANSYS License Optimization: The FlexLM Management Guide

The High Cost of Engineering Software

In organizations with large engineering, product design, or R&D departments, specialized software represents a massive budget item. Programs like AutoCAD (Autodesk), ANSYS, and MATLAB (MathWorks) are not priced like standard business applications.

A single enterprise license for these tools can cost anywhere from $3,000 to over $50,000 per user per year.

To manage these costs, publishers historically offered concurrent (floating) licensing models managed by license managers like FlexLM (now FlexNet Publisher). Instead of buying a license for every engineer, you purchase a pool of shared licenses. When an engineer starts the software, a license is “checked out” from the server; when they close it, the license is returned to the pool.

While concurrent licensing is designed to optimize costs, it introduces significant operational waste and governance challenges.

This guide outlines how to monitor, analyze, and optimize your concurrent engineering license pools to reduce software spend without affecting engineering productivity.

The Anatomy of Concurrent License Waste

Unlike standard SaaS applications where waste is characterized by users who never log in, engineering license waste is driven by runtime behaviors:

1. The Idle License Hostage

The most common source of waste is the engineer who opens AutoCAD or ANSYS in the morning, uses it for two hours, and then leaves the application running in the background for the rest of the day — or over the weekend.

While the software sits idle, a license token is checked out. When other engineers try to open the application, they receive a “license limit reached” error. This leads to:

Productivity bottlenecks as engineers wait for licenses to free up.
Artificial demand that prompts IT to purchase more expensive licenses to resolve the bottlenecks.

2. The Multi-Device Double-Checkout

Engineers often work across multiple devices (a primary desktop workstation, a laptop for meetings, and perhaps a remote virtual machine).

If they keep the application open on their desktop while checking it out on their laptop to present in a meeting, they consume two concurrent licenses simultaneously. Most legacy license managers cannot identify that these two sessions belong to the same physical user.

3. The Peak-Demand Trap

IT departments typically size concurrent license pools based on historical peak utilization (e.g., the one day in the year when all engineers happened to be using the software at the same time).

This approach results in massive over-purchasing. A pool designed for a peak of 100 concurrent users may average only 30 concurrent users for 95% of the year.

A Data-Driven Optimization Strategy

To optimize your engineering software spend, move away from peak-based purchasing and implement active utilization management.

Step 1: Establish Continuous Utilization Telemetry

Do not rely solely on FlexLM log files, which only record check-out and check-in times. You must combine server-side logs with client-side active resource utilization telemetry:

Process Monitoring: Track the execution state of the primary application processes (e.g., acad.exe for AutoCAD, ansys.exe for ANSYS).
Resource Signals: Monitor CPU/GPU usage, memory active pages, and file system read/write cycles associated with those processes.
True Activity Classification: Differentiate between a running simulation (high CPU/GPU utilization) and an idle editor window (zero utilization).

Step 2: Implement Automated Idle Reclamation

Once you can accurately detect idle sessions, establish an automated reclamation workflow:

[User Session Idle > 45 Mins]
             │
             ▼
[Is Token Pool Utilization > 80%?] ──► No ──► Maintain License
             │
            Yes
             ▼
[Prompt User via Desktop Notification]
             │
             ├─► User Responds ──► Reset Idle Timer
             │
      (No Response in 10 Mins)
             ▼
[Gracefully Save Work & Release FlexLM License Token]

This workflow ensures that engineers are only reclaimed when there is actual license scarcity, minimizing disruption during low-demand periods.

Step 3: Right-Size the Concurrent Pool

Analyze utilization data over a 90-day period to determine your true 95th percentile concurrent utilization. This metric represents the license capacity required to ensure that engineers experience no access delays 95% of the time.

For most organizations, the 95th percentile utilization is 25-40% lower than the absolute peak utilization. Right-sizing the pool to this level, combined with automated idle reclamation to handle peak demand, can yield immediate six-figure savings at renewal.

Managing the Shift: User Communication and Change Management

Engineers are protective of their tools and often resist license reclamation policies, fearing they will lose unsaved work. To successfully deploy an optimization program:

Guarantee work preservation. Ensure your reclamation system gracefully saves the user’s open files before releasing the license token.
Make check-in seamless. Provide a one-click mechanism for users to request and check out a license when they return to their workstation.
Share the data. Show engineering managers the utilization charts. When they see that 30% of their software budget is spent on idle licenses, they become partners in the optimization effort.

How Mima Optimates Engineering Software Licenses

Mima combines server-side FlexLM log parsing with client-side agentless telemetry to deliver comprehensive engineering license optimization:

True Activity Detection: Measures actual GPU, CPU, and process activity to separate running renders and simulations from idle, minimized windows.
Intelligent Reclamation Gates: Configures automated reclamation workflows that only release licenses when the concurrent pool reaches capacity thresholds, preventing user disruption.
Multi-Device Session Linking: Correlates active sessions across multiple hosts to identify and terminate double-checkouts by the same user.
Right-Sizing Analytics: Computes 95th and 99th percentile utilization curves to recommend the optimal concurrent pool size before renewal negotiations.