I have been running a prototype OpenClaw agent cluster on Raspberry Pi 4 and Pi 5 units for edge-based AI inference. The setup involves multiple agents coordinating across different physical locations, handling sensitive telemetry and making autonomous decisions. While the inference pipelines are robust, my primary concern is the foundational security of the agent state.

The current stack utilizes TLS 1.3 for communication between nodes, which is well understood. However, the persistent state for each agent—including its operational parameters, learned model weights for local fine-tuning, and cached sensitive data—is currently encrypted using a simple symmetric key stored on the same SD card. This is clearly inadequate for a production deployment.

My specific areas of inquiry for this community are:

* **Key Management for Edge Devices:** How to properly generate, store, and rotate encryption keys for data-at-rest on resource-constrained, physically accessible hardware. I am evaluating the use of a dedicated HSM module (like a TPM or a YubiHSM) for the cluster controller, but the cost/benefit for each individual Pi agent is unclear.
* **Agent State Encryption Schema:** Best practices for structuring the encrypted agent state. Should it be a single encrypted blob, or a structured store with individually encrypted fields? I am particularly concerned about key rotation without losing state.
* **Secure Enclave Alternatives:** On ARM architectures like the Raspberry Pi, are there practical secure enclave or TrustZone implementations that can be leveraged for secret storage without proprietary blobs?

Below is a simplified version of my current state encryption routine, which I know needs to be replaced:

```python
# Current naive implementation
from cryptography.fernet import Fernet
import json

# Key is loaded from a file on the same filesystem
with open('state_key.key', 'rb') as f:
key = f.read()
cipher = Fernet(key)

def save_agent_state(state_dict):
plaintext = json.dumps(state_dict).encode()
encrypted = cipher.encrypt(plaintext)
with open('agent_state.enc', 'wb') as f:
f.write(encrypted)
```

I am seeking discussions on architectural patterns and concrete implementations. What are others using to secure agent state in similar edge deployments?