Exort Embedded Workspace

Write, compile, and upload microcontroller code from one desktop workspace, with live serial output for feedback.

Source repo
Razz19/Exort
Stars
★ 226
Last updated
16d ago
License
AGPL-3.0
Primary language
Svelte

At a glance

How it runs
Desktop app
Works with
Universal · cross-platform
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Node.js 20 or newernpm 10 or newerGitArduino CLIOpenCode runtime/provider configurationShell / CLINetwork accessLocal filesystem
Typical use
An Arduino or ESP32 developer wants an assistant to inspect, explain, or edit firmware.
Not a fit if
  • Developers who need a general coding desktop without a microcontroller workflow
  • Teams using boards incompatible with Arduino CLI
Source review
64/100 · Some gaps

What does this agent do, and when should you use it?

Exort is an Electron desktop app for projects built on Arduino, ESP32, RP2040, STM32, and similar boards. Its Svelte and Monaco interface connects through preload IPC to an Electron main process that owns the OpenCode runtime, workspace files, Arduino CLI, and serial features. Developers can ask OpenCode to inspect or edit local project code, then compile and upload it to a board and watch device output in the serial monitor or plotter. The app includes free OpenCode models and supports a user-configured OpenCode-compatible provider. It suits embedded developers who want coding assistance alongside firmware and board iteration; actual compile and upload support depends on the board core, toolchain, USB driver, and upload protocol.

After a local project folder is opened, Exort uses OpenCode to inspect workspace files, explain code, and edit files; the project manager persists workspace sessions locally. It can install and manage Arduino CLI board platforms and cores, and provides automatic or manual compile and upload operations. With a board connected, Serial Monitor reads live device output, while Serial Plotter graphs numeric streams. The UI communicates with the Electron main process through preload IPC (window.electronAPI); the renderer does not directly access OpenCode, files, serial ports, or Arduino tools.

  1. An Arduino or ESP32 developer wants an assistant to inspect, explain, or edit firmware.
  2. A prototyper needs a quick cycle for changing code, compiling it, and uploading it to a board.
  3. A hardware debugger needs to inspect boot output, debug logs, or sensor data over serial.
  4. A sensor developer wants to graph numeric serial output to study calibration or runtime behavior.
  5. An embedded learner wants local project, board, and AI-assisted coding workflows in one desktop app.

How do you install or deploy this agent?

Download a desktop build from exort.dev or GitHub Releases. Running from source requires Node.js 20 or newer, npm 10 or newer, Git, and the platform build tools needed for Electron and native Node dependencies. Start from source with:

git clone https://github.com/Razz19/Exort.git
cd Exort
npm install
npm run dev

Arduino CLI and OpenCode runtime/provider configuration are used for board workflows and AI features; the desktop app settings can install the relevant requirements.

How do you use this agent?

Open a local workspace, choose an included free model or configure an OpenCode-compatible provider, then ask Exort Agent to create, inspect, or edit the project. Review changes in the editor, select a target board and serial port, compile and upload, then inspect logs in Serial Monitor or numeric plots in Serial Plotter. The app can check local requirements in settings; from source, run:

npm --workspace @exort/desktop run requirements:status

What are this agent's strengths and limitations?

Pros
  • Combines OpenCode-assisted coding with local firmware project editing in a desktop workflow.
  • Integrates Arduino CLI board platform management, compilation, and upload operations.
  • Includes live serial monitoring and numeric plotting for hardware debugging and calibration.
  • Offers included free models and a bring-your-own OpenCode-compatible provider option.
Limitations
  • Requires a desktop Electron app and its platform build dependencies; it is not documented as a standalone library or server.
  • Compile and upload depend on Arduino CLI, the relevant board core and toolchain, USB driver, and upload protocol.
  • A custom model provider needs OpenCode-compatible configuration, but the README does not give provider-specific setup steps.
  • The README does not specify the costs of particular models or custom providers.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Exort Embedded Workspace This agent 64 · Some gaps Desktop appFree + model costs ★ 226 16d ago Svelte —
Tessera 74 · Some gaps Desktop appFree + model costs ★ 313 3d ago TypeScript Codex · Claude Code
Nimbalyst Visual Coding Workspace 50 · Major gaps Desktop appFree + model costs ★ 1.9k today TypeScript Codex · Claude Code
iPolloWork 44 · Major gaps Desktop appFree + model costs ★ 6.9k today TypeScript —

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
64/ 100 5-point scale 3.2 / 5
Trust 16/29
Reliability 9/14
Adaptability 12/18
Convention 12/18
Effectiveness 10/13
Verifiability 5/8
Why each dimension lost points
Trust16 / 29 · 2.8/5

The README describes renderer access to native capabilities through a preload IPC boundary owned by the Electron main process, and maps workspace files, Arduino CLI, serial access, and local state. This supports some least-privilege and data-flow transparency, but the supplied material does not detail authorization boundaries or per-capability permissions, so neither earns full marks. The recommended workflow has users select a board and port and review edits in the editor, but does not say whether changes, compilation, or uploads require per-action confirmation; user confirmation earns 1. Test source covers managed-runtime integrity checks, path-traversal rejection, migration rollback, and error handling. Credential encryption, retention, and cleanup are not adequately described, and controls or recovery guidance for external effects—especially compilation and upload—are limited. Updater tests show restoration of runtime data and version plus cleanup of a failed candidate, supporting a 3 for rollback. The README, package metadata, and license identify the project and its license, but the author email is empty and no maintainer response or release responsibility is given, so attribution and maintenance responsibility are only partly clear.

