> For the complete documentation index, see [llms.txt](https://docs.heisenware.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.heisenware.com/reference/glossary.md).

# Glossary

The words Heisenware uses in the App Manager, the App Builder, the App Player, the assistant and these docs

These are the words Heisenware uses everywhere: in the App Manager, the App Builder and the App Player, in what the assistant says, and on these pages. Each term has one meaning, and the same thing always has the same name.

## Product, places, people

**Heisenware**: the platform you build and run industrial Apps with.

**Account**: your organization on Heisenware, reached at its own address, e.g. `acme.heisenware.cloud`. It holds members, workspaces, plan and billing.

**Workspace**: an isolated area inside an account with its own Apps, databases, files, agents and integrations. Every account starts with one: `default`.

**Domain**: a workspace's technical name, `<account>.<workspace>`, e.g. `acme.default`. It appears in App URLs and client credentials.

**Member**: a person who belongs to the account and builds or manages Apps in the Manager and the Builder.

**Owner**: a member who decides who else takes part. An owner of the account holds the plan and the members and reaches every workspace. An owner of a workspace builds there and chooses who else does.

**Editor**: a member who builds in a workspace.

**User**: a person who uses an App in the Player. *Also called:* App user.

**App**: what you build: pages, executors and widgets, living in a workspace, reachable at its own URL and installable on a device. *Also called:* application.

**App Manager**: where members create and run Apps and manage the account. *Also called:* Manager.

**Dashboard**: the App Manager's first page: what needs you in the workspace, and how its Apps run and are used.

**App Builder**: where members build one App. *Also called:* Builder.

**App Player**: what runs an App for its users, in the browser or installed on a device. Users see their App's name; members may see "App Player". *Also called:* Player.

**Assistant**: the AI built into Heisenware. In the Manager it plans Apps with you; in the Builder it builds with you. It follows the platform law. *Also called:* AI assistant.

**MCP server**: a workspace's tools for your own AI client. Reached by the workspace's MCP address (AI clients), or as a local MCP server on your computer (Integrations).

**Local MCP server**: a package a member installs on their own computer for an AI client there (Claude Code, Claude Desktop, Cursor): the same tools, with the member's local files.

**Platform law**: the rulebook for how Heisenware works and how Apps are built well. The assistant follows it, and these docs agree with it.

**Project notes**: the workspace's shared written memory (requirements, decisions, data model), kept as files. Together with the files you upload for the assistant they form the *project knowledge*, listed beside the assistant chat in the Manager.

**Inform Heisenware**: the assistant's report card for a platform defect. Nothing is sent unless you click.

**Ask**: lets an App's invited users ask an AI about the workspace's data and run the App's endpoints, in the App's own panel or from their own AI client by the App's Ask address. A member switches it on per App; it holds only on an App that invited users alone can open.

**Report**: a document Ask makes of an analysis for a user: PDF, Word, Excel or CSV, in the App's look. It belongs to the user who asked.

## Builder: its parts

**Explorer**: the Builder's left panel, with five tabs: Functions, Pages and actions, Files, Variables, Endpoints.

**App editor**: the Builder's main editor, where an App is built: the Flowboard and the Page editor side by side, with the Explorer and the Console.

**Flowboard**: the Builder surface where you place and wire executors. It holds the logic of the whole App, which runs even when no page is open.

**Page editor**: the Builder surface where you design a page for each screen.

**Console**: the Builder's bottom panel. It holds the assistant.

**Theme editor**, **Template editor**, **Database editor**: the Builder's other editors: for the App's look, for PDF templates, and for looking into and editing the workspace's databases.

The Database editor is the workspace's, not an App's: it opens from the Builder's toolbar inside any App, and from the App Manager's "Databases" entry without one. Its left panel is the **Databases explorer**: the database chosen (source, storage type, instance) and what it holds.

**Data model**: the shape of the workspace's own database: its tables, their fields, keys and audit logs, and the relations between them. It is kept inside the database, with a history of who changed what, and shaped in the Database editor's Model tab or by the assistant. An App's versions never touch it. *Also called:* model.

**Adopt**: the data model takes what the database holds where the two differ: a table, field or relation made outside the platform (by SQL from elsewhere, by a database import, or by an App built before the model was kept), or one dropped outside it. The database stays as it is.

**Drift**: where the workspace's database differs from its data model, because something was made or dropped outside the platform. Adopt ends it.

**Audit log**: a table's record of every change of a row, with who made it. Once on it stays on, and the platform alone writes it.

**Data source**: a database or time-series database a flow of the workspace has connected, as the data tools read it. It is named `agent/instance`.

**Trace**: highlights what feeds a node (upstream), what it feeds (downstream), or both.

## Logic on the Flowboard

**Node**: anything placed on the Flowboard: an *executor node*, an *extension node*, a *section node* or an *annotation node*. Use the word sparingly, where the element on the board is meant rather than the concept.

**Flow**: a chain of wired executors that carries one piece of logic.

**Function**: one piece of code a class offers, e.g. `read` of the OPC UA client. You find functions in the Functions explorer; dragged onto the Flowboard, a function becomes an executor.

**Class**: a set of functions that belong together, e.g. `OpcuaClient`, `Counter`. A class can describe how to create instances of itself. *Also called:* blueprint.

**Instance**: a living object of a class, such as a connection, a buffer or a counter, with a name. It exists from its creation until it is deleted, and every App of the workspace reaches it by its name.

**Function kinds**: *static function* (needs no instance), *constructor* (creates an instance), *destructor* (deletes one), *instance function* (acts on one instance), *subflow*.

**Tools**: the everyday functions the Flowboard toolbar offers directly: echo, memory, trigger, combine.

**Agent**: a program that offers classes to the platform. The *internal agents* come with Heisenware (Connectors, Utility Functions, Data Analysis). *Native agents*, *Docker agents* and *LXC agents* you install inside your own network, where they reach machines the platform can't.

**Executor**: calls one function on the Flowboard and manages everything around the call: where it runs (address), what goes in (inputs), when it runs (trigger), and what comes out (outputs). *Also called:* executor node.

**Address**: where an executor's function lives: agent, class and, for instance functions, instance. Each part is fixed, or dynamic, taken from a value at run time; one executor can so reach many targets.

**Item**: any connection point of an executor: an input, the trigger, an output.

**Input**: a value the function receives, in the order of its arguments. It gets a default, a wire, a widget link or a `$variable`. *Also called:* argument, parameter.

**Handler**: an input that is itself a function the backend calls back. An *event* is called again and again (`onChange`), a *callback* once. *Also called:* listener.

**Event function**: a function that calls a handler again and again until it is released, e.g. `onChange`. It declares itself with `@returns {Registration}`; without a declaration, a name of `on` followed by a capital letter makes it one.

**Subscription**: an executor's standing wish to receive the events of one event function, with its inputs, on its targets, in one scope. Triggering declares it; it pauses with the App and ends with its scope.

**Registration**: the one call of an event function on an instance with one set of arguments, shared by every subscription that asks for the same. The agent makes and ends it.

**Trigger**: what makes an executor run. It holds a list of trigger sources; any one of them firing runs the executor. A value arriving at an input never runs it by itself.

**Trigger source**: one reason to run:

* *reactive*: an item receives a value, on every update, on change, on true, or when all have updated
* *lifecycle*: App start (with an interval: polling), App stop, browser reload
* *UI*: page load, widget event
* *subflow start*
* *manual*

**Hot input**: an input that also runs its executor whenever it receives a value. *Also called:* reactive input.

**Polling**: running an executor at a fixed interval from App start.

**Loop**: running an executor once per element of a list, one after the other; results come back as a list. *Zip loop*: several lists together, row by row. *Also called:* one by one.

**Output**: what an executor gives back: its *return*, and an *event output* for each value an event or callback delivers. Every output can carry wires, links and extensions.

**Wire**: a connection between two executors on the Flowboard, carrying a value from an output to an input or trigger.

**Extension**: a step attached to an output that works on its value: *modifier* (reshapes, JavaScript or JSONata), *filter* (lets it through or stops the branch; the platform's "if"), *recorder* (keeps its history), *error handler* (catches failures). Extensions chain into a pipeline. *Also called:* extension node.

**Expression**: the single JavaScript expression in a modifier or filter, working on `x`.

**Scope**: where a value lives and a run happens:

* *shared*: one for the whole App
* *user*: one per connected user
* *call*: one per subflow call

Widget events run in the user's scope, while App start and polling run in the shared scope. A backend event arrives in the scope of its subscription.

**Variable**: a named value of the App, used as `$name`. A static variable is a constant; a runtime variable is written by an output or extension and keeps its value. Variables never run anything themselves.

**Secret**: a variable or input whose value is masked everywhere, used for credentials.

**`$USER`**: the built-in variable naming the user whose scope a run happens in; empty in the shared scope.

**`$LOCALE`**: the built-in variable holding the App's language as a locale tag (`de-DE`); the same in every scope.

**`$TIMEZONE`**: the built-in variable holding the time zone of the user's browser (`Europe/Berlin`); empty in the shared scope.

**Endpoint**: an executor published under a stable public name so that other Apps and external systems can run it. Endpoints are the actions; variables are the values.

**Section**: a titled, colored frame around executors that form one stage of the logic. It is purely visual. *Also called:* section node.

**Annotation**: a documentation card on the Flowboard (text, tables, pictures, diagrams) that explains more than one executor. *Also called:* card, annotation node.

**Comment**: the short note on one executor or one extension, saying why it is there. It is shown on the node.

**Description**: an executor's function documentation, shown on hover; it comes from the function's code, not from you.

**Subflow**: a section published as a reusable executor. The *blueprint* holds the logic; each *caller* runs it in its own call scope.

**Status**: the colored dot on an executor: whether it is ready, slow, failed, or cannot reach its function.

## Pages and widgets

**Page**: one screen of an App, built from widgets. *Top-level pages* fill the navigation menu; a *subpage* hangs off one of them and is reached by a link.

**Screen**: one device class an App is designed for, such as Phone, Tablet or Desktop. An App enables some of them. The two tablets are the handheld tablet held upright (`__tablet`) and the panel mounted at a machine (`__tabletR`).

**Reference screen**: the screen a widget is first placed on; its other screens follow it automatically until you arrange them yourself (*authored*). An App's reference screen is the one most of its widgets reference; a new App starts on the widest screen it serves.

**Pin**: gives one screen its own value for one widget setting; unpinned settings are shared by all screens. Some settings are *pinned by nature* because their right value depends on the screen.

**Widget**: an element on a page that shows data, takes input or starts something. The categories are display, input, trigger and layout.

**Text box**: a widget for static text (Markdown), such as titles, labels and instructions.

**General tab**: the first tab of every widget's settings, listing its properties under *Receives* and *Emits*.

**Property**: something about a widget that can be linked: a value it shows, or a value or event it emits.

**Setting**: something about a widget you configure in its settings, such as color, columns or scale.

**Link**: a connection between a widget property and an executor item, or between a button or output and a page or App action. *Also called:* binding.

**Widget event**: something a user does to a widget, e.g. a click, that can fire triggers.

**Group**: a widget that holds other widgets (its *children*) and repeats them, one *tile* per data row.

**Tile**: one repetition of a group's children, showing one data row.

**Sticky**: a widget that stays where the screen puts it while the page scrolls beneath it: a header bar, a footer, a back-to-top button.

**Navigation menu**: how users move between top-level pages, e.g. bottom tabs or a drawer.

**App action**: an effect on the App itself: switch page, log out, reload, go back, open a link. Dropped on a button it runs on click; linked to an output it runs on every truthy value.

**Theme**: an App's look: a base theme plus the variables changed on it, such as accent, backgrounds, font and radius.

**Language**: the one language an App speaks, set in the Manager. An App in another language is another App, a translated copy.

## Building, testing, releasing

**Test**: runs the App in the Builder with its triggers armed; nothing changes for users.

**Deploy**: makes the current version the one users get. *Also called:* release.

**Version**: a saved state of an App. A *checkpoint* is a version saved during building (by you or the assistant) to go back to; a *release* is a version deployed to users.

**Rollback**: makes a saved version the App's current state again.

**Bundle**: an App exported as a `.hwt` file, carrying its files and the shape of its tables, but no rows and no secrets. It can be imported into another App or another platform. *Also called:* `.hwt`.

**Suite**: several Apps that work together and share data through named instances and endpoints.

## Connecting and administering

**Native agent**: an agent built in the Manager for the host it runs on, with its credentials inside. It connects outbound only.

**Docker agent**: an agent as a container, with credentials passed in at start.

**LXC agent**: an agent for INSYS routers.

**Fleet**: native agents built under one fleet name and updated together.

**Rollout**: bringing a new build to the native agents of a fleet.

**Connector**: a class that talks to an external system or protocol (OPC UA, S7, MQTT, databases, …).

**Add-on**: an optional module that runs as its own container and brings new classes (RAG AI, your own code).

**Integration**: a login for something outside that connects to a workspace: an MQTT client, a VRPC client, a local MCP server or a Microsoft 365 Copilot agent.

**Access mode**: who can open an App:

* anyone
* anyone with the *master password*
* users who sign up
* users who sign up and know the master password
* invited users only

**Master password**: one password shared by everyone allowed into an App.

**Plan**: what the account may use and what it costs, shown under Plan & billing.

**Files**: the workspace's shared files (images, templates, uploads, agent builds, backups), managed in the Files explorer.

**VRPC**: the open-source protocol all parts of Heisenware talk over. Only developers need it.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.heisenware.com/reference/glossary.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
