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 ready for 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 the local 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, so 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 safe to 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 ready for 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 and 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 under AGPL-3.0.
Common questions about edge agents
What is an edge agent?
An edge agent is an AI agent that runs directly on a local device instead of in the cloud. It reads local signals from sensors and industrial protocols like MQTT, Modbus and OPC-UA, reasons over them and acts on the physical system without a round trip to a datacenter. Latency, privacy and availability stay under local control.
How do edge agents differ from cloud agents?
Edge agents decide and act locally on the device while cloud agents send data to remote servers for every decision. Edge agents therefore keep working when the connection drops, respond in milliseconds and keep sensitive data on site. Cloud agents scale compute more easily but depend on connectivity and add latency to every action.
How is LLM behavior bounded in an edge agent?
The workflow graph bounds the model. An agent node only sees the tools that are wired into the graph, so the LLM cannot invent new capabilities at runtime. Every possible decision path is visible on the canvas, every run is replayable and every actuation is limited to what the graph allows.
What hardware do edge agents run on?
Edge agents run on ordinary Linux edge devices. The ForestHub engine ships as a small multi-arch Docker image for amd64 and arm64, so gateways, industrial PCs and compact single board computers in the field all run the same workflow without recompilation.
Are edge agents open source?
Yes. The edge-agents repository on GitHub contains the Go engine, the LLM proxy, the language neutral workflow contract and the visual builder under the AGPL-3.0 license. The stack runs standalone and offline, no account and no external service is required.
Guides on edge AI agents
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.
See the safety patterns·Read the edge AI agent guides·Browse the edge AI glossary
Explore More
Explore the visual orchestration platform for edge AI agents.
Six patterns that make LLM agents safe enough for industrial control.
Answers to common questions about ForestHub and Edge AI.
ForestHub vs n8n, Node-RED, Litmus Edge and LiteRT-LM. Honest comparisons with sources.