What Is an Edge Agent? Definition and Architecture

Most AI agents live in the data center. Every decision is a round trip to the cloud, sensor data out and answer back. At the machine, that is rarely practical. Latency is too high, connectivity is not guaranteed, the data should not leave the plant, and running costs scale with every call. This is exactly where a different design comes in, the Edge Agent. An AI agent that runs not in the cloud, but directly on the device itself.

What is an Edge Agent?

An Edge Agent is an autonomously operating AI agent that executes locally on the edge device, on the machine, the controller, the gateway, or a single-board computer such as a Raspberry Pi or a Jetson board. It does three things, all of them on site.

• Perceive. It reads sensors and data sources, such as digital inputs (GPIO), analog values (ADC), serial interfaces (UART), or messages over MQTT.
• Reason. It assesses the situation at the appropriate level, with a rule, a classical ML model, or a small language model running directly on the device.
• Act. It switches outputs (GPIO, PWM, DAC), writes parameters, or publishes a message.

The decisive point is that it is local. On-device AI means perception, decision and action happen on the same piece of hardware. An Edge Agent is therefore not a model you call somewhere, but a complete perceive, reason and act loop at the point of action. With a local model it works offline, and without a cloud call or web search, no data packet leaves the device.

Graph-first means the graph is the program

What makes an Edge Agent predictable is its inner structure. In an Edge Agent the workflow graph is the program, and the AI is one node in that graph, not the conductor above it.

This is the inversion of the common pattern where a language model sits in a loop and decides for itself which tool to call next. In a graph-first Edge Agent, the flow is laid out in advance. A trigger starts the graph, the nodes execute in a defined order, and branches are visible. The result is threefold.

• Deterministic. The same input runs along the same path.
• Inspectable. Every step is a named node, every edge a traceable transition.
• Bounded. The agent can only do what is in the graph. No open loop, no uncontrolled tool access.

Security here does not come from after-the-fact guards, but from the design itself, namely local execution, container isolation, and an auditable, bounded graph. This architecture is built from the ground up for the security requirements of the EU Cyber Resilience Act, with CRA readiness as a property of the architecture, not a label applied afterwards.

The intelligence cascade

Not every task needs a language model, and the most expensive level is rarely the right one. An Edge Agent grades its intelligence to actual demand.

1. Rules. Thresholds and state logic. Fast, deterministic, free.
2. Classical ML. Classification and anomaly detection on narrow models.
3. On-device SLM (1 to 3B). A small language model directly on the device, via a local, OpenAI-compatible inference server next to the engine.
4. Mid-size open-weight model. When more language understanding is needed.
5. Frontier cloud LLM. The exception, not the rule.

The practical finding is that a large share of industrial tasks fit a small language model running locally. The cloud is then the special case, not the default, and that is precisely what makes local AI in industry viable.

Edge Agent, cloud agent, TinyML and chatbot compared

• Cloud agent. Calls a data center. Powerful, but dependent on connectivity, latency and running costs, and the data leaves the plant.
• Pure TinyML inference. A single model on the microcontroller that outputs a number. No perceive, reason and act loop, no branching, no memory.
• Chatbot. Waits for text and answers with text. No sensors, no actuators, no trigger from the physical world.
• Edge Agent. Closes the full loop locally, with hardware I/O as first-class nodes, a graded intelligence, and a durable local memory.

An example from building automation

A plant operator monitors a pump and compressor station. An Edge Agent runs on a small controller right at the station. Through an analog input it reads the inlet pressure, and a threshold trigger with deadband reacts only when the value genuinely leaves a band, with no chatter. The agent classifies the operating state locally, and when an intervention is needed, it writes a new setpoint. It never touches the deterministic control loop directly. It delivers the parameter buffered, while the actual controller keeps running undisturbed. The agent publishes the station status over MQTT to the supervisory level. In its local memory it keeps the recent trends to place recurring patterns over time.

How it works at the edge

Technically, the Edge Agent is a single binary that runs on the given hardware, from a Raspberry Pi through a Jetson board to an x86 industrial computer. Moving from the Pi to stronger hardware means redeploy, not rewrite (bench-tested). The hardware interfaces are first-class nodes on real Linux drivers, with GPIO digital, ADC, DAC and PWM analog, UART serial, and MQTT as both a publish target and a triggering subscription. The trigger set covers interval, alarm and time, delay, threshold with deadband, pin edge, serial receive, and MQTT message.

The small language model runs via a local, OpenAI-compatible inference server right next to the engine. For knowledge there is a searchable knowledge base with semantic search, and web fetch and web search are their own nodes once a network is present. For operating across many devices there are an Agent Registry, fleet orchestration, and federated learning, which improves the model across many identical devices without centralizing the raw data. You build visually in the builder or through the CLI, and the core is open source and usable without an account. From Hardware to Intelligence.

Key Takeaways

• An Edge Agent is an AI agent that perceives, decides and acts locally on the edge device, instead of in the cloud.
• Graph-first means the graph is the program and the AI is a node, deterministic, inspectable, bounded.
• The intelligence cascade grades from rules through classical ML to an on-device SLM, and the cloud is the exception.
• The same binary runs from Raspberry Pi to x86, with hardware I/O as nodes, a local model, offline capability, and durable memory.
• Unlike a cloud agent, TinyML or a chatbot, the agent on the machine closes the full loop on site.