Cellular IoT for remote sensors and control

Out of sight. Never out of reach.

The S2 is an LTE-M IoT board with the SIM and prepaid data built in. Wire up sensors or relays, write a few lines of Lua, and the S2 sends readings to your own API and acts on your commands. Once it's bolted to the equipment, you still change its code and watch its log from your desk.

Order an S2 arrow_outward play_circle Watch the 40s demo

No monthly fees · 10 MB of credit in the box · then $1 per MB

Why we built it

Three days to reach a bug that took minutes to fix.

If you've shipped hardware, you've had a device that worked on your desk and failed on site. Mine came in my first engineering job, more than ten years ago. I built a converter to connect a gas generator to a large energy company's new IoT system. On my desk, it read and wrote every register. On site, it didn't.

  1. Getting there

    Sites are rarely close. Mine was an 8-hour drive, with the car full of debugging gear.

  2. Getting in

    Sites have gates and safety training. I did the training and got through the gate the next day.

  3. Plugging in

    Being there doesn't mean you can connect. Plugging anything in risked a spark, so my tools stayed in the bag.

  4. Finding it

    The bug is usually small. Mine was a wrong register address from a typo in the spec. It took three days to find and minutes to fix.

I've hit the same wall on IoT projects ever since. The device sits somewhere hard to reach. The bug only shows up there. The algorithm waits until the real sensors are installed. I built the S2 and Superstack so you can reach the device from your desk instead: change its code, watch its log and read its sensors, wherever it is.

Raj Nakarja, founder

The old curse

A year of plumbing before your device does anything useful.

Before the application can bring any value, a cellular IoT product needs hardware, a carrier, an update pipeline and a backend. Building that takes most teams about a year. The S2 and Superstack come with all of it, so you start on the application in minutes.

Building it from scratch

  • close Design cellular hardware and antennas
  • close Negotiate carriers, SIMs and data plans for every unit
  • close Build a backend to manage devices and collect their data
  • close Build an over-the-air update pipeline
  • close Make sure a bad update can't brick a unit in the field
  • close Run and patch all of it, forever
Months before the application does anything

With S2 and Superstack

  • check Unbox an S2. The LTE-M modem and antenna are on board
  • check Use the SIM, data and starter credit already inside
  • check Pair it to a fleet in under 30 seconds
  • check Push Lua over the air from the CLI, or let your agent do it
  • check Push freely. Nothing you send can brick an S2
  • check Leave firmware, connectivity and the backend to us
Minutes until you're writing the application
The vessel

The S2 plugs into the sensors you already use.

The S2 Module has six IO ports for I²C, SPI, analog and digital IO. Four of them take Stemma QT and Qwiic boards with no soldering. It's built on Nordic's nRF9151, and runs from USB-C, a 5 to 17 V supply or a single LiPo cell.

Fig. I · The S2 Module, and what may be bound to it
A · B · E · F
4-pin Stemma QT and Qwiic ports. Plug in I²C sensors, or use the two pins as digital IO.
C
7-pin port with five IO pins: SPI, digital IO, and analog input on C2 to C4.
D
7-pin port with five IO pins, all of them analog inputs or digital IO.
Sensor power
Every IO port powers its sensor at 1.8 to 3.3 V, set from Lua, with up to 100 mA for each side of the board.
Power, USB-C, Battery
Run the S2 from a 5 to 17 V supply or USB-C. It charges a single LiPo cell from either.

The S2 works with any I²C sensor, any SPI sensor or memory chip, and any UART device. It also outputs PWM, reads analog voltages, and drives or reads digital IO for relays, switches and LEDs. We've already built demos for ten sensors, a display, an NFC tag and a relay in the S2 Lua examples.

Radio
LTE Cat-M1 and GPS
Connectivity
Global SoftSIM, prepaid data
I/O
6 ports: GPIO, PWM, I²C, SPI, UART, analog
Connectors
Stemma QT and Qwiic pin order
Power
USB-C, 5 to 17 V, LiPo charging
Temperature
−40 to 85 °C operating
S2-MODULE Integrated antenna

For plastic enclosures, in most covered countries.

S2-MODULE-EXT-ANT External antennas

