Architecture overview

JasperNode is deliberately small. Everything in the product is one of three components arranged around a single data structure. Understand those three and you understand the system.

Three components around one data layer

1. The Tag Engine — the data layer. One in-memory tree of tags with publish/subscribe on every value change, persistence, and optional history. It owns no I/O of its own.
2. Logic execution — scripts that compute tag values. Today this is the Logic Cycle (event-driven, reactive). A time-driven High Performance Cycle is on the roadmap.
3. Connectors — readers and writers at the edges of the data layer. They are the only things that talk to the outside world (fieldbuses, networks, clouds, and built-in services).

Every component lives at the perimeter of the Tag Engine and talks to it the same way: by subscribing to tags and writing tags. Nothing reaches around the engine.

Browser IDE                         AI agent (JasperX cloud)
     │                                       │
┌────┴───────────────────────────────────────┴────┐
│                 System connectors               │   IDE · Tools · Logic Cycle
└───────────────────────┬─────────────────────────┘
                        │  subscribe / write
┌───────────────────────┴───────────────────────────┐
│                 TAG ENGINE                        │   one in-memory tag tree
│     pub/sub  ·  history  ·  persistence           │
└───┬───────────────┬───────────────┬───────────────┘
    │               │               │
┌───┴────┐      ┌───┴────┐      ┌───┴────┐
│  OT    │      │  OT    │      │  IT    │      …
│ Modbus │      │  S7    │      │ MQTT   │
└───┬────┘      └───┬────┘      └───┬────┘
    │               │               │
  field           field           broker

This is why the model is easy to reason about: the IDE, the AI agent, the logic cycle and every connector are all just participants that read and write tags. There is no privileged side channel.

The data layer

The Tag Engine holds every value in memory and notifies subscribers the instant a value changes:

• Publish/subscribe on change. Subscribe to a tag, a path, or a wildcard pattern and you receive every change. The IDE, connectors and the logic cycle are all subscribers.
• Change suppression. Writing the same value again (after rounding to the tag’s configured decimals) produces no event — the engine only emits real changes.
• One source of truth. There is no second place where state lives. Configuration, runtime status and live values are all tags.

Details: Everything is a tag.

Logic execution

Scripts are treated as just another participant around the engine. The shipping executor is the Logic Cycle:

• Event-driven. It sleeps until a value that a script depends on changes, wakes, runs exactly the scripts whose triggers fired, then parks again. A one-second safety net bounds any missed wake-up.
• Isolated. Because scripts are user-written code, the Logic Cycle runs in its own sandbox separate from the engine, with a watchdog that aborts any run exceeding 30 seconds. A runaway script cannot freeze the data layer.

A deterministic, sub-millisecond High Performance Cycle (compiled, time-driven) is designed for but not included in the current release. See Logic & the Logic Cycle.

Connectors at the perimeter

A connector bridges the tag tree to exactly one external surface. Connectors come in three kinds — ot (physical buses), it (networks/clouds), and system (built-in services) — and never depend on each other. Each instance owns a small, predictable set of tags for its configuration, its enable switch, and its live status. Connectors are isolated from each other and from the engine, so a single bad connector never takes down the node. See Connectors.

Services above the engine

A few responsibilities don’t fit the “reads and writes tags” shape — they are stateless coordination or policy. These live as services beside the engine, not as connectors:

• Deploy Gate — the test-before-deploy state machine that gates AI-driven changes and records the audit trail.
• AI Rule Registry — hard guardrails every AI action passes through (for example: read a script before modifying it; refuse to delete a tag that other scripts depend on).

See The AI agent & Deploy Gate.

Persistence

JasperNode is an in-memory system that writes through to a single local SQLite database. Tag values and properties — descriptions, script code and its derived input wiring — are saved continuously as they change, so a restart comes back on the state you left. If disk writes fail, the runtime keeps running on its in-memory state — availability first.

A project backup captures your application: all your user tags (with their scripts and descriptions), each connector instance’s configuration, and your saved flows. Host facts, live connector status, engine statistics and logs are left out — the receiving node regenerates them. See System tags.

The whole node in one tree

Because configuration and status are themselves tags, the node is fully described by its tag tree: your application data in user space, and a structured __sys/ tree for host info, node identity, connector config and status, engine statistics and logs. That uniformity is what lets one IDE — and one AI agent — see and operate the entire system through a single interface. See System tags for the map.