DevOps built for Ingenium

Turn Ingenium work into repeatable Flows.

Nexus captures Ingenium operational knowledge in a dedicated toolset. Each tool becomes a Nexus Agent Skill; Echelon combines them into Flows, while Vista brings the right Task and state to developers inside VS Code.

Explore the Flows See the current status

Developer Flow

› work-item / T02073

igit resolve changed source
icomp compile affected programs
ing restart DEV region
flow collect test evidence

One journey · One state · One evidence trail

Skill primitives

Small tools, clear boundaries, composed into larger work

Nexus keeps each operation deterministic and inspectable. The Agent does not need to speak directly to DB2 or Ingenium; it calls a Skill with explicit input, authority and outcome.

DB2, databases and policies

iadm · idb · ipol

Create and configure databases with DB admin authority; back up, restore and refresh Ingenium databases; export or import policies across environments.

Separate DBA operations from daily work
Keep checks before and after change
Support refresh and investigation flows

Ingenium and COBOL

ing · icomp

Start or stop Ingenium regions, compile projects and process only the source actually affected to shorten the feedback loop.

Parallel and incremental compilation
Chain bind, restart and verification
Run from the terminal or a Flow

Source and work items

igit + icomp

Put Git in Ingenium context: work-item branches, golden-point comparison, changed-file discovery and the exact source set passed into compilation.

One context from branch to build
Reduce error-prone Git operations
Produce explicit CI/CD input

Environment and utilities

nexus · dev tools · VS Code

Prepare environment configuration, shared utilities and a basic VS Code integration layer so developers can work in their current context.

Configuration by environment
One developer entry point
Foundation for Vista Tasks in the IDE

Operational flows

Value appears when the Skills work together

A CLI removes a few steps. A Flow that connects the right tools, authorities and checkpoints changes how the team operates Ingenium.

CI/CD for Ingenium

Move a work item from source changes to a release package with evidence.

01Read the branch and golden point
02Resolve affected source
03Compile and bind selectively
04Run checks and collect results
05Hand off for review or deployment

A repeatable pipeline replaces a sequence of tribal commands.

Refresh a low environment

Coordinate the database, Ingenium runtime and post-refresh checks in one journey.

01Confirm source and target
02Stop the affected region
03Back up, restore or refresh the database
04Reconfigure and start the region
05Verify state and hand over

Reduce waiting time while preserving the state of every step.

Copy a policy for support and debugging

Bring the right policy into DEV to reproduce an issue within a controlled scope.

01Receive policy and source environment
02Check authority and target data
03Export the policy
04Import it into DEV
05Prepare the region and debug Task

Support gets a consistent reproduction environment and evidence for comparison.

A Flow does more than add up tool features. It holds ordering, conditions, authority, human checkpoints and the ability to continue after an operation fails.

Inside BENOVA

Echelon orchestrates. Nexus executes. Vista keeps developers in the loop.

The layers share Tasks and Outcomes while keeping separate responsibilities. Nexus can focus on Ingenium knowledge while each Flow remains observable and controlled from end to end.

Flow authority

Echelon

Keeps the Process, emits Tasks, receives Outcomes and chooses the next step.

Ingenium executor

Nexus Agent

Selects and invokes a Skill that fits the Task, environment and granted authority.

Deterministic actions

Nexus Skills

Operate DB2, databases, policies, COBOL, Git and the Ingenium runtime.

Human workbench

Vista for VS Code

Shows Tasks, progress, logs and the points where a developer must review or act.

Developer experience

A dedicated Flow catalog for development environments

Vista VS Code Host can ship with Echelon Local — a compact runtime for one developer, using the same contracts as full Echelon while running DEV-focused Flows.

Build work item Prepare debug policy Reset DEV region Collect test evidence

Vista for VS Code · DEV

Run Flows locallyStart, pause, retry and inspect every Task without leaving the IDE.
Use the active contextA Flow knows the workspace, branch, program or policy the developer is handling.
People and machines share one journeyNexus runs Skills; Vista pauses at the right point for developer review or action.
Share server contractsSuitable Flows can move to Echelon server without changing the Task and Outcome model.

Now / Next

Keep what has been proven, revamp how the parts work together

Nexus does not begin with an architecture slide. The tools and VS Code extension already exist; the next round standardizes them around Agents, Skills and Flows.

NOW · AVAILABLE

The Ingenium tooling foundation

CLI tools for DB2, databases, policies, runtime, compilation and Git
Optimizations built for the Ingenium development loop
A basic VS Code extension
Experience from a real Ingenium system

NEXT · REVAMP

A Flow-driven operating system

Standardize CLI tools as Nexus Skills
Have Nexus Agent execute Tasks from Echelon
Move predecessor workflows into Echelon Flows
Vista VS Code Host with Echelon Local for DEV

There is no single release-date promise. Each Flow will be proven on a real journey before the surface expands.

Start with one Ingenium Flow that is costing the team time.

Choose a journey with clear input, an accountable owner and a measurable result — compiling a work item, refreshing a low environment or copying a policy for debugging. Binean will help separate it into Skills, Tasks and the right control points.

Discuss Nexus View BENOVA