Reliability9 / 14 · 3.2/5

The README's product description, feature list, and architecture diagram are broadly consistent, and package scripts expose build and typecheck commands; static material does not establish runtime consistency, so self-consistency earns 2. Dependency versions, Node/npm requirements, and Arduino CLI and OpenCode runtime requirements are described, and the release workflow shows install and packaging steps. The app still relies on external tools, model providers, and compatible board environments, with no availability guarantees, so dependency availability earns 2. Test source covers offline errors, version mismatches, and migration failures, while the updater distinguishes quiet background errors from actionable manual errors. This is source evidence, not an executed result, and there is no comprehensive user-facing error guide, so failure messages earn 2.

Adaptability12 / 18 · 3.3/5

The README names learners, prototyping, and debugging as use cases and lists Arduino, ESP32, RP2040, STM32, and other board families, earning 3 for audience and scenarios. It says support depends on board cores, toolchains, USB drivers, and upload protocols and describes the desktop IPC boundary, but does not comprehensively enumerate Agent operations and limits, so capability boundaries earn 2. Trigger behavior is summarized as asking the Agent and following a recommended workflow; the material does not explain when tools run automatically or which actions require user initiation, so trigger precision earns 1. Desktop and source-run requirements, a Linux GPU startup issue, and board dependencies are documented, but platform-specific adaptation details are incomplete, so environment fit earns 2.

Convention12 / 18 · 3.3/5

The README is organized around features, architecture, requirements, installation, workflow, and supported boards. It is clear but lacks a deeper configuration reference, so information architecture earns 2. Download and source-install steps, common npm commands, and some environment requirements are present, but full troubleshooting and configuration details are missing, so install notes earn 2. Repository and workspace names, version metadata, and commands appear consistent in the supplied material, but evidence is limited, so naming stability earns 2. The recommended workflow and command examples are concrete; no FAQ is provided, so examples and FAQ earn 2. Board support is qualified by local cores, toolchains, drivers, and protocols, and a Linux GPU issue is described; other known limitations are not comprehensively listed, so this earns 2. The README, package.json, and LICENSE all specify AGPL-3.0-only, and the license file is explicit, earning 3. package.json gives version 0.4.0 and the release workflow checks tags against the desktop package version and generates release notes, but no hand-maintained changelog appears in the supplied material, so versioning and changelog earn 2. The package author has a name but no email, and the material does not identify a maintenance team, support commitment, or accountable update path, so maintenance responsibility earns 1.

Effectiveness10 / 13 · 3.8/5

The product combines code editing, compile/upload, serial monitoring, and plotting, and the README gives a workflow for using them in embedded iteration. It does not provide interface or result examples that establish output quality, so output usability earns 2. Integrating an OpenCode coding agent with board management, compilation/upload, and live serial observation offers clear added value for embedded development, earning 3. Free models, bring-your-own providers, and local workspace history reduce some barriers, but users still need runtime, toolchain, and hardware setup; no cost or performance data is supplied, so cost-benefit earns 2.

Verifiability5 / 8 · 3.1/5

The README makes locatable claims about features, requirements, and architecture, while test source gives concrete examples of runtime update, validation, and rollback logic. The supplied material does not map every product claim to implementation or verification records, so claim traceability earns 2. The README, package metadata, release workflow, and test source corroborate aspects of runtime management and release process. Some documented features lack corresponding source evidence here, and workflow configuration is not proof of an executed run, so cross-source corroboration earns 2. The README separates requirements, support conditions, and recommended steps, and test source exposes test scenarios; however, not all product claims are explicitly labeled by evidence status, and static material cannot establish that tests ran, so fact-inference separation earns 2.

Risks and how to mitigate them
  • Static source cannot establish that tests or release workflows ran, or that runtime tool calls, permission prompts, and upload behavior match the documentation.
  • When connecting a provider, users should verify credential storage and data transmission paths; the supplied material does not explain credential protection in detail.
  • Compilation and upload can affect connected hardware. The README has users select a board and serial port but does not specify confirmation requirements or recovery steps for each operation.
Evidence confidence: Low Reviewed Oct 13, 2026 Reviewed revision bd05d654ed9e
See the full review method →

FAQ

Which boards can I use with Exort?
It targets Arduino CLI-compatible platforms, with Arduino, ESP32, ESP8266, RP2040, STM32, and Teensy listed. Actual compiling and uploading also depend on the core, toolchain, USB driver, and upload protocol.
Do I have to supply my own model provider?
No. The README says Exort includes free OpenCode models and can also use a user-configured OpenCode-compatible provider. It does not name specific providers or their costs.
Can Exort run fully offline?
The README does not establish full offline support. AI features require an OpenCode runtime or provider configuration; Arduino and serial workflows depend on local tools and connected hardware.
What if the app fails with a GPU process error at startup?
For Linux startup errors such as “GPU process isn't usable,” the README recommends setting EXORT_DISABLE_HARDWARE_ACCELERATION=1 when launching the AppImage to use software rendering.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents