EDGE AGENTS
AI agents that run where the work happens.
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. ForestHub makes edge agents you can run in production: the workflow is a deterministic graph, the LLM is one node among many — inspectable, replayable, auditable, bounded by design.
What is an edge agent?
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. Because it runs next to the machine, it keeps working when the network is down, responds in real time, and keeps operational data inside your network. The agent is not a chat assistant bolted onto a device: it is a bounded decision process wired directly into perception and actuation.
Edge agents vs cloud agents
Both are "AI agents." The difference is who is in control and where the agent runs — and for anything next to a machine, that difference decides whether the system is safe to deploy.
Cloud agent
- The model drives the loop: it decides which tools to call and when to stop.
- Runs in a datacenter — every decision needs a network round-trip.
- Behavior is emergent; the set of possible actions is hard to enumerate ahead of time.
- Stops working — or stalls — when connectivity drops.
- Operational and sensor data leaves your network to reach the model.
Edge agent
- A bounded graph drives the loop; the LLM is a single, replaceable node within it.
- Runs on a Linux edge device, next to the sensors and actuators it controls.
- Every possible action is wired at design time and verifiable before deployment.
- Keeps running offline; cloud is optional, not a dependency.
- Data stays local; it leaves only when an explicit step sends it.
Where a cloud agent lets the model drive and hope, an edge agent runs a bounded graph where the LLM is a single, replaceable node and every action is verifiable — the only kind of agent you can safely put next to a machine.
Why edge agents must be bounded
Next to a machine, a wrong decision means a relay actuates or a setpoint changes. "Let the model figure it out" is not an acceptable failure mode on a factory floor. An edge agent earns the right to act by being bounded by design — not by a sandbox bolted on after the fact.
01The workflow is a deterministic graph
The program is a graph you draw, not a loop the model improvises. Every possible decision path is visible at design time, and the same inputs always produce the same path.
02The LLM is one node among many
The model is a single node wired into the graph — replaceable by a rule, a classical ML model, or a smaller on-device model. It can only reach the tools an explicit wire grants it.
03Every run is replayable and auditable
Each execution can be replayed deterministically and inspected step by step. An auditor can see exactly what the agent did and why — a requirement, not a feature, for industrial systems.
04Actions are bounded by design
The agent cannot actuate anything that was not wired into the graph. Capability is deny-by-default at the architecture level, which is what makes the agent safe to run next to physical equipment.
How ForestHub delivers edge agents
ForestHub is the graph-first engine for building edge agents you can run in production — from the visual builder down to the binary on the device.
Graph-first engine
Author the agent as a graph in a visual builder; the engine interprets it at runtime. No per-device code generation, no recompile per target — the graph is the program.
Runs on the Linux edge
The engine ships as a small distroless Docker image (amd64 + arm64). It runs the agent locally on the Linux edge device, offline-first, with cloud as an optional convenience.
Industrial protocols first-party
MQTT, Modbus TCP/RTU, and OPC-UA are wired in as native nodes, so the agent perceives and acts on real industrial signals without glue code.
Bounded multi-model orchestration
Each node picks its own tier — rule-based logic, classical ML, an on-device small model, or a frontier LLM. The graph keeps every node bounded and replaceable.
The engine, LLM-proxy, workflow contract, and visual builder are open source in github.com/ForestHubAI/edge-agents — AGPL-3.0.
Build edge agents you can put in production
Draw the graph, wire in your protocols and models, and ship a bounded agent to your Linux edge devices.