01 / What · MIEFAB / MIE Private Alpha

No OS.
No runtime.
Just firmware.

MIE turns a task-specific model and a chip SDK into a verified inference engine — as firmware. It learns the SDK, checks whether the silicon can actually run the model, and, once you sign off, builds, flashes and tests the image itself.

≈0software overhead*no OS / runtime
0.5–1Mmodel parameterstask-specific
30 daysper chiprepeatable

*The model is the firmware: no OS, no runtime, no framework between it and the silicon. It is still software — about as little of it as a chip allows. Any chip with a usable SDK is a candidate.

0%

02 Why

The software stack
is the tax.

Between a model and a transistor sits an operating system, a scheduler, a runtime, a framework, a loader and a dependency tree. For a fixed task, almost none of it has to be there — and all of it costs boot time, jitter, memory and attack surface.

Typical edge stackFour layers before the model.
OS→ Scheduler→ Runtime→ Framework→ Model

boot · jitter · copies · CVEs

MIEFAB / MIEThe model is the image.
Model + weights→ Firmware→ Silicon

≈0 software overhead · 1 image

Removed on the target
  • OS kernel
  • RTOS scheduler
  • Interpreter
  • ML framework
  • Model loader
  • Dynamic allocation
  • Dependency tree

MIE removes what the SDK and the silicon let it remove. On a bare MCU the engine is the firmware — no OS, but not zero software. On a bigger part it can go further. Removing a layer means proving the layer was never needed.

03 How

How MIE
works.

Learn the SDK. Assess the silicon. Stop for a human. Then build, flash and test. The rail moves down as each step is checked.

01 / 07

Learn

MIE ingests the SDK: headers, linker scripts, HAL, vendor toolchain, errata, and the datasheet. It builds a working model of the part — memory map, MACs, DMA paths, peripherals — before it proposes anything.

SDKDatasheetErrataToolchain

The assess step is the honest one: if the silicon cannot host the outcome, MIE says so up front instead of discovering it after the build. Some parts can host a classifier or control logic but not an LLM.

03 How

How MIE
works.

Learn the SDK. Assess the silicon. Stop for a human. Then build, flash and test.

01
Learn

SDK + spec

MIE ingests the SDK, headers, linker scripts, HAL, errata and datasheet, and builds a model of what the part can do.

02
Assess

Can this chip do it?

A feasibility pass — memory budget, MAC throughput, quantization, IO. The verdict is yes, no, or not unless the model changes.

03
Validate

Human sign-off

Chip owner, silicon engineer or AI builder reviews the feasibility report and approves. Nothing touches the board before this gate.

04
Build

Model → image

Target kernels and weight blobs, linked into a single firmware image. No runtime to load, nothing to boot.

05
Inject

Flash over USB/UART

The desktop harness drives your SDK: compile, flash, reset, read back. Failures return as structured data, not a stack trace.

06
Test

Prove it on silicon

Golden vectors on the part. Output equivalence, memory, latency and power measured — mismatches caught here, not in the field.

07
Deliver

Signed image

A signed image plus a verification report, reproducible from the same model, SDK and constraints.

The assess step is the honest one: if the silicon cannot host the outcome, MIE says so up front instead of discovering it after the build.

04 Desk

It plugs into
the bench.

Most AI coding tools stop at the repository. MIE runs as a harness on your desktop, with direct access to the USB and UART ports your board is already on — so the agent can flash the part, reset it, and read the boot log itself.

01 / Host MIE harness your desktop · your SDK
USB · UART
02 / Bench Board + probe flash · serial console
SWD · JTAG
03 / Target Silicon one image · no OS
Local by default

Your bench, your SDK.

The harness runs against the vendor toolchain and board you already have. The model, the image and the traces stay on your machine.

Hands on the part

Close the loop itself.

Enumerate ports, flash, reset, capture the boot log, parse the output. No human copying terminal text between the agent and the hardware.

Bounded search

Compile → flash → assert.

Every iteration is measured against golden vectors and a memory and timing budget, so the agent knows when to stop instead of guessing.

Evidence

A recorded trajectory.

SDK version, image hash, serial trace, verdict. A reviewer can replay the run and see exactly why the image was accepted.

The harness is the part of MIE a chip team can put in a lab tomorrow — and the part that turns an agent's claim into a measurement.

05 Who

Built for the people
who own the silicon.

MIEFAB helps chip owners, chip engineers and AI builders research, develop and optimize their chips — using MIE as an AI reference to reach a working inference engine faster, cheaper and closer to the part's optimum.

Chip owners

De-risk the path.

Know whether your silicon can run the model before you commit a team, a board or a tape-out. The answer arrives as a feasibility report, not an opinion.

Chip engineers

Direct, don't grind.

Set the target and the constraints, approve the feasibility report, sign the image. MIE runs the repetitive build-and-flash loop between your decisions.

AI builders

Reach the silicon.

Get your model running on a specific part without owning a runtime stack, a vendor compiler team, or a year of bring-up.

Assessed before anything is built Validated before handoff to MIE Tested on the part, over real ports

06 Roadmap

One chip today.
Custom silicon next.

Short term is a small task-specific model on an SDK-qualified chip, end to end, verified on the part. Long term is the same loop with larger models, bigger chips — and eventually a model cast into a mask.

Short term · now

A small model on one chip, in firmware.

  • 0.5M–1M parameter, task-specific model — not a general assistant
  • Any part with a usable SDK, toolchain and flash path
  • One image: no OS, no runtime, no framework where the SDK stands alone
  • Flashed and verified over USB/UART, with a signed report
Long term · the trajectory

Larger models. Bigger chips. Custom silicon.

  • Larger LLMs — multi-megabyte weights, longer context, real language tasks
  • Bigger parts — MPU and SoC-class silicon with real memory and more compute
  • Any SDK — MIE learns a new toolchain per chip, so each one costs less than the last
  • Custom ASIC — the Taalas HC1 path, where the weights become the mask
  1. M1 Verified POC

    Model → firmware on one SDK-qualified chip, outputs checked on silicon.

    Done
  2. M2 Second chip

    The same loop on a different SDK, to prove the learning step generalizes.

    Next
  3. M3 Repeatable compiler

    Verified trajectories become templates. Paid chip partners, repeatable delivery.

    Then
  4. M4 Custom ASIC

    Stable model plus real volume: hard-wired inference silicon, HC1-class.

    Later

M1 is measured on silicon. Everything after it is a target, and the custom-ASIC stage is capital-intensive — it is gated on volume, not on ambition. Taalas HC1 is the reference point for what hard-wired inference silicon can look like.

07 Contact

Back the build.
Or bring a chip.

MIEFAB is being built with a small group of investors and chip partners. One verified POC is on silicon; the next step is a second chip and a repeatable loop. There are two ways in.