Technologies /
From Device Identity to Verifiable Autonomy
Establishing trust when software makes decisions autonomously
Connected devices, robots and artificial intelligence agents are becoming increasingly autonomous.
Machines decide when to start and stop processes. Vehicles make decisions based on sensor information. Industrial equipment diagnoses conditions and initiates corrective actions. AI agents use web services and trigger transactions without a person being present at every step - or indeed any step.
This creates a problem that is easy to overlook:
When something happens, can we later prove what happened, who or what caused it, and whether the record itself can be trusted?
Traditional security mechanisms primarily answer a question about the present:
Is this device or user allowed to do this?
ControlThings’ technology addresses the question that comes afterwards:
Can we prove what happened?
This distinction is at the heart of verifiable event logging.
The foundation: Cryptographic identity
A cryptographic identity gives a device or user an identity that can be proven through cryptography.
In this paper, actor is used as a practical umbrella term for anything capable of performing an action — a person, device, machine, robot or software agent.
Instead of relying on a shared secret such as an API key, a device possesses a private cryptographic key. Its corresponding public key can be used by others to verify signatures made by that device.
This makes it possible to distinguish between:
“Someone possessing this secret made the request.”
and:
“This particular device, possessing this private key, made the request.”
Certificate infrastructure makes such identities practical at scale. The state of the art X.509 certificates can associate public keys with devices and users, while certificate management provides mechanisms for issuing, revoking and rotating those identities. ControlThings’ CertManager provides certification, certificate revocation and certificate rotation for devices and mobile applications.
But having a cryptographic identity in devices is not the end goal. It is the foundation on which trustworthy actions can be built.
The missing piece: trustworthy history
Suppose an industrial controller receives an instruction to change the operating state of a machine.
A conventional security system may be able to establish that the sender was authenticated and authorized.
But months later, when investigating an incident, several new questions arise:
- Who actually initiated the operation?
- What exactly was requested?
- Which device executed it?
- What happened immediately before it?
- Was the recorded sequence subsequently altered?
- Was an event deleted?
- Can the recorded history itself be trusted?
A conventional log file does not necessarily provide these guarantees.
Even if the log is protected against unauthorized access, someone with sufficient privileges may potentially modify, delete or reorder its contents.
This becomes increasingly important as systems become autonomous.
When a human operator makes a decision, there may be a person who can explain what they intended.
When a distributed autonomous system makes thousands of decisions without direct human intervention, the event history may be the only practical evidence of why the actors involved arrived at a particular state.
Verifiable Event Logging
ControlThings’ patented technology, US 11,343,107 B2, “System for Method for Secured Logging of Events,” addresses this problem.
The patent was granted on May 24, 2022, to ControlThings Oy Ab.
The basic idea is deceptively simple:
Don’t merely record events. Make the history itself cryptographically verifiable.
Each event is connected to the preceding event. The position of a new event in the history is cryptographically locked, while the device generating the event signs the information associated with that event and its intended position.
The logging device independently verifies the request before accepting it into the history and adds its own signature when the event is accepted.
Conceptually:
EVENT N
│
│ cryptographic reference
▼
EVENT N+1
│
│ cryptographic reference
▼
EVENT N+2
│
│ cryptographic reference
▼
EVENT N+3
Changing an earlier event therefore affects the cryptographic relationships that follow it.
The patented mechanism goes further than simply hashing a log file: the triggering device signs the event information together with information identifying its position in the chain, while the logging device verifies the request and signs its acceptance. This provides evidence both of event origin and of the agreed position of the event in the history.
Not just an immutable log
The important property is not simply that events are difficult to modify. The system is designed to make important facts independently verifiable.
A verifiable event history can establish:
Who triggered an event.
What was triggered.
Which system accepted and recorded it.
Where in the sequence the event belongs.
Whether the history has subsequently been altered.
This corresponds closely to the original ControlThings concept of a verifiable immutable chain of events, including verifiable event producer, command, target system, event order, chain coherence and immutability.
That changes the role of logging. A traditional log is primarily a record for inspection, but is can be difficult to establish it authenticity. In contrast, a verifiable log is evidence because it is not editable by a single person or entity.
A Shared Chain of Evidence
There is another important distinction between a conventional audit trail and a verifiable event history: the events do not have to be recorded by one trusted owner.
Consider an autonomous device operating in the real world. Its owner may keep in a cloud database a complete log of everything the device does via a remote data link. But if that same owner has full control over the device and its logging infrastructure, an outside party has little reason to blindly trust that log. The owner may have the technical ability to alter, remove or reorder events after the fact.
The problem becomes even more apparent when autonomous devices interact with other devices belonging to different parties.
A transaction may involve several independent actors:
DEVICE A
│
│ requests / action
▼
DEVICE B
│
│ response / action
▼
DEVICE C
Each party can keep its own log, but the logs are ultimately controlled by the parties that operate them. A dispute can therefore become a matter of deciding whose records to trust.
A verifiable event history provides another approach.
Actors can obtain cryptographic evidence from each other as events occur.
An event can be signed by the actor that generated it and incorporated into a cryptographically linked history. Other participating actors can retain that evidence and verify it independently. Participants can also save the state of the history, and later present it as indeniable proof.
The resulting history can therefore span many independent entities, rather than being merely the private log of the owner of one autonomous device.
ACTOR A ACTOR B ACTOR C
│ │ │
│ signed evidence │ signed evidence │
└───────────┐ └───────────┐ │
▼ ▼ │
┌─────────────────────────────────────┐
│ VERIFIABLE CHAIN OF EVENTS │
│ │
│ A → B → C → A → B → C → ... │
└─────────────────────────────────────┘
This changes the trust model fundamentally.
Instead of asking:
“Can I trust the log maintained by the owner of this device?”
we can ask:
“Can the participating actors provide cryptographic evidence of the events in which they took part?”
An actor does not need to trust another actor’s private logging infrastructure merely because that actor owns the device. The evidence can be checked cryptographically, and subsequent alteration of the recorded event history can be detected.
This is particularly valuable when autonomous actors cross organisational boundaries. A machine may interact with another company’s machine, a vehicle may interact with infrastructure operated by a third party, or a software agent may invoke services belonging to another organisation.
The audit trail can become a shared chain of evidence between independent actors, rather than a log controlled by a single owner.
For increasingly autonomous systems, this provides an important foundation for accountability: events can remain verifiable even when no single party can be assumed to be the trusted keeper of the complete history.
Why autonomy makes this increasingly important
Autonomous actors change the nature of accountability.
Consider a future industrial environment in which:
- sensors detect a condition;
- an edge controller evaluates it;
- an autonomous software component decides that action is required;
- another device executes the action;
- the resulting state causes another autonomous decision.
There may be no human decision-maker at any individual step.
The question after an incident is therefore not simply:
Who operated the machine?
It may instead be:
What sequence of autonomous decisions and events caused the machine to reach this state?
For such environments, trustworthy history becomes part of the safety and accountability infrastructure.
The objective is not to prevent autonomous actors from acting. Quite the opposite: autonomy becomes more practical when their actions can subsequently be understood and verified.
Identity, action and evidence
This gives us a useful way of looking at the entire ControlThings technology stack, where an actor means anything capable of performing an action — a person, device, machine, robot or software agent:
CRYPTOGRAPHIC IDENTITY
│
▼
CERTIFICATE MANAGEMENT
│
▼
MUTUAL AUTHENTICATION
│
▼
TRUSTED ACTION
│
▼
SIGNED EVENT RECORD
│
▼
CRYPTOGRAPHIC EVENT CHAIN
│
▼
VERIFIABLE EVENT HISTORY
Certificate management and secure device identity are therefore supporting infrastructure.
They establish who the participants are.
Mutual authentication establishes trust between them.
The patented event-logging technology addresses the next question:
What did the actor actually do, and can we prove it afterwards?
ControlThings’ work specifically brings certificate management, device registration, mutual authentication and verifiable audit trails together into a common foundation.
Designed for the edge
An important aspect of the patented approach is that it does not require a global distributed consensus system, such as a blockchain.
Blockchain-style approaches provide distributed consensus and replication, but with significant computational and network costs. ControlThings’ verifiable audit trail provides secured, tamper-evident event logging without those requirements, something that is particularly relevant to embedded and IoT systems.
A vehicle, industrial controller, machine or other edge device may have:
- limited computing resources;
- intermittent connectivity;
- no reliable connection to a central cloud;
- strict latency requirements;
- a requirement to continue operating when disconnected.
Trustworthy event history therefore needs to work where the event happens, rather than requiring every event to be immediately sent to a central service.
The patent describes, for example, an implementation involving a vehicle, with a logging device implemented as an electronic control unit and a separate triggering device.
From logs to evidence
The ultimate purpose is not cryptography for its own sake. It is evidence. When connected actors control increasingly important parts of our physical and digital environment, we need to be able to distinguish between:
“The system says this happened.”
and:
“The system can provide cryptographic evidence that this happened, in this order, and that the recorded history has not been altered.”
That distinction becomes particularly valuable for:
- autonomous and semi-autonomous machines;
- industrial systems;
- vehicles and fleets;
- maintenance and service histories;
- supply chains;
- regulatory and compliance processes;
- insurance and warranty claims;
- security investigations and forensics.
The original ControlThings work already described these broader motivations: verifiable logs can provide evidence that can be checked by all involved parties, rather than simply trusted, while device identity and certificate management make it possible to associate events with authenticated participants.
The ControlThings proposition
ControlThings developed technology around a simple principle:
If connected actors are going to act autonomously, we should not only secure their ability to act — we should also make their actions verifiable afterwards.
Cryptographic identity establishes trustworthy participants.
Certificate management makes those identities practical to operate at scale.
Mutual authentication establishes trusted communication.
And Verifiable Event Logging provides a cryptographically secured history of what happened.
The result is a foundation for connected environments where autonomy does not have to mean loss of accountability.
The more autonomous the actors become, the more important it is to have a history that can be trusted.
For reference
US Patent 11,343,107 B2 — “System for Method for Secured Logging of Events”
ControlThings Oy Ab. Granted May 24, 2022.
https://patents.google.com/patent/US11343107B2/en
US Patent 11,343,107 B2 — patent PDF
Google Patents / USPTO publication copy.
https://patentimages.storage.googleapis.com/63/8c/90/0f03417de7abe4/US11343107.pdf