FREQUENTLY ASKED QUESTIONS

ForestHub is the Edge AI and Agents Orchestration Platform. Workflows are authored as graphs in a visual builder. The engine runs them as a Go binary in a Docker image on Linux edge devices. The graph is the program, the LLM is one node among many — inspectable, replayable, auditable, bounded by design.

ForestHub is designed for engineering teams at machine manufacturers (OEMs), system integrators, and industrial technology companies that need to ship AI agents into products which must pass an audit. Whether you build industrial equipment, building automation systems, or sensor networks — ForestHub gives you on-device intelligence without cloud dependency.

Most AI agent platforms put the LLM in charge — it decides what tools to call and when to stop. That's the right model for chat assistants, but for industrial control it leaves auditors with no way to verify what the system will do. ForestHub inverts the relationship: the workflow is a graph drawn by the builder, and the AI node is one among many. Every possible decision path is visible at design time, every run can be replayed deterministically, and the node cannot reach any tool or system unless an explicit wire grants access. Beyond the graph, the choice of model tier (rule-based logic, classical ML, on-device SLM, or frontier LLM via cloud) adds another control and cost lever: pick what fits each node, on each node.

The ForestHub platform and website are available in English and German. Our engineering team supports projects in both languages.

An edge agent is an AI agent that runs where the work happens — on a Linux edge device, not in the cloud. It perceives local signals (sensors, MQTT, Modbus, OPC-UA), reasons over them, and acts on the physical system without a round-trip to a datacenter. With ForestHub, the workflow is a deterministic graph and the LLM is one node among many — inspectable, replayable, auditable, bounded by design.

You author the edge agent as a graph in a visual builder, then deploy the engine — a small Docker image — onto your Linux edge device, where it runs the agent locally and offline-first. Industrial protocols (MQTT, Modbus, OPC-UA) are wired in as native nodes, and each node can use a rule, classical ML, an on-device small model, or a frontier LLM. The graph keeps every action bounded and every run replayable, so the agent is safe to run next to a machine.

The builder is a canvas where you wire deterministic nodes (read sensor, transform value, branch, actuate), LLM agent nodes, and triggers (sensor events, MQTT, schedules, webhooks, state changes) into a single graph. Every wire is explicit. Every possible flow is visible at design time. Workflows version like code. Deploys roll back like deployments. The platform is built for technical builders — not for citizen developers.

The engine doesn't produce code — it interprets the workflow at runtime. Your workflow is the artifact. The engine is a Go binary in a distroless Docker image (~10–15 MB, `linux/amd64` + `linux/arm64`). It loads `workflow.json`, manages triggers, routes tokens between deterministic nodes and LLM nodes, exposes `/deploy`, `/stop`, `/healthz`.

Any Linux edge device — gateways, NUCs, NVIDIA Jetsons, Raspberry Pis, industrial PCs. The engine targets `linux/amd64` and `linux/arm64`, which together cover 95%+ of the edge/IoT market by volume (Yocto, Buildroot, OpenWrt, Balena, standard distributions all included).

No. The engine runs locally on your edge device. Cloud connectivity is optional — only used for backend-managed LLM routing, telemetry, and remote deploys, all of which can be replaced with self-hosted alternatives. ForestHub Edge runs fully on-prem in air-gapped environments.

Every AI node — whether it's a classical ML model, an on-device SLM, or a frontier LLM in the cloud — only sees the tools the builder wires in: read this sensor, set this actuator, call this sub-graph. There's no generic `read_file`, no `exec`, no MCP server loading arbitrary capabilities. The node cannot access any data or system unless an explicit wire grants it. Deny-by-default at the architecture level — not enforced by sandboxes after the fact. The choice of model tier itself adds another layer of bounding: a classical ML model with a finite output set is more tightly scoped than a free-running LLM.

No. ForestHub's edge-first architecture processes all data locally on the device. No sensor data, machine data, or operational data ever leaves your premises. This is a core design principle, not an afterthought.

Yes. Because data processing happens entirely on-device, ForestHub solutions are GDPR-compliant by design. No personal or operational data is transmitted to external servers, which eliminates most data protection concerns from the start.

Your project data within the ForestHub platform is stored securely in compliance with European data protection regulations. For deployed AI solutions, all operational data stays on your local hardware - nothing is sent to external servers.

ForestHub offers AI assessments, architecture assessments, team enablement training, and full-service integration projects. From initial feasibility analysis to productive deployment - we guide your team through the entire process.

Typically, we start with an AI assessment (1-2 days) to identify use cases and check feasibility. Based on the results, we develop the architecture together and guide implementation. The entire process is hands-on and tailored to your specific requirements.

Our consulting services are relevant for any industry deploying embedded AI: manufacturing, building automation, energy management, automotive, medical devices, agriculture, and logistics. Wherever sensors generate data and intelligent local decisions create value.