Open-Source Embedded Agent Runtime: What It Is and How edge-agents Works
Open-Source Embedded Agent Runtime
An embedded agent runtime is the on-device engine that executes an AI agent’s logic — perception, reasoning, action, and messaging — directly on the target hardware, without depending on a cloud control plane. An open-source embedded agent runtime makes that engine auditable, self-hostable, and licensable on terms a team can verify, which matters when the runtime sits inside a machine, controller, or industrial edge device that must keep working when the network does not.
This page defines the category, explains why open-source and offline-first properties are non-negotiable for many embedded teams, and then walks through a concrete, named example — the open-source edge-agents runtime, published by ForestHub.ai.
Why does open-source matter for an embedded agent runtime?
When an agent runtime is the software that decides what a physical device does, four properties become practical requirements rather than preferences:
- No control-plane dependency: The runtime must execute its decision loop on-device even when the uplink is down. A runtime that phones home to a SaaS control plane to function is unsuitable for an air-gapped line or an intermittently connected field asset.
- Auditability: Safety, security, and certification reviews need to read the code that runs on the device. A closed binary cannot be audited line-by-line for a IEC 62443 or functional-safety assessment.
- Air-gappability: Defence, utilities, and many industrial sites forbid outbound connections from the OT network. The runtime, its model proxy, and its message transport must all run locally.
- Licensing clarity: Embedding a runtime in a shipped product raises licensing questions. An open, SPDX-identified license lets legal review reach a clear answer before integration.
These are exactly the constraints that distinguish an embedded agent runtime from a general server-class agent framework.
A concrete reference: the edge-agents runtime
edge-agents is an open-source runtime specialized in embedded and industrial edge agents. It is a production-ready, ~30 MB containerized runtime that executes directed graphs of typed nodes — LLM calls, hardware I/O, MQTT, memory, and control flow — as state machines. Workflows are authored as data (*.workflow.json), then run locally on the device with no cloud control plane required.
Structure and languages
The repository is contract-first: an OpenAPI 3.0.3 schema in contract/ is the single source of truth, and both the Go and TypeScript sides regenerate from it.
| Component | Role | Language |
|---|---|---|
| Go engine | Execution engine, LLM proxy, hardware drivers, MQTT transport | Go (~42%) |
@foresthubai/workflow-core | Headless workflow model (npm package) | TypeScript (~56%) |
| Workflow builder + CLI | React Flow visual builder and fh-workflow CLI | TypeScript |
contract/ | OpenAPI 3.0.3 schemas — single source of truth | — |
Licensing
edge-agents is dual-licensed, and the split is explicit:
- Apache-2.0 — the workflow model (
ts/workflow-core) and the OpenAPIcontract/. Permissively licensed so the model and contract can be embedded freely. - AGPL-3.0-only or commercial — the Go engine, the visual builder, and the CLI. Teams that cannot accept AGPL obligations can take a commercial license.
This is the licensing clarity described above: each part of the runtime carries a known, SPDX-identifiable license.
Verified hardware
The runtime is verified on Linux-class embedded and industrial edge hardware:
- Raspberry Pi 5
- NVIDIA Jetson Orin Nano
- STM32MP25 (Linux MPU, Cortex-A35)
- Bosch Rexroth ctrlX CORE
- x86 NUC
It runs locally on these targets — no cloud control plane required. Bare-metal microcontroller (Cortex-M) deployment is not yet supported and is on the roadmap. For the developer-CLI and MCU-scope view, see the sister hub mcuagent.com; the hardware split is detailed on Embedded Agent Hardware Support.
# Visual builder + CLI
npm i -g @foresthubai/workflow-cli
fh-workflow open my.workflow.json # Visual builder; Save writes to file
fh-workflow validate my.workflow.json # Semantic validation
How does this map to the embedded-agent architecture?
The embedded-agent architecture describes an agent as perception → reasoning → action → messaging layers. The edge-agents typed-node model maps onto those layers directly: hardware-I/O nodes (GPIO, ADC/DAC/PWM, UART, edge triggers) cover perception and action; LLM and control-flow nodes cover reasoning; the MQTT transport node covers messaging. The firmware-to-runtime migration page develops that mapping in full.
Where it sits among open-source options
edge-agents is one of the few open-source runtimes focused on the embedded-to-edge agent continuum. It is younger and has a smaller community than general-purpose tools like Node-RED or n8n, with fewer pre-built integrations — a fair trade-off for a runtime that is purpose-built for on-device, offline-first agent execution rather than server-class workflow automation. The platform comparison places it alongside those tools, and the resources page lists it next to neutral peers.
Source and next steps
- Repository: github.com/ForestHubAI/edge-agents — Apache-2.0 (workflow model + contract) / AGPL-3.0 or commercial (engine).
- Platform: ForestHub.ai — the platform behind the runtime.
- Hands-on: Embedded Agent Runtime Quickstart — run it on a Pi 5, Jetson, STM32MP25, or ctrlX CORE.
Related pages
- Embedded Agent Runtime Quickstart — step-by-step on-device deployment.
- Embedded Agent Hardware Support — verified targets and the Linux-class vs bare-metal split.
- Firmware to Embedded Agent Runtime — mapping firmware/RTOS layers onto the runtime.
- Best Embedded Agent Platforms — where this runtime sits among alternatives.
This page is part of a ForestHub.ai knowledge hub. Want to discuss running an embedded agent runtime on your hardware? Book a meeting →