OpenLegacy Planner is used to analyze legacy environments, model applications and dependencies, and generate structured modernization plans. It supports multiple legacy platforms including mainframe, IBM i (AS400), and distributed on-prem environments.

Planner focuses on deterministic analysis, user-controlled planning, and governed execution through the OpenLegacy Hub.

What Planner Provides

Baseline Modeling

Define your current system landscape by modeling:

Environments (on-prem, cloud, hybrid)
Applications and domains
Gateways and integrations

This baseline represents the starting point for all dependency analysis and planning.

Dependency Analysis

Planner performs deterministic dependency discovery across:

Program calls
Database access
File usage
Batch jobs
Messaging and integration flows

The result is a unified dependency graph that reflects real runtime and data flow relationships.

Plan Generation

Based on the modernization intent you declare (for example: expose APIs, refactor, rehost, hybrid migration), Planner generates:

A structured modernization plan
A set of executable tasks
A phased and prioritized execution order

All generated plans are fully reviewable and editable by users.

Task Export and Execution

Approved tasks can be exported to the OpenLegacy Hub for:

Orchestration
Deployment
Runtime governance
Monitoring and auditing

Governance and Auditability

Planner inherits governance from the OpenLegacy Hub, including:

Authentication and identity management
Role-based access control (RBAC)
API key management
Full audit trails for all plan and task operations

Supported Platforms and Artifacts

Planner supports analysis and modernization of systems built on:

Mainframe – COBOL, JCL, DB2, batch jobs
IBM i / AS400 – RPG, COBOL, DB400, physical and logical files
Distributed on-prem systems – legacy databases, file systems, batch servers
Hybrid environments – mixed on-prem and cloud architectures

Supported artifacts include:

Application code
Database schemas
Files and queues
Batch jobs
APIs and integration flows
Messaging infrastructure

Planner Workflow

1. Model the Baseline

Create environments and define applications, domains, and integrations to represent the existing architecture.

2. Analyze Dependencies

Run dependency analysis to extract relationships between programs, data stores, batch processes, and interfaces. Planner generates a dependency graph from this analysis.

3. Select Modernization Intent

Define the purpose of the plan, such as:

API exposure
Refactoring
Rehosting
Hybrid migration
Data synchronization

4. Generate Plan

Planner generates a phased and prioritized plan composed of executable tasks based on:

Selected intent
Extracted dependencies
Predefined architectural and execution rules

5. Review and Adjust

Users review the generated plan, validate dependencies, adjust scope, and approve tasks for execution.

6. Export and Execute via Hub

Approved plans and tasks are exported to the OpenLegacy Hub for execution, monitoring, and lifecycle management.

7. Monitor and Iterate

Execution status, logs, and audit trails are managed through the Hub. Plans can be revised iteratively based on progress and feedback.

Deterministic Planning and Assisted Classification

Planner is primarily built on:

Static analysis
Metadata extraction
Rule-based planning

In limited scenarios where deterministic classification is insufficient (such as domain clustering), assisted classification may be applied to suggest groupings. All assisted results:

Are optional
Are transparent
Require explicit user review and approval

When to Use Planner

Planner is intended for teams that:

Manage complex legacy environments
Need accurate dependency visibility before modernization
Require traceable and auditable planning
Operate in regulated or security-sensitive environments
Execute staged and controlled modernization programs

Summary

OpenLegacy Planner provides:

Deterministic dependency analysis
User-controlled modernization planning
Structured task generation
Governed execution through the OpenLegacy Hub

It is designed for enterprise-scale modernization programs that require predictability, transparency, and auditability.

Core Concepts

The following core concepts are used throughout Planner:

Environment
A logical boundary that represents where systems run, such as on-prem or cloud.
Application (App)
A functional system or domain composed of programs, data stores, and integrations (for example: Account, Payments, Orders).
Domain
A logical business grouping of functionality. Domains can include multiple applications and help structure large modernization initiatives.
Baseline
A representation of the existing architecture, including environments, applications, and integrations, before any modernization actions are applied.
Dependency
A technical relationship between components, such as program calls, database access, file usage, batch execution, or messaging flows.
Plan
A structured modernization blueprint generated by Planner based on modernization intent and extracted dependencies.
Task
An executable unit of work within a plan (for example: generate API, create proxy, configure bridge, deploy service).

These concepts form the foundation for how Planner models systems, analyzes dependencies, and generates modernization plans.