AI-NATIVEAGENT SYSTEM
AI-NATIVE PLATFORM LINUX-FIRST

Build embedded systems with AI. From silicon to production.

KERNARY combines an autonomous embedded systems engineer with Linux, build infrastructure, real-hardware validation and fleet lifecycle tooling—so teams can move from vendor BSP to tested production software in one engineering loop.

Explore the platform ↘See the engineering loop ↓
  • ✓ Linux / Yocto first
  • ✓ Real-board validation
  • ✓ Human-controlled release
LIVE ENGINEERING SESSION
PROJECT / ORBIT-CONTROLLERBUILD #2387

$ kernary engineer bring-up ./orbit-controller

→Target detected: NXP i.MX93 / custom carrier

✓BSP matched: nxp-lf-6.6.x

✓Device tree generated · CAN · ETH · MIPI

→Build #2387 deployed to BoardLab-UK / bay-07

!CAN interface failed after boot

→Correlating kernel log + schematic

✓Device-tree pinmux repaired

✓HIL validation: 18 / 18 passed

Candidate OS image ready for human approval

18 / 18Hardware tests
4.8sBoot target
ReadyRelease gate
01

Value across the organisation

Aligned teams. Clear evidence. Better product decisions.

KERNARY gives product leaders, engineers and technology partners a shared view of system progress, technical evidence and release readiness.

Choose your audience view

For product leaders

A clear path from product requirements to validated software.

KERNARY connects board requirements, software delivery and real-hardware validation in one accountable workflow, giving product teams clear visibility from bring-up through release.

  • Clear delivery ownership
  • Evidence-backed milestones
  • Visibility from bring-up to release
How KERNARY supports your teamExample workflow
Typical use caseBring a new industrial controller to release

A product leader tracks a new board revision from approved BSP and acceptance criteria through build completion and real-hardware validation before making the release decision.

01Provide the product contextBoard revision, approved BSP, interfaces and constraintsDefine
02Set acceptance criteriaFeatures, security, performance and release requirementsAlign
03Review release evidenceApproved source changes, software image and hardware test resultsDecide
ContextVerified outcome
02

The product system

One engineer. Five layers of leverage.

Kernary Engineer is the centre of gravity. Every surrounding product exists to give it reliable execution, physical evidence and a production lifecycle.

KERNARY product portfolio
01

Flagship product

Kernary Engineer

An autonomous embedded systems engineer designed to coordinate specialist agents and deterministic tools across system bring-up—from product intent to real-board evidence.

02

System foundation

Kernary OS

A customisable embedded Linux foundation spanning BSP, boot chain, kernel, drivers, root filesystem, security and OTA hooks.

03

Execution layer

Kernary Build

Fast, isolated and target-aware engineering environments with toolchains, caches, source and durable project state.

04

Physical validation

Kernary Board

Remote power, serial, JTAG/SWD, network and instruments exposed through one schedulable validation interface.

05

Production lifecycle

Kernary Fleet

Signed updates, staged rollout, rollback, CVE mapping and agent-assisted diagnosis for deployed device fleets.

06

Secure compute foundation

Kernary Fabric

A scalable compute foundation for isolated builds, with resource control, scheduling, networking and durable project state.

03

The system intelligence layer

Plan every layer. Find the fault. Repair the system.

KERNARY sees one connected runtime stack—from hardware and boot firmware through the bootloader, kernel, drivers and user space—with BSP integration across every board-specific layer.

The closed engineering loop
System model activeOrbit controller / i.MX93
PRODUCT SOFTWAREPHYSICAL SYSTEM
⌁

One coordinated system Layer-specific plans stay connected, so the agent can trace a symptom across boundaries before it changes source.

MAP → REPAIR → PROVE
04

Developer experience

The physical world, inside the engineering loop.

A target-aware workspace connects source and build tools to remote power, serial, debug and test fixtures—then returns the evidence to the same project history.

Developer experience and illustrative board lab
Connected board lab4 targets
BAY 07NXP i.MX93custom carrier / rev BTESTING
BAY 12TI AM62xreference targetAVAILABLE
BAY 04STM32MP157diagnostic sessionBOOT FAIL
BAY 09Renesas RZ/G2Lfixture reservedRESERVED
PWRRemote power
TTYSerial console
DBGJTAG / SWD
HILTest fixtures
Evidence stream RECORDING

@@ imx93-orbit-controller.dts

- pinctrl-0 = <&pinctrl_flexcan1>;

+ pinctrl-0 = <&pinctrl_flexcan1_default>;

