Skip to content
Back to search

edge-agents

The 30 MB open-source edge AI agent runtime. Run AI agents offline on Linux (Raspberry Pi, Jetson). GPIO, UART, MQTT as first-class nodes. Industrial protocols (OPC-UA, Modbus) on the roadmap.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/foresthubai--edge-agents/badge.svg)](/listings/foresthubai--edge-agents)

HTML

<a href="/listings/foresthubai--edge-agents"><img src="/api/listings/foresthubai--edge-agents/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The lightest path needs no clone and no Docker — just the CLI and the visual builder:

npm i -g @foresthubai/workflow-cli
fh-workflow open my.workflow.json      # opens the visual builder; Save writes back to the file

Don't have a workflow yet? Let Claude Code write one from a single sentence — see [Generate workflows with Claude Code](#generate-workflows-with-claude-code). Ready to run it on real hardware? [Run the engine](#run-the-engine) on the device.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 404 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Edge Agents
  2. **The 30 MB open-source edge AI agent runtime. Run AI agents offline, on Linux.**
  3. [![CI](https://github.com/ForestHubAI/edge-agents/actions/workflows/ci.yml/badge.svg)](https://github.com/ForestHubAI/edge-agents/actions/workflows/ci.yml)
  4. [![Go Reference](https://pkg.go.dev/badge/github.com/ForestHubAI/edge-agents/go.svg)](https://pkg.go.dev/github.com/ForestHubAI/edge-agents/go)
  5. [![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](LICENSE)
  6. ![Edge Agents demo](docs/assets/hero.gif)
  7. > _Build an edge agent visually, deploy it to a Raspberry Pi, and let it talk to GPIO, MQTT and local SLMs — no cloud required._
  8. Offline by default. GPIO, UART, MQTT as first-class nodes. Local SLMs alongside cloud LLMs in the same workflow. Industrial protocols (OPC-UA, Modbus) are on the roadmap.
  9. **Runs on Linux edge devices:** Raspberry Pi 5 · Jetson Orin Nano · STM32MP25 · Bosch Rexroth ctrlX CORE.
  10. ⭐ **Star the repo** if you think AI agents belong beyond the cloud.
  11. > Today's AI agents live in datacenters. The interesting workloads — sensors, machines, vehicles, gateways — live everywhere else. **Edge Agents** brings the agent paradigm to the devices that interact with the real world: small enough to run on a Pi 5, capable enough to drive an industrial controller, with hardware I/O as native primitives instead of REST shims.
  12. ## What you can build
  13. - **Voice assistant on a Pi with a local SLM** — wake-word → STT → agent → TTS, no internet required
  14. - **Predictive maintenance on industrial gear** — live vibration stream over MQTT → LLM decides → MQTT alert
  15. - **Local RAG on a Jetson** _(on the roadmap)_ — answers grounded in live sensor and machine state instead of the public web (today the retriever runs against an external backend; a fully on-device RAG path is in progress)
  16. ## Edge Agents vs other agent frameworks
  17. | | Edge Agents | n8n | LangGraph | Dify | OpenClaw |
  18. | ------------------------------------------- | ----------------------- | --------------- | ---------------- | -------------- | ------------------ |
  19. | **Runtime size** | ~30 MB container | ~500 MB Docker | Python library | ~500 MB Docker | ~1 GB Docker |
  20. | **Offline by default** | ✅ | ❌ | depends on host | ❌ | ❌ datacenter-only |
  21. | **Hardware I/O (GPIO, UART, ADC) as nodes** | ✅ first-class | ❌ | ❌ | ❌ | ❌ |
  22. | **On-device SLM provider** | ✅ typed multi-endpoint | ❌ | partial via libs | ❌ | ❌ |
  23. | **MQTT as workflow transport** | ✅ first-class | community node | ❌ | ❌ | ❌ |
  24. | **Visual builder** | ✅ | ✅ | ❌ code-only | ✅ | ❌ |
  25. | **Industrial protocols** (OPC-UA, Modbus) | on roadmap | community nodes | ❌ | ❌ | ❌ |
  26. ---
  27. # Using Edge Agents
  28. Two pieces: the **engine** (a small container that runs your workflows) and the
  29. **`fh-workflow` CLI** (authors, validates, and visually edits workflow files). You can
  30. run the engine without ever cloning this repo, and author workflows with a single
  31. `npm i -g @foresthubai/workflow-cli`.
  32. ## Quickstart
  33. The lightest path needs no clone and no Docker — just the CLI and the visual builder:
  34. ```sh
  35. npm i -g @foresthubai/workflow-cli
  36. fh-workflow open my.workflow.json # opens the visual builder; Save writes back to the file
  37. ```
  38. Don't have a workflow yet? Let Claude Code write one from a single sentence — see
  39. [Generate workflows with Claude Code](#generate-workflows-with-claude-code). Ready to run
  40. it on real hardware? [Run the engine](#run-the-engine) on the device.
  41. ## Run the engine
  42. The engine ships as a small container you build from [`go/Dockerfile.engine`](go/Dockerfile.engine)
  43. (multi-arch, distroless, nonroot). Most edge targets are `arm64` (Pi, Jetson, STM32MP2,
  44. ctrlX), so the common flow is to cross-build on an `amd64` workstation and ship the
  45. result to the device:
  46. ```sh
  47. cd go
  48. # Cross-build for an arm64 edge device (use --platform linux/amd64 for x86 targets)
  49. docker buildx build -f Dockerfile.engine --platform linux/arm64 -t engine:latest --load .
  50. # Ship to an offline device: save to a tar, copy it across, load it there
  51. docker save engine:latest -o engine.tar
  52. # scp engine.tar device:/tmp/ ← then, on the device:
  53. docker load -i engine.tar
  54. # The engine boots exactly one workflow, read once from ENGINE_CONFIG_FILE.
  55. # A `fh-workflow deploy` bundle wires this up for you (see "Deploy a workflow").
  56. docker run --rm \
  57. -v "$PWD/engine-config.json:/etc/foresthub/engine-config.json:ro" \
  58. -e ENGINE_CONFIG_FILE=/etc/foresthub/engine-config.json \
  59. engine:latest
  60. ```
  61. Building for the same architecture you're already on? A plain
  62. `docker build -f Dockerfile.engine -t engine:latest .` works too — the Dockerfile cross-compiles via
  63. `TARGETARCH`, so QEMU only emulates the trivial copy into the final layer.
  64. The `engine:latest` tag is the one a `fh-workflow deploy` bundle expects (its
  65. `docker-compose.yml` loads the image with `pull_policy: never`), so an image built here
  66. drops straight into a generated bundle.
  67. The engine is a **headless, immutable runner** — it serves no inbound HTTP. It reads its
  68. single boot config (workflow + bindings + device manifest) once from `ENGINE_CONFIG_FILE`,
  69. runs that one workflow, and exits when the workflow does; a boot failure exits the process.
  70. It runs **standalone by default** — no control plane, no account, no inbound port, no
  71. outbound calls beyond LLM provider APIs. Setting `FH_BACKEND_URL` (with `ENGINE_SECRET`)
  72. opts into memory sync only; logs always go to **stdout** (the container runtime captures
  73. them — `docker logs` or your collector), and liveness is observed externally from the
  74. container's exit, not self-reported. Configure via `ENGINE_*` env vars; see
  75. [`go/cmd/engine/config.go`](go/cmd/engine/config.go).
  76. **Hardware access:** the image runs as a nonroot distroless user, so reaching real GPIO,
  77. serial or analog devices needs them passed into the container with the right group — e.g.
  78. `--device /dev/gpiochip0 --group-add "$(stat -c '%g' /dev/gpiochip0)"` (or run with
  79. `--privileged` on a throwaway dev box). Pure-software workflows need none of this.
  80. ## Author workflows
  81. A workflow is a `*.workflow.json` file you author, validate, and open in the visual
  82. builder. Install the `fh-workflow` CLI from npm — no clone required:
  83. ```sh
  84. npm i -g @foresthubai/workflow-cli
  85. # or run it without installing:
  86. npx @foresthubai/workflow-cli <command>
  87. ```
  88. ```sh
  89. fh-workflow open my.workflow.json # open the visual builder; Save writes back to the file
  90. fh-workflow validate my.workflow.json # semantic: wiring, references, types
  91. fh-workflow check-schema my.workflow.json # structural: types, required fields, enums
  92. fh-workflow update my.workflow.json # migrate a workflow to the current schema version
  93. fh-workflow deploy my.workflow.json # generate a self-contained deployment bundle
  94. fh-workflow help # list all commands
  95. ```
  96. `fh-workflow open` _is_ the visual builder — the same React Flow canvas, served locally;
  97. hit Save and it writes straight back to your file. See [`ts/workflow-cli`](ts/workflow-cli)
  98. for the full command reference and the `--static` / `--dev` open modes.
  99. ## Generate workflows with Claude Code
  100. Describe a workflow in plain language and the **`workflow-generate`** skill writes the
  101. `*.workflow.json` and runs the validators for you. Install it into any project with the
  102. [`skills`](https://github.com/vercel-labs/skills) CLI — no clone required:
  103. ```sh
  104. npx skills add ForestHubAI/edge-agents --skill workflow-generate
  105. ```
  106. The skill validates by shelling out to the `fh-workflow` CLI, so install that too
  107. (`npm i -g @foresthubai/workflow-cli`). Then just describe a workflow — e.g.
  108. _"read a sensor every 10s and toggle a relay"_ — and the skill generates and validates
  109. the file for you.
  110. ## Deploy a workflow to a device
  111. **The quick path is `fh-workflow deploy my.workflow.json`** — it inspects the workflow,
  112. asks for the values it can't infer (device paths, broker URLs, model files, API keys),
  113. and writes a self-contained bundle: `docker-compose.yml`, `.env`, the workflow, and any
  114. config files the workflow needs — plus a `README.md` with the build/transfer/run steps.
  115. For an on-device SLM it even drops in a `llama` component wired to the engine over the
  116. compose network. Without a terminal (CI, a Claude Code skill) feed the answers with
  117. `--values <file.json>`. The rest of this section explains what ends up in that bundle —
  118. and how to assemble it by hand if you'd rather.
  119. Prefer to drive it from Claude Code? The **`workflow-deploy`** skill runs this same flow —
  120. reading the workflow, gathering the values, and writing the bundle while keeping secrets as
  121. placeholders. Install it the same way:
  122. ```sh
  123. npx skills add ForestHubAI/edge-agents --skill workflow-deploy
  124. ```
  125. A workflow is **binding-free**: it declares _what_ it needs — channels (GPIO, MQTT, …)
  126. and custom models — but not _where_ those live on a given device. You supply the _where_
  127. in a single boot config mounted into the engine container. See
  128. [`go/docs/workflow-deployment-layers.md`](go/docs/workflow-deployment-layers.md) for the
  129. schemas and deploy-time validation rules.
  130. The engine reads exactly one file at a fixed path — `/etc/foresthub/config.json`, the
  131. `EngineConfig` blob — plus an out-of-band secret document. There are no per-file env vars:
  132. | Mounted file | Holds | When it matters |
  133. | ------------------------------ | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
  134. | `/etc/foresthub/config.json` | `EngineConfig`: `{ workflow, mapping, resources }` — the graph, the logical-id→resource bindings, and every resolved resource (device families + MQTT / LLM / ML endpoints), all in one blob | always — it is the engine's whole input |
  135. | `/etc/foresthub/secrets.json` | resolved credentials keyed by resource id (broker passwords, provider API keys / bearers) | only when a resource needs a secret; absent otherwise (an anonymous broker is valid) |
  136. Within `config.json`, the parts you actually author per deployment are `mapping` (binds
  137. each logical id to a resource `ref`, plus a sub-address for hardware/endpoints) and the
  138. environment-supplied families of `resources` (`mqttBrokers` / `llmProviders` /
  139. `mlProviders`). The device families of `resources` (`gpios`..`cameras`) are device ground
  140. truth; the `workflow` is the binding-free graph as authored.
  141. **Rule of thumb:** a workflow with no channels and only built-in catalog models (e.g.
  142. `claude-haiku-4-5`) needs almost none of this — a `workflow` and the provider's API key in
  143. `secrets.json`. A `mapping` entry and a `resources` entry appear the moment a channel or a
  144. custom/self-hosted model does; hardware adds device families, MQTT and self-hosted models
  145. add the matching endpoint families.
  146. To assemble this by hand instead of with `fh-workflow deploy`: ship the image with the
  147. `docker save` / `docker load` flow from [Run the engine](#run-the-engine) and start it
  148. with `docker run`, mounting the two files above read-only at those exact paths. The repo
  149. ships no static `compose.yaml`; `fh-workflow deploy` generates one per workflow, or write
  150. your own.
  151. ## Features
  152. - **Workflow engine** — typed graph runtime; nodes for LLM calls, hardware I/O, MQTT, web search, memory, control flow.
  153. - **Multi-provider LLMs** — Anthropic, OpenAI, Google Gemini, Mistral, plus a local SLM provider for `llama.cpp` / `vLLM` / `Ollama` / any OpenAI-compatible endpoint.
  154. - **Visual React Flow builder** — embeddable component or runnable as bundled SPA, with typed parameters and live validation.
  155. - **Contract-typed wire format** — every API generated from `contract/*.yaml` for both Go and TypeScript; CI fails on schema drift.
  156. ## Local models (self-hosted SLMs)
  157. Models run on the device through **`llama.cpp`**, in their **own container, separate from
  158. the engine**. Reference the model in the workflow as a **custom `LLMModel`**; the engine
  159. talks to its endpoint over HTTP.
  160. The easy way is to mark that model as **on-device** and let `fh-workflow deploy` add the
  161. `llama` component to the generated `docker-compose.yml` for you — reached by service
  162. name over the compose network, no host networking, no hand-written compose (see
  163. [Deploy a workflow to a device](#deploy-a-workflow-to-a-device)).
  164. That component is built from [`components/llama/`](components/llama), the same way as the
  165. engine image above. It wraps `llama-swap`, so one container serves several models and
  166. renders its own server config from the boot config the bundle writes:
  167. ```sh
  168. docker build -t llama:latest components/llama
  169. # Ship to an offline device: save to a tar, copy it across, load it there
  170. docker save llama:latest -o llama.tar
  171. ```
  172. `llama:latest` is the tag a generated bundle expects (`pull_policy: never`). Put the
  173. `.gguf` weights in the bundle's `workspaces/llama/` directory, and `docker compose up`
  174. does the rest.
  175. A model marked **on the network** instead points at an inference server you run yourself
  176. — any OpenAI-compatible endpoint (llama.cpp, vLLM, Ollama). The bundle does not start
  177. that one for you.
  178. ## Hardware and transports
  179. - **GPIO** via `go-gpiocdev` (digital in/out, edge triggers)
  180. - **ADC / DAC / PWM** via Linux character-device interfaces
  181. - **UART / serial** via `go.bug.st/serial`
  182. - **MQTT** via Eclipse Paho — topic-scoped channels for device-to-device messaging
  183. - **Web search** as a pluggable node
  184. Digital and analog signal types are first-class in the workflow contract.
  185. ## Target hardware
  186. ✅ = brought up and exercised on our own bench. We don't yet publish a per-device CI matrix, so treat these as known-good targets rather than a continuously tested guarantee.
  187. | Target | Status |
  188. | ------------------------------ | ---------------------------------------------------------------------------------------------- |
  189. | Raspberry Pi 5 (8 GB) | ✅ |
  190. | NVIDIA Jetson Orin Nano (8 GB) | ✅ |
  191. | x86 NUC (16 GB) | ✅ |
  192. | STM32MP25 (1 GB, Linux MCU) | ✅ |
  193. | Bosch Rexroth ctrlX CORE | ✅ |
  194. | Other Linux `amd64` / `arm64` | Works, untested |
  195. | macOS `arm64` / `amd64` | Supported (development) |
  196. | Bare-metal MCU (Cortex-M) | Not supported by the Go engine. Contract is portable; dedicated MCU runtime is on the roadmap. |
  197. ---
  198. # Developing Edge Agents
  199. Want to hack on the engine, the builder, or the contract? Clone the repo — `go/` and
  200. `ts/` are independently buildable and releasable; only `contract/` edits touch both.
  201. ```sh
  202. git clone https://github.com/ForestHubAI/edge-agents
  203. cd edge-agents
  204. ```
  205. ## Build from source
  206. **Go engine** (requires the Go version pinned in [`go/go.mod`](go/go.mod)):
  207. ```sh
  208. cd go
  209. go build ./cmd/engine
  210. ENGINE_CONFIG_FILE=engine-config.json ./engine # boots the one workflow it's given
  211. go test ./... # testify-based tests
  212. ```
  213. **TypeScript packages** (Node ≥ 20):
  214. ```sh
  215. cd ts
  216. npm ci
  217. npm run dev # Vite dev server with the visual builder → http://localhost:5173
  218. npm run build # build all three packages
  219. npm run typecheck && npm run lint && npm test
  220. ```
  221. **The CLI from your working tree** — the root `package.json` delegates to
  222. `ts/workflow-cli`, so a single root `npm install` (its `postinstall` builds the `ts/`
  223. toolchain) runs the validators against your local changes instead of the published
  224. package:
  225. ```sh
  226. npm install
  227. npm run check-schema -- my.workflow.json # the -- passes the path to the CLI, not to npm
  228. npm run validate -- my.workflow.json
  229. npm run open -- my.workflow.json
  230. npm run deploy -- my.workflow.json # generate a deployment bundle (--values <file.json> for scripted runs)
  231. ```
  232. After a `git pull` that changed dependencies, just run `npm install` again. If a stale
  233. `node_modules` bites you after switching branches, do a clean reinstall:
  234. ```sh
  235. rm -rf node_modules ts/node_modules && npm install
  236. ```
  237. ## Contract is the source of truth
  238. Every API type is generated from [`contract/*.yaml`](contract) for **both** Go and
  239. TypeScript — CI fails on drift. Never hand-edit generated bindings; edit the contract,
  240. then regenerate both sides:
  241. ```sh
  242. cd go && go generate ./... # → go/api/*/types.gen.go, server.gen.go
  243. cd ts && npm run generate # → ts/workflow-core/src/api/workflow.ts
  244. ```
  245. See [`go/CLAUDE.md`](go/CLAUDE.md) and [`ts/CLAUDE.md`](ts/CLAUDE.md) for the full
  246. contributor guide, conventions, and the domain-layer reconciliation each side needs.
  247. ## Architecture
  248. A workflow is a directed graph of typed nodes — LLM call, hardware I/O, MQTT, memory, control flow, expressions — connected by edges with one of five types: `control`, `tool`, `agentTask`, `agentChoice`, `agentDelegate`. The engine interprets the graph as a state machine: wait for event → execute node → transition. The contract (`contract/*.yaml`) is the single source of truth — Go and TypeScript both regenerate from it, CI fails on drift.
  249. See [`go/CLAUDE.md`](go/CLAUDE.md) and [`ts/CLAUDE.md`](ts/CLAUDE.md) for deeper architecture notes.
  250. ## Repository layout
  251. | Path | What it contains |
  252. | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
  253. | [`contract/`](contract) | OpenAPI 3.0.3 schemas — single source of truth for Go, TS and Python. |
  254. | [`go/`](go) | Engine binary, `camera` capture component, LLM proxy, hardware drivers, MQTT transport. Module `github.com/ForestHubAI/edge-agents/go`. |
  255. | [`ts/workflow-core`](ts/workflow-core) | `@foresthubai/workflow-core` — headless workflow model, validation, (de)serialization. No React. |
  256. | [`ts/workflow-builder`](ts/workflow-builder) | `@foresthubai/workflow-builder` — React canvas component. |
  257. | [`ts/workflow-cli`](ts/workflow-cli) | `@foresthubai/workflow-cli` — the `fh-workflow` CLI + the reference SPA it serves. |
  258. | [`py/onnx`](py/onnx) | `onnx` — generic ONNX inference component (model repository), FastAPI + onnxruntime. Build-yourself image, `pull_policy: never`. |
  259. ## Releases
  260. - **Go runtime** — tagged `go/vX.Y.Z`; consume with `go get github.com/ForestHubAI/edge-agents/go@vX.Y.Z`.
  261. - **TypeScript packages** — `@foresthubai/workflow-core`, `@foresthubai/workflow-builder`, and `@foresthubai/workflow-cli` ship in lockstep at the same version, published to public npm.
  262. - **Container image** — built from [`go/Dockerfile.engine`](go/Dockerfile.engine): multi-arch (`linux/amd64`, `linux/arm64`), distroless, nonroot. Build it yourself (see [Run the engine](#run-the-engine)).
  263. See [RELEASING.md](RELEASING.md).
  264. ## Contributing
  265. See [CONTRIBUTING](.github/CONTRIBUTING.md) and the [Code of Conduct](.github/CODE_OF_CONDUCT.md). Open an issue before any non-trivial change. Every contribution is accepted under a Contributor License Agreement that preserves the dual-licensing model.
  266. ## Security
  267. Do not open public issues for security vulnerabilities. Use [GitHub private vulnerability reporting](https://github.com/ForestHubAI/edge-agents/security/advisories/new) or email **root@foresthub.ai**. See [SECURITY.md](.github/SECURITY.md) for scope and process.
  268. ---
  269. ## Learn more
  270. New to edge AI? These guides on foresthub.ai define the concepts Edge Agents builds on:
  271. - [What is edge AI?](https://www.foresthub.ai/en/glossary#edge-ai) and the [edge agents guide](https://www.foresthub.ai/en/edge-agents): running models and autonomous agents on local devices.
  272. - [On-device inference](https://www.foresthub.ai/en/glossary#on-device-inference) and [small language models](https://www.foresthub.ai/en/glossary#slm): deciding locally without a cloud round trip.
  273. - The full [edge AI glossary](https://www.foresthub.ai/en/glossary) spans foundations, models, agents, safety and industrial integration.
  274. ---
  275. ## Talk to the team
  276. Using Edge Agents in a product, need a license that isn't AGPL-compatible, or want
  277. help getting an agent onto your hardware? Talk to the people who build it at
  278. [ForestHub](https://foresthub.ai):
  279. - 📅 **Book a 30-min call** → https://calendar.app.google/FZ93vzS5zMBc4Kjs7
  280. - ✉️ **Email** → root@foresthub.ai
  281. ---
  282. ## License
  283. Edge Agents uses a **two-tier license model** designed to make the wire format and the headless workflow model maximally reusable while keeping the engine and the visual builder protected under copyleft.
  284. | Component | License | Why |
  285. | ---------------------------------------------------------------------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  286. | [`contract/`](contract) (OpenAPI schemas) | **Apache-2.0** | Wire format. Third-party Python, Rust, or Java clients should be free to implement against it. |
  287. | [`ts/workflow-core`](ts/workflow-core) (headless model) | **Apache-2.0** | Workflow model and validation. Same reasoning — should be embeddable into any TypeScript/JavaScript project without copyleft friction. |
  288. | [`go/`](go) (engine, LLM proxy, drivers) | **AGPL-3.0-only** or **commercial** | Keeps hosted "Edge Agents as a service" offerings honest. For commercial use cases incompatible with AGPL, [book a call](https://calendar.app.google/FZ93vzS5zMBc4Kjs7) or contact **root@foresthub.ai**. |
  289. | [`ts/workflow-builder`](ts/workflow-builder) (React canvas) | **AGPL-3.0-only** or **commercial** | Same dual-license terms as the engine. |
  290. | [`ts/workflow-cli`](ts/workflow-cli) (`@foresthubai/workflow-cli` + reference SPA) | **AGPL-3.0-only** or **commercial** | Bundles the AGPL builder; same dual-license terms. |
  291. | [`py/onnx`](py/onnx) (`onnx` inference component) | **AGPL-3.0-only** or **commercial** | A service shipped alongside the engine; same dual-license terms. |
  292. For the AGPL components, the AGPL network clause applies — providing a modified version over a network requires making the corresponding source available to users of that service.
  293. Third-party components retain their own licenses; see [THIRD_PARTY_NOTICES](THIRD_PARTY_NOTICES) and [NOTICE](NOTICE).
  294. ---
  295. Built by [ForestHub](https://foresthub.ai) — the platform for embedded and edge AI agents. Questions or a commercial use case? **[Book a call](https://calendar.app.google/FZ93vzS5zMBc4Kjs7).**

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.