Ktema SystemsDemo Center
KtemaRecordKletosExecutionKrisisJudgmentDeltaOperationTelosTransportKleisAuthorization

Replayable Agentic Computing

Every autonomous act, accountable.

AI agent books shipment. Drone turns back. Insulin pump holds dose. Robot stops line. Later, someone asks why. System answers from record: what was asked, what it did, and what limited it.

The answer is usually assembled afterwards, from an agent log, a device trace, and rows in a database that were never written to agree. We keep the ask, the act, and the limit in one record at the machine that made it, so the answer is already there when the question arrives.

Demo Center
Space systemSmart meterVision cameraFactory PLCLaptop and mobileMCU droneROS robotMedical deviceWearableVehicle ECUData centerEdge gateway
The same record, from a part to orbit. An agent, a service, or a machine keeps its own record, and another reads it at the same address with no translator between them. One format, so a fleet, a cell, and a product line answer the same way. Connect through your own infrastructure, or through our mission control.

Stack

Six parts, one record format.

Each part stands on its own, and together they carry one record from the ask to the proven act.

Incidents

Everything is asked afterwards.

An incident is settled by what was kept. Six of them, and what the answer takes.

  1. Pump03:14

    The dose was held.

    What happenedA dose was held. Weeks later, someone has to say why.

    TodayThree logs in three places: the readings, the alarm, the model decision.

    The recordThe readings, the earlier occlusion they match, and the entry that held the dose, in one record on the pump.

  2. Robot14:22

    The line stopped.

    What happenedA line stopped, and the shift wants to know which decision did it.

    TodayThe cell log, the robot trace, and the approval, joined by hand.

    The recordThe ask, who took it, what was produced, and who approved it, in one chain.

  3. Drone09:41

    The link dropped.

    What happenedA link dropped, and someone asks what the aircraft saw before it.

    TodayThe flight log ends where the radio ended.

    The recordThe readings ordered by time, with the last acknowledged command, kept on the aircraft.

  4. Vehicle21:07

    The system intervened.

    What happenedThe system braked on its own, and the question is which sensors agreed.

    TodayTwo vendor logs and one model server, with no shared clock.

    The recordBoth readings, the model output, and the rule that allowed the action.

  5. Workflow08:12

    The hand-off failed.

    What happenedWork moved between agents, and stopped moving.

    TodayEach agent kept its own log, and nothing ties the hand-off.

    The recordThe intent, the claim, the tool call, and the record the next agent received.

  6. Software agent11:48

    The agent responded.

    What happenedAn agent answered a customer, and the answer cost money.

    TodayThe platform billing, the model log, and no record of who allowed it.

    The recordThe model, the price, and the authority, in one record beside the result.

01/ 06

What changes

The answer stops being reconstruction.

Three things change: the limit is written first, the ask stays with the act, and the run can be re-entered.

  1. The limit

    The limit is written before the work starts

    A person states the work and its bounds once. A call outside them is refused by the system while it runs, instead of by a review afterwards.

  2. The chain

    The ask and the act are one record

    What was asked, who claimed it, what was done, and what came back stay together. Nothing is joined from separate logs when the question arrives.

  3. The replay

    The run can be re-entered years later

    Every act carries an address anyone can recompute, so the run replays on another target from the record alone.

01/ 03

Proof

The same build answers in a data center and on a 256 KB part.

The measurements that bound it, from a part with no operating system to the comparison with a database.

  1. The part

    8MB512KB1,648B

    The engine on an 8 MB microcontroller

    An ESP32-S3 module with 8 MB of flash and 512 KB of RAM. The engine answers multi-axis questions and keeps its record within 1,648 bytes, so a product that ships this part can answer for itself.

    The initial boot prepares the volume; all subsequent boots operate within this peak.

  2. The hard end

    64 KB of SRAM, and no operating system

    On the RISC-V reference part, with 256 KB of flash and 64 KB of SRAM, the engine and its storage take 32,812 B of static SRAM and 123,782 B of flash, and its heap peaks at 2,163 B. A database needs an operating system and a heap; this answers without either.

  3. The comparison

    What the same question costs elsewhere

    A general database needs an operating system and 100 KB or more of heap. An embedded key-value store keeps one axis and a RAM index. The engine answers across axes with no resident index, so the memory a product reserves does not grow with its history.

  4. Alongside the database

    Keep the database. Send it fewer questions.

    A multi-axis question costs an index per axis. The engine answers it from the record, and the database keeps transactions.

