Pre-seed · Ktema Systems, pre-incorporation
The coordinate is the index.
On-device spatiotemporal queries without a database or an operating system.
Ktema is a storage engine for devices that cannot run a database. A machine is asked about its own past, and on a server that question is a query with an index behind it. A microcontroller has tens of kilobytes of SRAM and no room for the index. Ktema answers the question on the device.
- 4,309 Blive peak heap for a write and a read round trip on a RISC-V target with no operating system
- 760 Blargest single allocation in that round trip
- 478cells in the coordinate decoder, verified on an FPGA
- 0.93 msthree-axis query over a one-day window at 100,000 records
server
the address is looked up
device with no operating system
the address is computed
Problem
A machine is asked about its own past
Different buyers, the same shape. Each question is a filter on three axes at once: an origin, an event, and a time window.
| Device | The question it has to answer |
|---|---|
| Motor drive | which frames showed vibration, winding temperature, and current moving together, before the bearing fails |
| Robot zone | what this zone saw, from the zone controller’s own memory |
| ECU | the sensor burst from before the reset, absorbed without a compaction pause |
| Patient monitor | why an alarm fired, from the record it kept |
A server answers questions like these with an index. A B-tree, a hash table, or an LSM tree holds the axes, and the server has the memory to keep it. A microcontroller has tens of kilobytes of SRAM. In our pilot engine a single leaf of the index cost 134,064 bytes on a 32-bit target, for two small records. That is why the index does not fit.
The workaround moves the data off the device
It stops working when the link is down
The machine keeps running through the outage. The record of what it did does not.
Its latency depends on a network
A question about the last few milliseconds has to survive a round trip to answer it.
The record sits on someone else’s infrastructure
What the machine did ends up held by a gateway, a cloud, or the vendor’s own service.
Microcontrollers already have storage, from flash drivers to small filesystems and key-value stores. What they lack is a store that answers multi-axis questions inside the memory they have. That gap calls for a different addressing model.
Why now
Physical AI sets the requirement, and the toolchain arrived with it
Robots and instruments have to answer on the device
Robots, actuators, instruments, and sensor nodes have to capture and query multimodal streams on the device, with no cloud in the path and no operating system under it. They carry the constraints cloud infrastructure was never built for: power interruption, flash wear, telemetry workloads, and operational lifetimes of ten to thirty years.
Compliance follows the product, not the vendor’s address
A device placed on the European market carries the Cyber Resilience Act duties wherever it was built, so a firmware team that sells worldwide meets them as a procurement requirement. The reporting duties are already in force, and the main obligations, including the software bill of materials, apply from December 2027. A record that carries its own origin and time is the evidence those duties ask for.
The reporting duties apply from 11 September 2026, and the main obligations from 11 December 2027. Penalties reach €15M or 2.5% of worldwide turnover.
The coordinate space is new, and so is the toolchain that carries it
It was defined this year, and the layers around it now build without a standard library, so a device with no operating system can compute the address. The decoder is verified on an FPGA, and continuous integration runs the engine and enforces the footprint budget on every change.
Insight
Two writers that observe the same thing compute the same address
They never talk to each other, and nothing looks the address up.
A record’s address is computed from what it holds, where it came from, and who wrote it. Any reader can recompute it to check the record, which is what makes the store auditable on a device nobody administers.
No index to keep
Because the address is computed, there is no index to size, store, or repair, and memory grows with the data rather than with the address space.
A volume is portable
The same bytes produce the same identifier in any conforming implementation, so a record can be checked by recomputing its address.
Time is one of the axes
A time window is answered from the same structure as every other question, with no second store to keep in step.
Product
A Rust library with a C interface
Ktema ships to firmware teams as something they link, not as something they port.
- Delivery
- A Rust library with a C interface, so an integrator links it into an existing firmware.
- Carries
- The on-media format, the state contract, the media channels, and the C surface.
- Record kinds
- Facts, intents, and hints.
- Portability
- The format fixes the layout, the keys, the encoding, and how identifiers are derived, so a volume moves between machines without a conversion step.
Rem, the reference product
Rem is an offline spatial AI memory that runs the engine over a real FAT32 medium from a desktop application, a CLI, and an MCP client. It exercises the engine against real media, which is how the format is validated outside the firmware target.
Proof
Running without an operating system is a measurement
A firmware image boots in emulation on a RISC-V target with no operating system and no runtime, completes a write and a read, and peaks at 4,309 bytes of live heap.
The largest single allocation in that round trip is 760 bytes, inside a 64 KB SRAM budget the build enforces. A second build compiles the C surface and runs the same test. Both run in continuous integration on every change.
Live peak heap for the MCU round trip with the structural index on and off, on one scale. The optional index costs about 354 KB of live heap, which is why the reference build leaves it off and keeps the engine in the 64 KB class.
| Measurement | Result |
|---|---|
| Live peak heap, two facts and a read back | 4,309 bytes |
| Cumulative allocation over the round trip | 12,150 bytes |
| Largest single allocation | 760 bytes |
| Static SRAM used, inside a 64 KB budget | 32,812 bytes |
| Firmware text (flash) | 144,842 bytes |
Three-axis query latency
A three-axis query over a one-day window answers in about 0.93 ms at 100,000 records and about 18.9 ms at one million, from the same structure that holds every other axis, and the cost grows with the number of records.
| Scale | Structural index | Scan path |
|---|---|---|
| 100,000 records | 25.4 to 26.3 µs | 915 to 941 µs |
| 1,000,000 records | 226.6 to 229.5 µs | 18.6 to 19.4 ms |
Those figures come from a virtual test environment, a release build, and the median of ten samples from the Criterion harness. The device runs the same scan path. The on-target cost is not yet measured, and the scan path is the one the read path uses.
Market
Three layers: what the buyer replaces, what grows it, and the wedge
The software the buyer replaces
The embedded database system market in 2025, projected to reach US$ 23.55B by 2034 at a CAGR of 8.08%.
The driver that grows it
The Physical AI market grows from US$ 0.89B in 2025 to US$ 15.28B by 2032, with Asia Pacific leading the demand and the manufacturing.
The wedge we sell into
Firmware teams in industrial equipment, instruments, and modules, where the memory budget is the purchase requirement.
The wedge count is derived from published figures on industrial automation equipment makers (9,300), IoT device manufacturers (14,000), and embedded system companies, narrowed to those that ship a microcontroller product with a multi-axis history requirement.
Base case
$1M ARR20 design wins within two years of the first paid deployment, at $50k average annual licence and support.
0.2% of the wedge
Upside, the Series A path
$3M ARR30 design wins within three years of the first paid deployment, at $100k average.
0.3% of the wedge
The projections above are estimates from those terms, not a booked pipeline. The size of the wedge and the win rate from evaluations are expected to be calibrated by the first design partner.
Competition
Every multi-axis system here carries an index, except one
FlashDB runs in less memory than any system here and answers key and time-series questions only. shodh-redb is no_std and multi-modal, but its published example runs at 8 GB of RAM. remdb, Fjall, and a minimal SQLite build answer through an index, and MoteDB and spatio index on Linux and work in tens of megabytes. Every multi-axis system in the table except Ktema carries an index, and the ones with published figures need an operating system or more memory than a microcontroller carries. Ktema answers the same three-axis query from a 4.2 KB heap with no index and no operating system.
| System | Query model | Index | Operating system | Memory |
|---|---|---|---|---|
| FlashDB | key and time series | key index | none | RAM near zero, 5 to 7 KB of flash |
| shodh-redb | embedded database, multi-modal | B-tree | none | 8 GB in the published example |
| remdb | key-value | hash and secondary trees | none | 128 MB in the published example |
| spatio | spatial | R-tree and geohash | Linux | low, with a runtime |
| SQLite, minimum | multi-axis through an index | B-tree | needs one | about 100 KB of heap |
| MoteDB | vector and multi-model | DiskANN and others | Linux | up to 35 MB, P99 ≤ 50 ms |
| Fjall | key-value | LSM tree | Linux | not published |
| Qdrant Edge | vector, in-process | HNSW | none | minimal footprint, not published |
| Ktema | multi-axis over a coordinate space | none | none | 4.2 KB heap, 141 KB flash |
Figures for the other systems are from their published documentation. FlashDB publishes its RAM as near zero and is drawn at the axis floor. The remdb and shodh-redb figures are their published examples.
Moat
A coordinate carries origin, event, and time in one value
Content addressing is the precedent: Git, IPFS, Nix, and casync each derive an address from content, and none of them derives one from a coordinate that carries those axes.
A decoder a controller can read
The coordinate decoder is a small fixed circuit, 478 cells, checked against every valid code point. A storage controller in an FPGA or an ASIC can read Ktema addresses directly. The hardware IP will be a licence that sits beside the library.
A primitive with a publication record
The primitive has three preprints across six months, a verified decoder, and a coordinate space shared across the SSCCS stack, which no content-addressed store has.
Conformance is the specification
Any conforming implementation can read a volume Ktema wrote, including the neXus and chton layers of the same stack. A second implementation has to pass the same suite, and each deployment adds to the value of the others.
The publication record
- February 2026SSCCS, the computing model the coordinate space belongs to
- July 2026Tagma, the hashless coordinate space
- August 2026The applied measurement
Qdrant Edge and MoteDB bring vector and multimodal search to embedded systems. Ktema is the layer beneath them: the multi-axis coordinate store that fits in 4.2 KB of live heap.
Founder
Taeho Lee, founder of the SSCCS initiative
He is the architect of the addressing primitive that Ktema commercializes, and the author of three preprints published between February and August 2026.
His engineering stack covers C and C++, Rust, chip design and verification (RTL), compilers, and distributed systems. He has worked in software since 2008.
Consumer platforms at scale
Led Android, web, desktop, and cloud development in a team of more than twenty, for a service with more than 45 million monthly users, and built a national map service with street-view VR.
A computer vision venture
Founded and bootstrapped a mobile computer vision company.
The payment core of a mobile bank
Lead software engineer. Rebuilt the payment core of an app with more than 19 million active installs, part of a transformation programme of roughly €700M, under BaFin, GDPR, and PSD2.
Ktema is the product he sells. It stands on the SSCCS stack, the result of nine months of self-funded work that produced the engine, the proofs, and the hardware decoder. He runs the agent runtime that operates the engineering work, and he is the first engineer of the system.
Round
Raising $1.2M at pre-seed
Nine months of self-funded work already produced the engine, the proofs, the publications, and the hardware decoder. The engine risk is retired.
This round funds the commercial layer and closes the last three engineering items the first design partner needs. The commercial milestones come first; the engineering items run through the rest of the 24 months, because the first design partner’s integration depends on them. Those milestones trigger the seed round, and the design wins before it are founder-led.
What this round reaches
Ktema Systems incorporated
The entity formed in the jurisdiction the first design partner and the lead investor choose. Malaysia is one candidate among several.
On-media format complete at version 0.1
The layout, the keys, the encoding, and the derivation of identifiers, fixed.
First design partner signed
With integration started, and the warranty and safety documentation framework defined with that partner.
Use of funds (draft)
- 50%
Engineering and compute
Founder compensation, the agent runtime that carries the engineering work, and the three items the first design partner needs: constrained arena scopes, flash footprint reduction, and a second conforming implementation.
- 15%
Company setup and compliance
The incorporation of Ktema Systems, legal and accounting, and the warranty and safety documentation framework.
- 15%
Design partner and field hire
The first design partner contract, the field-facing first hire, and the design partner pipeline.
- 20%
Reserve
Contingency across the 24-month runway.
- Structure
- Ktema Systems is not incorporated yet, and the jurisdiction is not fixed. Malaysia was the plan and remains one option; the company is open to wherever its first design partner, its investors, and its first hires are. The entity that is formed will hold the Ktema specification and the engine, sell the certified build and the support behind it, and license the decoder to silicon vendors later.
- Open layers
- Ktema itself is proprietary. The layers beneath it, neXus, chton, and syntagma, are Apache 2.0, documented at docs.ssccs.org, and will be held by the SSCCS Foundation, an open-source research foundation to be formed later.
- Runway
- 24 months. A Singapore holding company remains an option for a later round.
- Instrument
- The instrument and the terms are expected to be set with the lead investor; they are not fixed yet.
The endgame is a device that can account for its own history, with no server in the path.