Lens manages lightweight agents that execute configured workloads beside devices and local systems. Its control plane defines what runs, where and when, then receives typed output and operating state.
Commands and synchronizationOutput and runtime state
Edge runtime
Lens Agent
ConnectorLocal logicTyped output
LinuxWindowsmacOSAndroid
A controlled deployment path
Keep collection logic separate from the place it runs.
Lens turns an edge requirement into an explicit operating contract. Define the workload and its output, configure the local environment, select the agents, schedule execution and keep the resulting fleet visible from one control plane.
01
Define
Package the collection logic and declare the typed output the program is expected to return.
Executable workload02
Configure
Keep endpoints, paths, register maps and environment parameters outside the program.
Reusable configuration03
Target
Use tags and locations to assign each workload to the agents that should receive it.
Explicit scope04
Execute
Run the workload beside the source on a defined schedule and within an explicit timeout.
Local processing05
Operate
Inspect heartbeat, synchronization, system information, logs and deployment state centrally.
Fleet control
Northstar Plant
One control plane. Four technical surfaces.
This isolated industrial fixture uses the current product to model an edge estate. Fleet state, executable collection, environment-specific parameters and deployment policy remain separate, visible and independently manageable.
Observe
Keep the edge estate visible.
Each runtime exposes its platform, location, assigned tags and synchronization state before a workload is allowed to run.
Define
Make collection executable.
Programs package collection logic with a declared output contract. OPC UA, Modbus, equipment logs and infrastructure polling remain distinct workloads.
Configure
Separate code from environment.
Endpoints, register maps, paths and timeouts live outside the program so the same workload can be reused across sites.
Deploy
Bind the runtime contract.
A deployment joins one program, one configuration, a schedule, a timeout and target tags. Matching agents receive the resulting workload.
Lens on Android
Set up on site. Stay connected.
Pair an Android device with Lens, check its connection and inspect runtime logs from the same app.
Know the agent is online.
The device shows its identity, version and connection state. Open the console when you need to look further.
Device-side runtimeConnectionClick screen to enlarge
Technology
A programmable runtime with a central control plane.
Lens combines a Java and Spring Boot service, durable messaging and portable edge runtimes. The architecture keeps workload definition, delivery, local execution and operational evidence as distinct technical concerns.
01
Java control plane
The current core runs on Java 21 and Spring Boot, exposing the management model through a REST API and web interface.
02
Portable agent
A Java 8-compatible runtime supports Linux, Windows and macOS, with a dedicated Android implementation for mobile edge devices.
03
Durable command transport
Apache Artemis and MQTT/JMS carry instructions and telemetry between the central service and intermittently connected runtimes.
04
Declared outputs
Programs state the fields and types they emit, making collected results explicit before a deployment is scheduled.
05
Decoupled configuration
Environment parameters remain separate from executable logic so programs can move across sites without embedding local detail.
06
Tag-based deployment
Programs, configurations, schedules, timeouts and agent tags combine into one controllable execution contract.
07
Runtime observability
Heartbeat, synchronization, system information and logs make the operating condition of each agent available centrally.
08
Persistent management state
PostgreSQL retains the platform model while APIs keep its resources available to automation and adjacent systems.
Practical scope
Start with one inaccessible source.
A useful first scope identifies the data that cannot be collected reliably from a central system, the environment beside it and the smallest output contract that makes that data usable.
The supported runtime depends on the agent package and connector required for the source.
Collection contract
Define the connector, execution and output together.
Devices and sensorsMachines and OT systemsLocal APIs and servicesFiles and operational logsNetwork equipmentProprietary local systems
A source is included when a suitable connector already exists or is implemented for the engagement.
Start with the source
Which operational data never reaches a central system?
Bring one source, the environment beside it and the decision its output should support. We can define the connector, execution location, cadence and output contract before discussing a wider estate.