For metal enclosures, and for the US, Japan and other countries marked in the coverage table.

Compare and order Datasheet
An S2 Module air quality monitor: the S2 and two sensor boards in a clear sealed enclosure, powered over USB-C
Fig. III · An S2 air quality monitor, sealed and powered over USB-C
An S2 Module sealed in a clear enclosure on a workbench, with cables through two cable glands
Fig. IV · An S2 wired through cable glands, ready for the field
Scrying from afar

Debug the deployed device, not a copy on your desk.

Field bugs rarely show up on the bench, so the S2 lets you debug the real device where it's installed. Read its sensors, change its code and watch the result from your terminal, while it stays bolted to the equipment.

  • Live logs. superstack tail streams every print() from a fleet or one device.
  • Fixes in seconds. superstack dev uploads on every save and follows the log. No compile, no flash, no site visit.
  • The real hardware. Lua talks to I²C, SPI, analog and GPIO directly. Scan a bus or probe a register on the deployed board.
  • Ship the board, not the engineer. Someone on site plugs in the sensors. You build the algorithm against real readings from your desk.
  • A whole fleet at once. Push code to every device in a fleet with one command, and tune the algorithm across many sites. 
-- Which address is the sensor really on?
device.power.set_vout(3.3)
device.sleep(0.1)

for address = 0x08, 0x77 do
    if device.i2c.read(address, 1).success then
        print(string.format("Found 0x%02X", address))
    end
end
Spellcraft

Write one line of Lua. We maintain the C beneath it.

Lua is the lightest safe layer you can put over C, and one of the easiest languages to learn. The S2 runs Lua 5.5, which has 23 keywords to Python's 35. Most sensors and buses follow a standard scheme, so each S2 call handles the common case in one line, and optional parameters let you go deeper when you need to.

  • One call to your API. network.post() sends your data over an encrypted session, from a thread of its own. Thread safety, memory safety and security are our problem, not yours.
  • No bricking. We build and sign the firmware. Your Lua runs in a sandbox we test hard for memory leaks, and it handles its own internal errors.
  • Always reachable. Networking runs ahead of anything your code does, so the device keeps answering even when your Lua misbehaves.
  • Mistakes cost seconds. Bad code stops Lua, not the device. Read the error in the log, fix it and push again.
main.lua
-- The common case takes one line
local reading = device.i2c.write_read(0x18, "\x05", 2)

-- Optional parameters go deeper
local reading = device.i2c.write_read(0x18, "\x05", 2, {
    port = "PORTE", frequency = 400,
})

-- Send it to your own API
local raw = string.unpack(">I2", reading.data)
network.post("https://api.example.com/readings",
    json.encode({ raw = raw }))
lines to maintain
Send to your API
1,363 → 1
I²C, SPI and UART
785 → 1
GPS location
505 → 1
Digital IO
129 → 1
Analog input
113 → 1
PWM
38 → 1
Lines of C in the S2 firmware behind each Lua call, not counting blanks and comments. You write the one line. We write, test and patch the rest.
The workings

Your devices speak REST, like the rest of your stack.

Superstack is the pipe between your S2 devices and your systems, and it makes IoT look like the ordinary web. Devices call your REST endpoints. Your services reach devices over REST, or over a WebSocket when latency matters. We did the protocol work, so any backend developer on your team can build on your devices with the tools they already know.

  • thermostat BMP280
  • mode_fan motor
S2 Module Lua code
firmware SIM
Superstack main.lua print 21.44 °C POST
your server

received POST /readings {"temp": 21.44}

sent POST {"motor": "on"} to my device

main.lua print
your laptop

$ superstack pair "my device"

$ superstack upload main.lua

$ superstack tail

14:52 [my device] 21.44 °C

Yours. Your Lua code, your sensors, your data and the systems it reaches.

Ours. The S2 firmware, the SIM and LTE-M connectivity, recovery, and Superstack in between.

REST, not MQTT

An S2 posts its readings to your REST endpoints, in the format you choose. There's no MQTT broker to run, scale or pay for.

WebSockets, not UDP

Your services message a device with a REST call, or hold a WebSocket open for low latency. Your team never hires for embedded networking or touches a UDP socket.