+ status = "okay";

12:41:06BitBake image assembled / manifest stored

12:42:18Board flashed via recovery interface

12:42:26Serial can0: bitrate 500000 / state ERROR-ACTIVE

12:43:04HIL 18 assertions passed / 0 failed

Source diffBuild manifestTest run #9183Approval pending

ℹ Example board names and session data are shown for demonstration.

05

Connected system knowledge

Turn fragmented engineering data into trusted system knowledge.

KERNARY connects product definitions, BSP sources and operational evidence, then returns validated configurations, traceable results and proven repair history.

Connected Embedded System Knowledge
Customer inputsWhat your team provides
KERNARY system knowledgeConnected context and evidence
KERNARY outputsWhat your team gets back

Board + SoC definition

  • Schematics
  • Components
  • Interfaces
  • Constraints

BSP + source provenance

  • BSP version
  • Toolchain
  • Libraries
  • Source repository

Lab + fleet observations

  • Logs and traces
  • Telemetry
  • Test results
  • Field data
KERNARY system coverageEnd-to-end visibility

Typed system knowledgeComponents · relationships · constraints

Versioned knowledge layersHistory · integrity · traceability

Proven knowledgeVerified · tested · trusted

Embedded System KnowledgeOne source of engineering truth

Validated configurations

  • Build configurations
  • Toolchain setup
  • Feature set
  • Compatibility

Evidence-linked results

  • Test reports
  • Coverage
  • Compliance
  • Traceability

Failure → repair history

  • Root cause
  • Fix commits
  • Test validation
  • Deployment

Simulators

QEMU · Renode · Wokwi

Real hardware

Targets · Probes · Instruments

CI / test pipelines

Build · Test · Analyse

HIL + labs

HIL rigs · Measurements · Automation

Fleet + devices

Telemetry · Health · OTA

Operational foundationWhere knowledge meets real systems
06

Partner ecosystem

Build customer-ready embedded platforms together.

KERNARY helps silicon, software, validation and engineering partners turn specialist assets into repeatable workflows backed by clear integration scope and real-system evidence.

KERNARY partner ecosystem and integration pathways
01SB

Silicon + board platforms

Turn reference platforms into repeatable, customer-ready enablement.

Customer valueFaster board bring-up with a reusable path to production
02SW

Embedded software ecosystem

Carry supported software components into controlled product baselines.

Customer valueA reproducible software baseline that remains supportable across releases
03VL

Validation + lab providers

Make physical test capacity part of a traceable engineering workflow.

Customer valueRepeatable evidence from real hardware, available to every delivery team
04ED

Engineering delivery partners

Package specialist knowledge into delivery methods customers can reuse.

Customer valueFaster adoption while customer teams retain technical and release control

Partner programme

See how partner assets become validated customer workflows.

Explore engagement models, integration surfaces, validation responsibilities and programme requirements.

Explore the partner programme →
07

Where KERNARY fits

Keep your Linux workflow. Add one system that connects it.

You provide product intent, source and controlled access. KERNARY adds the system intelligence, coordination and evidence layer across the tools you already use.

KERNARY system coverage
01

You provideProduct intent, source and access

  • Board + SoC definition
  • Vendor BSP + source
  • Product requirements
  • Security + release policy
  • Lab and fleet access

KERNARY system coverageThe intelligence and evidence layer

MODEL → PLAN → EXECUTE → PROVE → LEARN
  1. Step 01
    ModelBuild the system model

    Turn board, BSP and product requirements into connected, versioned target knowledge.

    01
  2. Step 02
    PlanCoordinate every layer

    Link boot, kernel, driver, build and test plans instead of treating them as separate tickets.

    02
  3. Step 03
    ExecuteExecute with control

    Use deterministic, permissioned tools to make reproducible and reviewable engineering changes.

    03
  4. Step 04
    ProveAttach physical proof

    Connect real-board logs, measurements and test results directly to the change that produced them.

    04
  5. Step 05
    LearnPreserve system learning

    Feed validated configurations, failures and repairs back into the system model for the next release.

    05
02

Your existing stackThe engineering tools you already trust

  • Linux + Yocto
  • GitHub + GitLab
  • CI + build tools
  • Board labs + HIL
  • OTA + fleet systems

Built for embedded product teams

Move from board bring-up to production with less integration risk.

KERNARY connects your embedded Linux source, build environment, board validation and release evidence—giving your team a clearer path to a tested, supportable product.

Explore KERNARY →Read the documentation →