-
Public Apache-2.0 SYNQAGI StateDelta Edge repo with Arm64 edge runtime, tests, CI, and reproducible local AI benchmarks.
Inspiration
Industrial and physical AI systems often need to answer a simple but critical question: does the real-world state still match what is expected?
That comparison should not depend on sending sensitive operational data to the cloud, and a generative model should not be allowed to override deterministic safety logic.
SYNQAGI StateDelta Edge was built around that principle: combine deterministic expected-vs-observed state evaluation with local advisory AI, designed for low-power Arm edge deployment.
What it does
StateDelta evaluates a structured State Capsule containing an expected state, observed measurements, tolerances, conformance rules, safety rules, and allowed actions.
The system can represent physical or process signals such as temperature, vibration, load, current, pressure, logs, or modality-derived measurements.
The deterministic engine:
- validates the State Capsule contract
- compares observed values against expected conditions
- calculates state, severity, delta, and evidence
- recommends an operational action
- passes that action through a deterministic safety validator
- produces the final validated action and human-review requirement
A local LLM can then act as an advisory reasoning layer.
The important architectural boundary is that the model does not receive unrestricted authority. It receives only the deterministic assessment, validated delta/evidence, and the list of allowed actions. Model-generated evidence outside the deterministic delta is rejected, and the deterministic safety layer remains the final operational authority.
How I built it
The core implementation is written in Python with a schema-driven State Capsule and Decision contract.
For local AI integration I implemented an Ollama runtime adapter using Python standard-library networking rather than an additional client dependency.
The adapter:
- only accepts loopback/local Ollama endpoints
- uses deterministic inference settings
- dynamically restricts recommended actions to the capsule's allowed actions
- requests structured JSON output
- prevents the model from re-evaluating hidden/raw safety rules
- rejects evidence paths that were not produced by the deterministic engine
A reproducible local model baseline was also created using llama3.1:8b.
During testing, the unrestricted model initially misinterpreted a safety rule and recommended STOP even though that rule had not been violated. Instead of accepting the model output, I changed the architecture so that the model receives only deterministic assessment and validated evidence.
After that change, the model correctly interpreted the test case as:
FAIL → OUT_OF_TOLERANCE → HIGH → REDUCE_LOAD
while the deterministic safety validator still remained authoritative.
The current repository has automated tests across Python 3.10, 3.11, and 3.12, with the full local suite passing 13/13 tests.
Challenges
The biggest challenge was not simply running an LLM locally. It was defining where AI should and should not have authority.
A model can provide useful interpretation, but in a physical system it can also invent evidence, misunderstand a threshold, or recommend an unsafe action.
That led to the core design decision of StateDelta Edge:
deterministic conformance and safety first, generative reasoning second.
Another challenge is preparing the same architecture for constrained Arm64 edge hardware, where memory, latency, model size, and power efficiency all matter.
What I learned
Local AI optimization is not only about tokens per second.
For physical AI, optimization also means reducing the amount of information the model must reason over, constraining its output space, validating its evidence, and keeping safety-critical decisions deterministic.
That architectural reduction makes the system safer while also making the eventual edge workload smaller and more practical.
What's next
The target edge platform is NVIDIA Jetson Orin on Arm64.
The next module is a Local Decision Orchestrator that will combine the deterministic StateDelta result and local model advisory result into one auditable response while preserving the deterministic validated_action as the final authority.
From there, the work moves to Arm-device profiling and optimization: model footprint, latency, memory usage, inference performance, and deployment efficiency on the target edge hardware.
Challenge-period development
This submission is built for the Physical AI track.
During the challenge period, SYNQAGI StateDelta Edge was meaningfully developed and extended with a reproducible local Ollama model benchmark, documented runtime baseline, and a new local advisory runtime adapter integrated with the deterministic StateDelta pipeline.
The runtime work added local-only endpoint enforcement, structured model output, dynamic action constraints, deterministic-delta-only context, and evidence-path validation. The implementation was covered by new automated tests and merged through pull requests with CI passing across Python 3.10, 3.11, and 3.12.
These challenge-period changes moved the project from its initial deterministic StateDelta architecture toward a working local-AI edge runtime while preserving deterministic safety as the final operational authority.
Log in or sign up for Devpost to join the conversation.