Never read, never logged

Superstack encrypts your data in both directions and forwards it without reading it, logging it or using it for anything of our own. It never stores your readings, so there's nothing of yours to leak.

Keys for one fleet

A fleet key reaches one fleet and nothing else. Share fleets with teammates by email, and revoke either in one command.

Watch the spell

One sentence in. A working sensor out.

We asked Claude Code to add a new S2 to our Greenhouse fleet and log its MCP9808 temperature sensor. With the Superstack plugin, it found the fleet, paired the module, wrote the Lua driver and read back the first temperatures in 27 seconds.

claude ~/greenhouse

> Add the new S2 (IMEI 350457790012345) to Greenhouse and log its MCP9808 temperature

Read the transcript

Claude: I'll look up your Greenhouse fleet, then pair the module with it.

Claude: Greenhouse is fleet 42. Press the pairing button on the module now.

Claude writes a 23-line temperature.lua. It sets the port voltage to 3.3 V, checks the MCP9808's ID register at I²C address 0x18, then reads and sends the temperature. It runs superstack upload 350457790012345 temperature.lua and superstack tail 42 350457790012345 -n 3.

Claude: The sensor is live. The ID check passed, and the first readings are 21.44 °C, 21.50 °C and 21.50 °C. Each reading also goes out through network.post, ready to pipe into your own systems.

Order an S2 arrow_outward See the four steps
Your own familiar

Tools for your AI. Not our AI in your way.

Superstack ships no chatbot and no opinion about how you should use AI. It gives your agent the same tools you have, and lets you decide what it does with them.

  • A Claude Code plugin that teaches S2 Lua and the Superstack API, installed in two commands.
  • Open Agent Skills for Codex or any agent that reads the format.
  • A CLI that covers every feature, with --json output on every list for scripts and agents.
  • Or no AI at all. The CLI is a single binary for macOS, Windows and Linux. 
> /plugin marketplace add siliconwitchery/claude-plugins
> /plugin install superstack@siliconwitchery

> Read the BMP280 on PORTA every 10 minutes
  and post it to our API

● I'll pair the module, write the driver,
  then follow the log to check the readings.
The spread

Anywhere there's a cell tower and nobody around.

The S2 Module fits any sensor or controller that sits beyond Wi-Fi and out of easy reach.

Retrofitting existing equipment

Generators, pumps and compressors that were never built to be connected, monitored and re-coded without a site visit.

Asset tracking

Built-in GPS and battery charging for trailers, tools and anything else that moves.

Cold chain

Temperature logs from trucks, containers and storerooms, straight into your quality system.

Agriculture

Soil, irrigation and livestock sensing across sites that will never have Wi-Fi.

Weather and environment

Stations in hard-to-reach places, re-coded remotely instead of revisited.

Drone and robot telemetry

Low-latency WebSocket links back to a ground station for decisions in real time.

Hire the coven

The engineers who built the S2 can build yours.

Silicon Witchery designed the S2, its firmware and Superstack. Our engineers can design the carrier board your S2 mounts on, write its Lua, and send its readings to your systems. Or we can design your whole product, through certification and into manufacturing.

See consulting services arrow_forward
The ritual

From box to first reading in four steps.

The S2 Module ships with its SIM and data plan built in. There's no carrier contract or gateway to set up before the first reading.

  1. Order an S2

    The S2 ships from DigiKey with 10 MB of starter credit. Its IMEI is on the label on the back.

    Order on DigiKey arrow_outward Compare S2 variants

  2. Install the CLI

    The Superstack CLI runs on macOS, Windows and Linux. Or add the Superstack plugin to Claude Code. 

    $ brew install --cask siliconwitchery/tap/superstack

  3. Log in and pair

    Log in with GitHub or GitLab and create a fleet. Then pair the S2 by its IMEI, and press the button on the board when asked. 

    $ superstack login github
Logged in as you@example.com.
$ superstack fleet create greenhouse
Created fleet "greenhouse" with id 42.
$ superstack device pair 350457790012345 42
Press the pairing button on device "350457790012345".
Paired device "350457790012345" with fleet 42.

  4. Write and run

    Wire an MCP9808 temperature sensor to PORTA, save this main.lua and run superstack dev. It uploads the file and follows the log of the S2. Every save uploads again.

    main.lua
    device.power.set_vout(3.3)

