The stack powering agentic devices

lim provides a flexible communication layer between physical machines and the people, agents and software that use them

Modern processes don’t come from one smart machine, but from connecting all of your devices into one intelligent system.

lim helps you do just that.

What it does

Every use case is different, but infrastructure and communication shouldn’t be. lim helps you create flexible, intelligent digital twins right next to your device that translate their state and functionality into various interfaces.

lim helps you structure this across devices and models, and keeps it maintainable and deployable at scale.

A lim machine exposing its interfaces

HMI / User Interface

From your definition lim generates a responsive user interface, with input fields and a live view of the complete state of the device.

HTTP Server

All data is queryable over HTTP. Attach your own programs or build a custom user interface – it's up to you.

MCP Connector

AI agents can explore all data, which makes it easy for them to understand the device and even take actions (depending on your configuration).

Historic data

Every run is recorded on the device. This allows you to check how the device is used or what went wrong.

Cloud mirror

Replicate all data to the cloud and access your machine data from anywhere.

Coming soon

Prompt your device

Provide an API key and talk to your device directly. It knows exactly what it can and can't do. Your device is an agent now.

Coming soon

Applications

lim is domain and use case agnostic. As long as the device has a plug of some sort, you can use lim to make it accessible and intelligent. It can be deployed to desktops, servers or mini-computers (which is what we recommend).

Due to its open nature, specific drivers and interfaces (CAN, OPC-UA etc.) can be integrated easily.

Bench top

Bench top

Especially in research and development, your goal is to validate ideas, not to build complex systems. You shouldn't have to think about how you talk to your benchtop rig, but focus on the use case you are actually exploring.

Retro-Fitting

Retro-Fitting

Often devices are still mechanically sound, but lack the connectivity and interfaces to fit into digital processes, or the user interface simply feels dated. With lim you can extend the lifetime of these machines and bring them into your digital workflows.

DIY

DIY

You often only have an evening or a weekend to build your project, so you should be able to focus on what you want to build, not the boring parts. Get going within minutes and build awesome things.

How it works

You write your device logic in TypeScript, following a given structure. lim then builds all the necessary interfaces out of it. Device state is mirrored and can be queried with simple HTTP GET requests, and actions become POST endpoints with automatic schema validation.

Besides that, an HMI is built automatically, and the endpoints are easy to query for an LLM. A machine is a list of things it knows and a list of things it can do, and that is all you write.

device.ts
class Centrifuge {
  state = {
    status: "idle",
    rpm: 0,
    finishTime: null,
    currentTemperature: 21,
    targetTemperature: 21,
  }

  actions = {
    spin: ({ rpm, minutes }) => {
      // start the run
    },

    setTemperature: ({ celsius }) => {
      // cool the chamber
    },

    stop: () => {
      // stop the run
    },
  }
}
Terminal
lim v1.0.0◉ 1 connection
endpoints
ui-> http://192.168.178.109:4000
api-> http://192.168.178.109:4000/api
machines (1)
◇centrifuge
events
15:47:18░ statestatus: idle, rpm: 0
15:47:20░ statecurrentTemperature: 21
15:47:28░ statefinishTime: null

Why lim instead of...

There is more than one way to get a machine talking. Most of them are reasonable. Here is where each one stops.

... writing everything myself?

A script and a quick dashboard get you running in an afternoon, and for a one-off that is the right call. It gets expensive later: no interface anyone else can use, no update path beyond copying files over SSH, and when you move on the script becomes something nobody wants to touch.

... a coding agent?

On its own, an agent writes a different app every time, with its own stack, conventions and way of being deployed. Point one at lim, that is the intended way to work. That is fine for the first machine and painful by the fourth. With lim as a guiding framework, the agent writes only the part that is specific to your machine.

... a framework like Next.js or TanStack?

Full-stack frameworks are built for the opposite problem: thousands of users, several backends and a database in the middle, with requests that forget everything in between. You have one machine, a handful of people using it, and state that has to stay live for as long as it runs. lim is optimized for that, so the live state, the API and the panel are there instead of being yours to assemble.

... MATLAB, LabVIEW or TestStand?

For many use cases they work great. You are however tied to their ecosystems, and they are a lot heavier than what most people need.

... Node-RED, Home Assistant or ESPHome?

Strong at sensors, automations and getting a value onto a dashboard or automating processes. They start to strain when the machine has real logic and needs a control surface people operate. Use them to orchestrate multiple lim machines – that's the best way to go.

... a PLC?

The right choice for a production line that has to run for a decade, but might be overkill for your use case. Combine it with lim as a connectivity layer and for an interface.

Give your machine a modern makeover within an afternoon.

$npx lim init

Stay in the loop

An occasional email when something ships: new interfaces, drivers, and machines people built with lim. No spam :)