01/ 04

An ESP32-S3-WROOM-1 module on the flight-controller board that carries it.

Operations

The run, seen from where it happens.

Delta is the cockpit: the machines, their records, the bounds around them, and the timeline, in one space.

  1. The run

    A fire on an island, met by the fleet already there

    Survey and thermal drones map the perimeter, a relay holds the link over the strait, and crawlers and boats take the shore. One intent carries every machine, and the operator changes it while the run moves.

  2. The cell

    A workforce runs on one intent

    Servos, conveyors, cameras, maintenance robots, software agents, and the people who run them, in one cell view. An intent is written once, and the cell runs on it.

  3. The span

    35,786km

    Land, air, and orbit in one view

    A rescue run reaches from a satellite at 35,786 km to a drone over the site, with the helicopters, the escorts, and the hospital on the same map.

  4. The seat

    The operator stands inside the run

    On the island, the operator stands in the run: the drones, their record, and the bounds around them, with the intent changed from where the record is read.

  5. The chain

    The ask and the act stay one chain

    A request is stated, claimed, performed, and written as a result, with the link back to the request. One chain across agents, people, machines, and outside systems.

  6. The terms

    The rules are written before the work starts

    A smart contract or a governance rule sets which model may act, at what cost, and on whose authority. The record is checked against it.

  7. The campaign

    A run another team can replay

    A finished run becomes a package that can be handed on and compared against another. The next campaign starts from it.

01/ 07

The campaign data in these views is simulated. Delta is planned to be open source.

Rescue Wing: Island Fire. The intents and records on the left, the cell view of survey, thermal, photo and relay drones with crawlers, boats and rovers in the middle, the island and its shoreline on the right, and the timeline below.

Open

A published format, and the engineering that runs it.

The format and the research are published through the SSCCS Initiative, which the work shares an origin with. A record is evidence only if someone other than its author can check it, so the format has to be public. The engines, the kernels, and the layers above them are separate engineering, and a deployment licenses them.

The format
Published under Apache 2.0, so a second implementation can recompute an address from the fields and check a record it did not write.
The research
Four preprints on the format and the addressing, from February to September 2026.
The initiative
The SSCCS Initiative publishes the format and carries it as the neutral source for the compliance frameworks. It is a non-profit and open source foundation.
The engineering
The engines, the device kernels, and the layers above them are built here, outside the published material, and a deployment licenses them.

Fit

Where this pays for itself.

The question spans several axes, and the answer has to exist where the record was made.

  1. Everyday

    The same shape on things people already run

    A service that keeps a year of runs. A bike computer that keeps a season of rides.

    Which deploy cost the latency, or what changed since Monday, settled in the process itself. No account and no round trip.

  2. Critical systems

    Where the record has to survive the audit

    Ten to thirty years in service, and the organization that shipped it is accountable for what it did.

    Defense programs, medical device makers, vehicle programs, and energy operators. The machine outlives the deployment, and the record has to outlive the machine.

    Medical and automotive: the EU AI Act requires logging over the life of a high-risk system. Industrial and energy: the CRA reporting duty has applied since 11 September 2026, with main obligations from 11 December 2027. Defense answers to its own regime.

  3. The boundary

    The line sits above the engine

    The engine holds the record. Everything above the line is yours.

    A record made where the work runs is proved from its own history. Your database, your cloud, and your services stay above it, and the format does not change.

01/ 03

Contact

Building a system that has to answer for itself?

Write to us. Bring the system that has to answer for what it did.

Write to us