while true do
    local result = device.i2c.write_read(0x18, "\x05", 2)
    local raw = string.unpack(">I2", result.data)
    print(string.format("%.2f °C", (raw & 0x0FFF) / 16))
    device.sleep(5)
end
    $ superstack dev 350457790012345 main.lua
Uploaded 1 file to device 350457790012345.
It arrives at its next check-in.
2026-10-23T09:14:06+02:00 350457790012345 state [] Code started
2026-10-23T09:14:06+02:00 350457790012345 print [] 21.44 °C
2026-10-23T09:14:11+02:00 350457790012345 print [] 21.50 °C
Questions

Before you order.

What are the S2 and Superstack?

The S2 Module is a cellular IoT module built on Nordic's nRF9151, with LTE-M, GPS, a global SoftSIM and prepaid data inside. Superstack is the service that sends Lua code and messages to S2 devices over the air, streams their logs back and forwards their readings to your own REST API or WebSocket.

What does it cost?

The S2 costs its hardware price, then $1 per MB of data. Every S2 comes with 10 MB of starter credit. Traffic in either direction spends credit, and nothing else does. Superstack has no subscriptions and no per-seat fees. Large fleets and heavy data users can ask for contract pricing. See S2 pricing.

Do I need a SIM card or a carrier contract?

No. Every S2 ships with a global SoftSIM and 10 MB of starter credit. When a fleet runs low, top it up with superstack account topup.

Where does it work?

The S2 has full LTE-M coverage in 25 countries, including most of Europe, the UK, the US and Japan, plus partial or city coverage in many more. Check the coverage table before you deploy.

What sensors work with the S2?

The S2 works with any I²C sensor, any SPI sensor or memory chip, and any UART device. It also outputs PWM, reads analog voltages, and drives or reads digital IO for relays, switches and LEDs. The S2 Lua examples include demos for ten sensors, a display, an NFC tag and a relay.

How does the S2 compare to Particle, Blues or the Thingy:91 X?

The S2 is built for debugging devices you can't reach. You change its Lua over the air in seconds without a compile or flash, follow its log live, and pay $1 per MB with no subscription or per-device fee. See the full S2 comparison with Particle, Blues and the Thingy:91 X.

How do I debug a device that's already in the field?

Follow the S2's log live with superstack tail, change its Lua, and push the fix with superstack dev. The new code reaches the S2 at its next check-in. Lua reaches I²C, SPI, UART, analog inputs, digital IO and PWM directly, so you can probe the real sensors on the deployed board without a site visit.

Can I start building before I can get to the site?

Yes. Pair an S2 to your fleet, then post it to whoever is on site. Once they plug in the sensors and power it up, you write and test your code from your desk against real readings.

Can I brick a device?

No. S2 code is Lua that runs inside Silicon Witchery's firmware, and Silicon Witchery builds and signs every firmware update. Nothing you push can leave an S2 unrecoverable, and a deployed S2 always stays reachable.

What happens to my data?

Superstack sends your devices' data to your own systems. Superstack keeps your account and fleets, device code, undelivered messages, 14 days of device logs and the credit ledger. Silicon Witchery never reads or logs the data sent to and from your devices, and no AI sits between you and them.

Can my team share devices?

Yes. Superstack groups devices into fleets. Add teammates to a fleet by email, and hand a fleet to a new owner when a project changes hands.

Does it work with Claude Code and Codex?

Yes. A Claude Code plugin and open Agent Skills teach your agent S2 Lua and the Superstack CLI, so it can pair devices, write sensor drivers and read logs. You don't have to use AI. The Superstack CLI covers every feature on its own.

Can I take it into production?

Yes. The S2 ships with a housing and standoffs, and pads on its underside let you mount it on your own carrier board with pogo pins. If you need a custom board or enclosure, our consulting team can design it.

Start today

Fix your next field bug from your desk.

Order an S2 from DigiKey, pair it in under 30 seconds, and change its code from anywhere.

Order an S2 arrow_outward Read the docs