One stable contract
A small gRPC protocol: discover the board, read and drive GPIO, tail and assert logs, run bounded commands. The same call shape against the local simulator or a real board.
Product · EdgeEmbed HIL · Open source
Hands and eyes for AI agents on hardware
AI agents now write embedded software, but they can't validate it blind: the edit → deploy → observe → fix loop has to close on real hardware. EdgeEmbed HIL is the open protocol that lets an AI agent, a test script, or your CI discover a target board, drive its pins, watch its logs, and run bounded commands — with a local simulator so you can start without any hardware at all. Our first fully open-source product.
EdgeEmbed HIL ArchitectureOne gRPC contract from client to hardware
AI agent · MCPTest scriptCI runnerGo client helpersConformance checksYour tools
EdgeAgentServiceThe gRPC protocol
01Describe · Health02GPIO read / drive03Log tail / assert04Deploy exec
profile.jsonBoard profile · friendly aliases · read/drive permissions
Local simulator · PCAgent daemon · boardGPIO providerLog providerDeploy provider
Why it's different
A validation loop an AI agent can actually drive
Hardware access has always assumed a human at the bench. EdgeEmbed HIL assumes the opposite: a programmatic client that needs discovery, deterministic status, and hard safety rails.
Runs without hardware
Clone, make test, go run. A local simulator and runnable examples work on any PC — no board, no NDA.
Safe by construction
A client drives only what the board profile explicitly allows, by friendly alias — never raw hardware IDs. The board owner decides what an AI agent may touch.
What's in the SDK
Everything runs on your PC first
The SDK ships the contract, the client, and a simulated board — so the first ten minutes need nothing but Go. A real board uses the same client-side call shape; only the endpoint changes.
Protocol + client
The public EdgeAgentService protobuf contract and Go client helpers — dial a target, reference resources, get deterministic status back.
Simulator + examples
A mock board on your PC: an in-memory agent service with GPIO, log, and deploy providers, and runnable example clients for each call.
Profiles + conformance
The JSON board-profile model that declares what clients may touch, and public compatibility checks for agent implementations.
Demo · NXP i.MX 8M Plus
A real board, driven end to end
The HIL loop on real silicon: a client on a PC drives an NXP i.MX 8M Plus EVK through the open EdgeAgentService contract — discovers the board, drives a pin, watches the logs, then deploys and runs a full test suite on the target. Every command below is an example that ships in the SDK, and every one of them runs against the local simulator too — only the target address changes.
hil-client — nxp-imx8mp-evk
go run ./examples/describe -target 192.168.1.42:9090
agent edge-agent · board nxp-imx8mp-evk · ready
gpio user_led (drive) · button0 (read)
log kernel · app deploy enabled
go run ./examples/gpio-drive -target 192.168.1.42:9090 -alias user_led -value true
gpio user_led -> true · OK
go run ./examples/log-assert -target 192.168.1.42:9090
log-assert: pattern matched in app log · OK
go run ./examples/deploy-exec -target 192.168.1.42:9090
deploy: runtime test bundle -> nxp-imx8mp-evk
exec: ctest --output-on-failure
test suite passed on target · OK
A representative session — the exact example clients from the SDK, pointed at a real i.MX 8M Plus EVK running the target agent instead of the local simulator.
1 · Discover
Describe asks the board what it is: the agent reports the board profile, its resources, and what the client is allowed to touch — no hard-coded assumptions.
2 · Actuate & observe
Drive the user LED by its profile-bound alias, then assert on the application log — hands and eyes, over one gRPC contract.
3 · Deploy & test
Push the EdgeEmbed Runtime's own test suite to the board and run it there. The results come back over the same contract — a full validation loop with no human at the bench.
Talk to us
Validating AI-driven behavior on real silicon?
Using the SDK, building an agent workflow around real boards, or interested in target-side integrations — we would love to hear from you.